ACE Task Framework 15 – 기본 샘플2

2013/06/12 by admin

ACE_Task 객체는 next 함수로 링크 관계를 만들수 있습니다. ACE_Message_Block는 cont 함수로 조합 데이터를 만들어 낼수 있습니다.

util.h
#pragma once

#include <ace/Message_Block.h>

ACE_Message_Block& operator<<( ACE_Message_Block& lhs, const char* mdata);

util.cpp
#include "util.h"

#ifdef ONE_DATABLOCK
ACE_Message_Block& operator<<( ACE_Message_Block& lhs, const char* mdata){
    size_t bsize = lhs.size();
   if( 0 ==bsize){
       lhs.size(1024);
       lhs.size(0);
   }

    size_t len  = strlen(mdata)+1;
    lhs.size( bsize+len);

   if( 0==bsize){
       lhs.copy(mdata);
      return lhs;
   }

    ACE_Message_Block* dup = new ACE_Message_Block( lhs.data_block(),ACE_Message_Block::DONT_DELETE );
    dup->rd_ptr(bsize);
    dup->wr_ptr(bsize);
    dup->copy( mdata );

    ACE_Message_Block* last = &lhs;
   for(ACE_Message_Block* temp = &lhs; NULL!=temp; last = temp, temp = temp->cont()){
   }

    last->cont( dup );

   return lhs;
}

#else

ACE_Message_Block& operator<<( ACE_Message_Block& lhs, const char* mdata){
   size_t bsize = lhs.size();
   size_t len = strlen(mdata)+1;

   if( 0 == bsize){
      lhs.size(len);
      lhs.copy(mdata);
      return lhs;
   }

   ACE_Message_Block* m = new ACE_Message_Block(len);
    m->copy(mdata);

   ACE_Message_Block* last = &lhs;
   for(ACE_Message_Block* temp = &lhs; NULL!=temp; last = temp, temp = temp->cont()){
   }

    last->cont(m);

   return lhs;
}

#endif

SimpleTask.h
#pragma once

#include "util.h"
#include <ace/Task.h>

class SimpleTask:public ACE_Task<ACE_MT_SYNCH>
{
private:
   const char* data_;

public:
   explicit SimpleTask(const char* data);
    ~SimpleTask(void);

   virtual int open (void *args = 0);
   virtual int svc (void);
   virtual int put (ACE_Message_Block *, ACE_Time_Value * = 0);

   void cmd_close();
   void append_task( const char* data);
};

SimpleTask.cpp
#include "SimpleTask.h"
#include <iostream>

SimpleTask::SimpleTask(const char* data)
    :data_(data)
{
}

SimpleTask::~SimpleTask(void)
{
}

int
SimpleTask::open (void *args/* = 0*/){
   return this->activate(THR_NEW_LWP | THR_JOINABLE | THR_INHERIT_SCHED, 2);
}

int
SimpleTask::svc (void){
   ACE_Message_Block* mdata;

   while(true){
      if( -1!=this->getq(mdata) ){
          (*mdata)<< this->data_;

         ACE_Task<ACE_MT_SYNCH>* next = this->next();
         if(next){
            this->put_next( mdata );
            continue;
         }

         int i(0);
         for(ACE_Message_Block* temp = mdata; NULL!=temp; temp = temp->cont(), ++i){
             std::cout<<std::endl<<"Index:"<<i<< "   data:"<< (const char*)temp->rd_ptr();
         }
          std::cout<<std::endl;

          mdata->release();
         continue;
      }

      if(ESHUTDOWN == errno) break;
   }

   return 0;
}

void
SimpleTask::cmd_close(){
   ACE_Task<ACE_MT_SYNCH>* temp = this->next();
   ACE_Task<ACE_MT_SYNCH>* nexttemp= temp;
   for(; NULL!=temp;
       nexttemp = temp,
       temp = temp->next(),
      delete nexttemp
       ){
       temp->flush();
       temp->wait();
   }

   this->flush();
   this->wait();
}

int
SimpleTask::put (ACE_Message_Block * data, ACE_Time_Value * vt){
   return this->putq(data, vt);
}

