ACE_Module_Base类

 

 

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),