ACE示例3 - ACE Proactor

这个示例将用ACE Proactor来实现echo server
代码量差不多只有完成端口的1/3

ACE Reactor的实现
http://www.cppblog.com/sandy/archive/2006/02/17/3308.html

完成端口的实现
http://www.cppblog.com/sandy/archive/2007/06/06/25670.html

当然如果你理解了完成端口，ACE Proactor就很简单了

大概的过程是这个样子的
1.使用ACE_Asynch_Acceptor来建立服务器端的socket,然后bind,listen等待Accept并创建IOCP
(相对于ACE Reactor的ACE_Acceptor）
2.当出现完成事件（GetQueuedCompletionStatus）返回时，调用用户的处理接口来处理，这是一个派生于ACE_Service_Handler的子类
（相对于ACE  Reactor的ACE_Svc_Handler）

ACE Reactor和Proactor最大的不同就是

ACE Reactor在处理读写事件的时候，要使用peer().recv/send来接收/发送数据。
而ACE Proactor在处理读写事件的时候,数据已经被读到用户的缓冲区了，典型的"先斩后奏"

ACE Proactor比ACE Reactor麻烦的地方是需要手工去投递异步读写的请求。
可以通过下面的代码来去体会。

==========代码===============

#ifdef _DEBUG
#pragma comment(lib, " ACED.lib " )
#else
#pragma comment(lib, " ACE.lib " )
#endif

#include  " ace/OS_main.h "
#include  " ace/OS_NS_sys_socket.h "
#include  " ace/ACE.h "
#include  " ace/Service_Object.h "
#include  " ace/Asynch_IO.h "
#include  " ace/Proactor.h "
#include  " ace/message_block.h "
#include  " ace/Asynch_Acceptor.h "
#include  " ace/INET_Addr.h "


class  Echo_Service :  public  ACE_Service_Handler
{
public :
   ~ Echo_Service ()
   {
      if  ( this -> handle ()  !=  ACE_INVALID_HANDLE)
       ACE_OS::closesocket ( this -> handle ());
   }

     virtual   void  open (ACE_HANDLE h, ACE_Message_Block & )
    {
         this -> handle (h);
         if  ( this -> reader_.open ( * this )  !=   0   ||   this -> writer_.open ( * this )  !=   0    )
        {
            ACE_ERROR ((LM_ERROR, ACE_TEXT ( " %p/n " ),ACE_TEXT ( " Echo_Service open " )));
            delete  this ;
             return ;
        }

        ACE_Message_Block  * mb;
        ACE_NEW_NORETURN (mb, ACE_Message_Block ( 1024 ));
         if  ( this -> reader_.read ( * mb, mb -> space ())  !=   0 )
        {
            ACE_ERROR ((LM_ERROR, ACE_TEXT ( " %p/n " ),ACE_TEXT ( " Echo_Service begin read " )));
            mb -> release ();
            delete  this ;
             return ;
        }
    }

   virtual   void  handle_read_stream( const  ACE_Asynch_Read_Stream::Result  & result)
    {
      ACE_Message_Block  & mb  =  result.message_block ();
       if  ( ! result.success ()  ||  result.bytes_transferred ()  ==   0 )
        {
          mb.release ();
          delete  this ;
        }
       else
        {
           if  ( this -> writer_.write (mb, mb.length ())  ==   - 1 )
            {
              ACE_ERROR ((LM_ERROR,
                          ACE_TEXT ( " %p/n " ),
                          ACE_TEXT ( " starting write " )));
              mb.release ();
            }
           else
            {
              ACE_Message_Block  * new_mb;
              ACE_NEW_NORETURN (new_mb, ACE_Message_Block ( 1024 ));
               this -> reader_.read ( * new_mb, new_mb -> space ());
            }
        }
       return ;
    }

   virtual   void  handle_write_stream
    ( const  ACE_Asynch_Write_Stream::Result  & result)
  {
    ACE_Message_Block  & mb  =  result.message_block ();
    mb.release ();
     return ;
  }

private :
  ACE_Asynch_Read_Stream reader_;
  ACE_Asynch_Write_Stream writer_;
};

typedef ACE_Asynch_Acceptor < Echo_Service >  MyAcceptor;
int  main( int  argc,  char   * argv[])
{
    ACE_INET_Addr addr( 1500 );
    MyAcceptor server;

     if (server.open(addr) ==- 1 )
    {
        ACE_DEBUG ((LM_DEBUG,
            ACE_TEXT ( " (%P|%t) %p/n " ),
            ACE_TEXT ( " bind failed " )));
         return   1 ;
    }

     while ( 1 ){
        ACE_Proactor::instance () -> proactor_run_event_loop ();
    }

     return   0 ;
}