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>删除任务
/**
* Don't change this value without updating the same enum in class
* ACE_Stream...
* The <M_DELETE_READER> and <M_DELETE_WRITER> flags may be or'ed
* together.
*/
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),