void
SimpleTask::append_task( const char* data){
   SimpleTask* ts = new SimpleTask(data);
    ts->open();

   ACE_Task<ACE_MT_SYNCH>* last = this;
   for(ACE_Task<ACE_MT_SYNCH>* temp = last; NULL!=temp; last = temp, temp= temp->next()){
   }

    last->next( ts );
}

Task2.cpp
// Task2.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

#include <ace/ACE.h>
#include "SimpleTask.h"

#include <iostream>
#include <string>
#include <ace/OS.h>

int _tmain(int argc, _TCHAR* argv[])
{
    ACE::init();
   {
      SimpleTask st("t1 task");
       st.open();

       st.append_task("t2 task");
       st.append_task("t3 task");

       std::string cmd;

      while(true){
          std::cout<<std::endl<<"전송할 데이터를 입력하세요. 종료하고 싶다면 exit를 입력하세요."<<std::endl;
          std::getline( std::cin, cmd );
         if( "exit"==cmd){
             st.cmd_close();
            break;
         }

          std::cout<<std::endl;
         ACE_Message_Block* m = new ACE_Message_Block;
          (*m)<< cmd.c_str();
          st.put(m);
          ACE_OS::sleep(2);
      }

       system("pause");

   }
    ACE::fini();
   return 0;
}

- 목록:

라이브러리 포팅하기
간단히 Echo 서버 만들어보기
간단히 Echo 클라이언트 만들기
ACE_Select_Reactor에 대한 이해
ACE_TP_Reactor 이해 – Leader/Followers 패턴
ACE_WMFO_Reactor 이해
Service Configurator Framework 1 – 개요
Service Configurator Framework 2 – ACE_Service_Config 클래스 이해
Service Configurator Framework 3 – 동적/정적 서비스
Service Configurator Framework 4 – 서비스를 등록하는 과정
Service Configurator Framework 5 – ACE_Service_Repository 클래스
ACE Task Framework 1 – 개요
ACE Task Framework 2 – Active Object 패턴 이해
ACE Task Framework 3 – Half-Sync/Half-Async 패턴 이해
ACE Task Framework 4 – ACE_Task_Base 클래스 이해
ACE Task Framework 5 – ACE_Task 클래스 이해
ACE Task Framework 6 – ACE_Message_Block 클래스 이해 1
ACE Task Framework 7 – ACE_Message_Block 클래스 이해 2
ACE Task Framework 8 – ACE_Message_Queue 이해 1
ACE Task Framework 9 – ACE_Message_Queue 이해 2
ACE Task Framework 10 – ACE_Message_Queue 이해 3
ACE Task Framework 11 – ACE_Thread_Manager 클래스 이해 1
ACE Task Framework 12 – ACE_Thread_Manager 클래스 이해 2
ACE Task Framework 13 – ACE_Thread_Manager 클래스 이해 3
ACE Task Framework 14 – 기본 샘플1
ACE Task Framework 15 – 기본 샘플2
ACE Task Framework 16 – 기본 샘플3
ACE Acceptor-Connector framework 1 – ACE_Svc_Handler 이해1
ACE Acceptor-Connector framework 2 – ACE_Svc_Handler 이해2
ACE Acceptor-Connector framework 3 – ACE_Acceptor 클래스 이해
ACE Acceptor-Connector framework 4 – ACE_Connector 클래스 이해
ACE Proactor Framework 1 – 비동기과 서버 모델
ACE Proactor Framework 2 – 비동기 IO 이해하기
ACE Proactor Framework 3 – 비동기 IO 기술 요소
ACE Proactor Framework 4 – Echo 서버 만들기
ACE Proactor Framework 5 – Echo 클라이언트 만들기
ACE Proactor Framework 6 – UDP 사용하기
ACE Proactor Framework 7 – serial port 사용하기
ACE Proactor Framework 8 – Review
ACE Proactor Framework 9 – Acceptor-Connector 예제 1
ACE Proactor Framework 10 – Acceptor-Connector 예제 2