Fix compilation error.

examples/echo_client/echo_client.cpp

@@ -30,12 +30,12 @@
 #define ASCS_MSG_BUFFER_SIZE 1000000
 #define ASCS_MAX_SEND_BUF (10 * ASCS_MSG_BUFFER_SIZE)
 #define ASCS_MAX_RECV_BUF (10 * ASCS_MSG_BUFFER_SIZE)
-#define ASCS_DEFAULT_UNPACKER flexible_unpacker<>
+#define ASCS_DEFAULT_UNPACKER flexible_unpacker<std::string>
 //this unpacker only pre-allocated a buffer of 4000 bytes, but it can parse messages up to ST_ASIO_MSG_BUFFER_SIZE (here is 1000000) bytes,
 //it works as the default unpacker for messages <= 4000, otherwise, it works as non_copy_unpacker
 #elif 1 == PACKER_UNPACKER_TYPE
 #define ASCS_DEFAULT_PACKER packer2<unique_buffer<std::string>, std::string>
-#define ASCS_DEFAULT_UNPACKER unpacker2<unique_buffer, std::string, flexible_unpacker<>>
+#define ASCS_DEFAULT_UNPACKER unpacker2<unique_buffer<std::string>, std::string, flexible_unpacker<std::string>>
 #elif 2 == PACKER_UNPACKER_TYPE
 #undef ASCS_HEARTBEAT_INTERVAL
 #define ASCS_HEARTBEAT_INTERVAL	0 //not support heartbeat

examples/echo_server/echo_server.cpp

@@ -30,12 +30,12 @@
 #define ASCS_MSG_BUFFER_SIZE 1000000
 #define ASCS_MAX_SEND_BUF (10 * ASCS_MSG_BUFFER_SIZE)
 #define ASCS_MAX_RECV_BUF (10 * ASCS_MSG_BUFFER_SIZE)
-#define ASCS_DEFAULT_UNPACKER flexible_unpacker<basic_buffer>
+#define ASCS_DEFAULT_UNPACKER flexible_unpacker<>
 //this unpacker only pre-allocated a buffer of 4000 bytes, but it can parse messages up to ST_ASIO_MSG_BUFFER_SIZE (here is 1000000) bytes,
 //it works as the default unpacker for messages <= 4000, otherwise, it works as non_copy_unpacker
 #elif 1 == PACKER_UNPACKER_TYPE
 #define ASCS_DEFAULT_PACKER packer2<unique_buffer<basic_buffer>, basic_buffer, packer<basic_buffer>>
-#define ASCS_DEFAULT_UNPACKER unpacker2<unique_buffer, basic_buffer, flexible_unpacker<basic_buffer>>
+#define ASCS_DEFAULT_UNPACKER unpacker2<unique_buffer<basic_buffer>, basic_buffer, flexible_unpacker<>>
 #elif 2 == PACKER_UNPACKER_TYPE
 #undef ASCS_HEARTBEAT_INTERVAL
 #define ASCS_HEARTBEAT_INTERVAL	0 //not support heartbeat
@@ -164,13 +164,14 @@ protected:
 };
 
 #if ASCS_HEARTBEAT_INTERVAL > 0
-typedef server_socket_base<ext::packer, ext::unpacker> normal_socket;
+typedef server_socket_base<packer<>, unpacker<>> normal_socket;
 #else
 //demonstrate how to open heartbeat function without defining macro ASCS_HEARTBEAT_INTERVAL
-class normal_socket : public server_socket_base<ext::packer<>, ext::unpacker<>>
+class normal_socket : public server_socket_base<packer<>, unpacker<>>
 {
 public:
 	normal_socket(i_server& server_) : server_socket_base<ext::packer<>, ext::unpacker<>>(server_) {}
+	//sometime, the default packer brings name conflict with the socket's packer member function, prefix namespace can resolve this conflict.
 
 protected:
 	//demo client needs heartbeat (macro ASCS_HEARTBEAT_INTERVAL been defined), please note that the interval (here is 5) must be equal to
@@ -190,7 +191,7 @@ protected:
 	virtual bool on_accept(object_ctype& socket_ptr) {stop_listen(); return true;}
 };
 
-class short_connection : public server_socket_base<ext::packer<>, ext::unpacker<>>
+class short_connection : public server_socket_base<packer<>, unpacker<>>
 {
 private:
 	typedef server_socket_base<ext::packer<>, ext::unpacker<>> super;

include/ascs/ext/packer.h

@@ -143,14 +143,14 @@ public:
 };
 
 //protocol: length + body
