ACE_Module_Base模块只定义
class ACE_Export ACE_Module_Base { public: enum { /// Indicates that <close> should not delete any Tasks. 指示<close>不要删除任何队列 M_DELETE_NONE = 0, /// Indicates that <close> should delete the writer Task. 指示<close>删除写任务 M_DELETE_READER = 1, /// Indicates that <close> should delete the reader Task. 指示<close>删除读任务 M_DELETE_WRITER = 2, /// Indicates that <close> deletes the Tasks. 指示<close>删除任务 M_DELETE = 3 }; }; ACE_Module
ACE_Module 是基于System V流的概念，它包括一对任务，一个是处理upstream，一个是处理downstream，一般而言你需要子类化该类，除非你子类化ACE_Task.简单一点的说ACE_Module它提供了对一对任务(读和写)的管理高级封装，方便流读写任务的指针出入和关闭处理，因为它代表在流的栈的某层的模块，下面就会说道流ACE_Stream的这个对象。 template <ACE_SYNCH_DECL> class ACE_Module : public ACE_Module_Base { 以模块名字<module_name>作为标识读<reader>写<writer>任务创建和初始化。初始化缺省读写任务为空。 ACE_Module (const ACE_TCHAR *module_name, ACE_Task<ACE_SYNCH_USE> *writer = 0, ACE_Task<ACE_SYNCH_USE> *reader = 0, void *args = 0, int flags = M_DELETE); 与构造函数类似，以模块名字<module_name>作为标识读<reader>写<writer>任务创建和初始化。初始化缺省读写任务为空。根据标识flags_参数注册读写，关闭，删除，不能在<ACE_Task::module_closed>调用 int open (const ACE_TCHAR *module_name, ACE_Task<ACE_SYNCH_USE> *writer = 0, ACE_Task<ACE_SYNCH_USE> *reader = 0, void *a = 0, int flags = M_DELETE); 关闭模块和任务，标记flags参数可以使用覆盖缺省的行为，那取决以前面的<open>,<reader>,<writer>的<flag>的值。先前的M_DELETE[_XXX]不能被覆盖，不能在<ACE_Task::module_closed>调用 int close (int flags = M_DELETE_NONE); ACE_Task处理例程，得到写任务。 ACE_Task<ACE_SYNCH_USE> *writer (void); 设置写任务。<flags>可以使用来指定模块可以通过调用关闭或析构来删除的写任务。先前的任务如果存在，它会关闭。写任务是否可以删除取决参数flags。不能在<ACE_Task::module_closed>调用 void writer (ACE_Task<ACE_SYNCH_USE> *q, int flags = M_DELETE_WRITER); 得到读任务 ACE_Task<ACE_SYNCH_USE> *reader (void); void reader (ACE_Task<ACE_SYNCH_USE> *q, int flags = M_DELETE_READER); 在<ACE_Module>设置和获取兄弟任务 /// Set and get pointer to sibling <ACE_Task> in an <ACE_Module> ACE_Task<ACE_SYNCH_USE> *sibling (ACE_Task<ACE_SYNCH_USE> *orig); 得到模块标识名字 const ACE_TCHAR *name (void) const; 设置模块标识名称 void name (const ACE_TCHAR *); 获取传入任务的参数 void *arg (void) const; 设置传入任务的参数 void arg (void *); 连接其他上游的栈的模块 void link (ACE_Module<ACE_SYNCH_USE> *m); 获取流中模块指针 ACE_Module<ACE_SYNCH_USE> *next (void); 获取流中模块指针 void next (ACE_Module<ACE_SYNCH_USE> *m); 动态分配hooks ACE_ALLOC_HOOK_DECLARE; private: 读写任务关闭操作 int close_i (int which, int flags); 一对读写任务指针 ACE_Task<ACE_SYNCH_USE> *q_pair_[2]; ACE_Module.名字 ACE_TCHAR name_[MAXNAMLEN + 1]; 栈中的下一个ACE_Module ACE_Module<ACE_SYNCH_USE> *next_; void *arg_; 任务如何删除关闭的标记 int flags_; }; } ACE_Stream主要是ASX抽象类，模型来自System V流。它包含一个<ACE_Modules>栈，每个又包含一对读写任务对。该类主要是对流头和尾ACE_Module模块的链表栈的方式处理和维护。流在多协议栈的消息块处理(put,get)提供很方便的管理。 ACE_Stream流栈 put/get(ACE_Message_Block)
template <ACE_SYNCH_DECL> class ACE_Stream { virtual int open (void *arg, ACE_Module<ACE_SYNCH_USE> *head = 0, ACE_Module<ACE_SYNCH_USE> *tail = 0); virtual int close (int flags = M_DELETE); virtual ~ACE_Stream (void); virtual int push (ACE_Module<ACE_SYNCH_USE> *mod); virtual int pop (int flags = M_DELETE); virtual int top (ACE_Module<ACE_SYNCH_USE> *&mod); virtual int insert (const ACE_TCHAR *prev_name, ACE_Module<ACE_SYNCH_USE> *mod); virtual int replace (const ACE_TCHAR *replace_name, ACE_Module<ACE_SYNCH_USE> *mod, int flags = M_DELETE); virtual int remove (const ACE_TCHAR *mod, int flags = M_DELETE); virtual ACE_Module<ACE_SYNCH_USE> *head (void); virtual ACE_Module<ACE_SYNCH_USE> *tail (void); virtual ACE_Module<ACE_SYNCH_USE> *find (const ACE_TCHAR *mod); virtual int link (ACE_Stream<ACE_SYNCH_USE> &); virtual int unlink (void); virtual int put (ACE_Message_Block *mb, ACE_Time_Value *timeout = 0); */ virtual int get (ACE_Message_Block *&mb, ACE_Time_Value *timeout = 0); 指向流的头指针 ACE_Module<ACE_SYNCH_USE> * stream_head_; 指向流尾的指针 ACE_Module<ACE_SYNCH_USE> * stream_tail_; /// Pointer to an adjoining linked stream. ACE_Stream<ACE_SYNCH_USE> * linked_us_; }
流模块 ustream流头 ACE_Stream_Head，ustream.流尾 ACE_Stream_Tail， ACE_Thru_Task提供流层任务处理基层类，在实际的运用中，继承这些类并在svc()实现流数据的处理。 template <ACE_SYNCH_DECL> class ACE_Stream_Head : public ACE_Task<ACE_SYNCH_USE> { public: virtual int open (void *a = 0); virtual int close (u_long flags = 0); virtual int put (ACE_Message_Block *msg, ACE_Time_Value * = 0); virtual int svc (void); virtual int init (int argc, ACE_TCHAR *argv[]); virtual int info (ACE_TCHAR **info_string, size_t length) const; virtual int fini (void); private: /// Performs canonical flushing at the ACE_Stream Head. int control (ACE_Message_Block *); int canonical_flush (ACE_Message_Block *); }; ustream.流尾 template <ACE_SYNCH_DECL> class ACE_Stream_Tail : public ACE_Task<ACE_SYNCH_USE> { virtual int open (void *a = 0); virtual int close (u_long flags = 0); virtual int put (ACE_Message_Block *msg, ACE_Time_Value * = 0); virtual int svc (void); virtual int init (int argc, ACE_TCHAR *argv[]); virtual int info (ACE_TCHAR **info_string, size_t length) const; virtual int fini (void); } template <ACE_SYNCH_DECL> class ACE_Thru_Task : public ACE_Task<ACE_SYNCH_USE> { virtual int open (void *a = 0); virtual int close (u_long flags = 0); virtual int put (ACE_Message_Block *msg, ACE_Time_Value * = 0); virtual int svc (void); virtual int init (int argc, ACE_TCHAR *argv[]); virtual int info (ACE_TCHAR **info_string, size_t length) const; virtual int fini (void); } 这里可以看到svc函数是个空函数，运用的时候实现这个函数 template <ACE_SYNCH_DECL> int ACE_Thru_Task<ACE_SYNCH_USE>::svc (void) { ACE_TRACE ("ACE_Thru_Task<ACE_SYNCH_USE>::svc"); return -1; } 结合ACE0015例子 首先看看对象 class Handler : public ACE_Svc_Handler 客户对象 class Protocol_Stream 协议流对象 class Recv : public Protocol_Task 接收任务 class Xmit : public Protocol_Task 发送任务 class Protocol_Task : public ACE_Task<ACE_MT_SYNCH> 他们的关系如下： Recv和Xmit都是继承任务类ACE_Task，分别是ACE_SOCK_Stream上接收客户请求和发送客户数据的封装线程类（ACE_Task又是任务也是线程类）。他们刚好是ACE_SOCK_Stream的一对读写任务类，构成一个ACE_Module实例，然后将ACE_Module实例push(ACE_Module*)压入ACE_Stream中.这样我们使用的协议流的对象变得非常简洁，只需要通ACE_Stream的put，get函数访问消息数据 ACE_Svc_Handler
put /get(ACE_Message_Block *&message),