-//T can be unique_buffer<XXXX> or shared_buffer<XXXX>, the latter makes output messages seemingly copyable.
-//C is XXXX or a class that inherit from XXXX (because XXXX can be a virtual interface).
+//Buffer can be unique_buffer<XXXX> or shared_buffer<XXXX>, the latter makes output messages seemingly copyable.
+//T is XXXX or a class that inherit from XXXX (because XXXX can be a virtual interface).
 //Packer is the real packer who packs messages, which means packer2 is just a wrapper.
-template<typename T = unique_buffer<i_buffer>, typename C = string_buffer, typename Packer = packer<>>
-class packer2 : public i_packer<T>
+template<typename Buffer = unique_buffer<i_buffer>, typename T = string_buffer, typename Packer = packer<>>
+class packer2 : public i_packer<Buffer>
 {
 private:
-	typedef i_packer<T> super;
+	typedef i_packer<Buffer> super;
 
 public:
 	static size_t get_max_msg_size() {return Packer::get_max_msg_size();}
@@ -158,7 +158,7 @@ public:
 	using super::pack_msg;
 	virtual typename super::msg_type pack_msg(const char* const pstr[], const size_t len[], size_t num, bool native = false)
 	{
-		auto raw_msg = new C();
+		auto raw_msg = new T();
 		auto str = Packer().pack_msg(pstr, len, num, native);
 		raw_msg->swap(str);
 		return typename super::msg_type(raw_msg);
@@ -170,7 +170,7 @@ public:
 			return false;
 
 		auto head_len = packer_helper::pack_header(len);
-		auto raw_msg = new C();
+		auto raw_msg = new T();
 		raw_msg->assign((const char*) &head_len, ASCS_HEAD_LEN);
 		msg_can.emplace_back(raw_msg);
 		msg_can.emplace_back(std::move(msg));
@@ -184,7 +184,7 @@ public:
 			return false;
 
 		auto head_len = packer_helper::pack_header(len);
-		auto raw_msg = new C();
+		auto raw_msg = new T();
 		raw_msg->assign((const char*) &head_len, ASCS_HEAD_LEN);
 		msg_can.emplace_back(raw_msg);
 		msg_can.emplace_back(std::move(msg1));
@@ -199,7 +199,7 @@ public:
 			return false;
 
 		auto head_len = packer_helper::pack_header(len);
-		auto raw_msg = new C();
+		auto raw_msg = new T();
 		raw_msg->assign((const char*) &head_len, ASCS_HEAD_LEN);
 		out.emplace_back(raw_msg);
 		out.splice(std::end(out), in);
@@ -208,7 +208,7 @@ public:
 	}
 	virtual typename super::msg_type pack_heartbeat()
 	{
-		auto raw_msg = new C();
+		auto raw_msg = new T();
 		auto str = Packer().pack_heartbeat();
 		raw_msg->swap(str);
 		return typename super::msg_type(raw_msg);

include/ascs/ext/unpacker.h

@@ -178,7 +178,7 @@ protected:
 //this unpacker has a fixed buffer (4000 bytes), if messages can be held in it, then this unpacker works just as the default unpacker,
 // otherwise, a dynamic std::string will be created to hold big messages, then this unpacker works just as the non_copy_unpacker.
 //T can be std::string or basic_buffer, the latter will not fill its buffer in resize invocation, so is more efficient.
-template<typename T = std::string>
+template<typename T = basic_buffer>
 class flexible_unpacker : public i_unpacker<T>
 {
 private:
@@ -388,14 +388,14 @@ protected:
 };
 
 //protocol: length + body
-//Buffer can be unique_buffer or shared_buffer, the latter makes output messages seemingly copyable.
-//T can be std::string or basic_buffer, and the output message type will be Buffer<T>.
+//Buffer can be unique_buffer<XXXX> or shared_buffer<XXXX>, the latter makes output messages seemingly copyable.
+//T is XXXX or a class that inherit from XXXX (because XXXX can be a virtual interface).
 //Unpacker can be the default unpacker or flexible_unpacker, which means unpacker2 is just a wrapper.
-template<template<typename> class Buffer = shared_buffer, typename T = std::string, typename Unpacker = unpacker<>>
-class unpacker2 : public i_unpacker<Buffer<T>>
+template<typename Buffer = shared_buffer<std::string>, typename T = std::string, typename Unpacker = unpacker<>>
+class unpacker2 : public i_unpacker<Buffer>
 {
 private:
-	typedef i_unpacker<Buffer<T>> super;
+	typedef i_unpacker<Buffer> super;
 
 public:
 	virtual void stripped(bool stripped_) {super::stripped(stripped_); unpacker_.stripped(stripped_);}