TAO/examples/RTCORBA/Activity/Builder.cpp

   1 #include "Builder.h"
   2
   3 #include "ace/Get_Opt.h"
   4 #include "POA_Holder.h"
   5 #include "Job_i.h"
   6 #include "Thread_Task.h"
   7 #include "Activity.h"
   8
   9 Builder::Builder(void)
  10   :poa_count_ (0),
  11    poa_list_ (0),
  12    task_count_ (0),
  13    task_list_ (0),
  14    job_count_ (0),
  15    job_list_ (0)
  16 {
  17   ACTIVITY::instance()->builder (this);
  18 }
  19
  20 Builder::~Builder(void)
  21 {
  22 }
  23
  24 int
  25 Builder::init (int argc, ACE_TCHAR *argv[])
  26 {
  27   ACE_Arg_Shifter arg_shifter (argc, argv);
  28
  29   const ACE_TCHAR* current_arg = 0;
  30
  31   int task_count = 0;
  32   int poa_count = 0;
  33   int job_count = 0;
  34
  35   while (arg_shifter.is_anything_left ())
  36     {
  37       if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-TaskCount"))))
  38         {
  39           task_count_ = ACE_OS::atoi (current_arg);
  40           ACE_NEW_RETURN (task_list_, Periodic_Task*[task_count_], -1);
  41           ACE_OS::memset (this->task_list_,
  42                           0,
  43                           this->task_count_ * sizeof (this->task_list_[0]));
  44           arg_shifter.consume_arg ();
  45         }
  46       if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-JobCount"))))
  47         {
  48           job_count_ = ACE_OS::atoi (current_arg);
  49           ACE_NEW_RETURN (job_list_, Job_i*[job_count_], -1);
  50           ACE_OS::memset (this->job_list_,
  51                           0,
  52                           this->job_count_ * sizeof (this->job_list_[0]));
  53           arg_shifter.consume_arg ();
  54         }
  55       if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-POACount"))))
  56         {
  57           poa_count_ = ACE_OS::atoi (current_arg);
  58           ACE_NEW_RETURN (poa_list_, POA_Holder*[poa_count_], -1);
  59           ACE_OS::memset (this->poa_list_,
  60                           0,
  61                           this->poa_count_ * sizeof (this->poa_list_[0]));
  62           arg_shifter.consume_arg ();
  63         }
  64       else if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-ThreadTask")) == 0)
  65         {
  66           if (task_count < this->task_count_)
  67             {
  68               arg_shifter.consume_arg ();
  69
  70               Periodic_Task *task = 0;
  71
  72               ACE_NEW_RETURN (task, Thread_Task (), -1);
  73
  74               if (task->init_task (arg_shifter) == -1)
  75                 return -1;
  76
  77               task_list_[task_count++] = task;
  78             }
  79           else
  80             return -1;
  81         }
  82       else if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-Job")) == 0)
  83         {
  84           if (job_count < this->job_count_)
  85             {
  86               arg_shifter.consume_arg ();
  87
  88               Job_i *job;
  89
  90               ACE_NEW_RETURN (job, Job_i (), -1);
  91
  92               if (job->init (arg_shifter) == -1)
  93                 return -1;
  94
  95               this->job_list_[job_count++] = job;
  96             }
  97           else
  98             return -1;
  99         }
 100       else if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-POA")) == 0)
 101         {
 102           if (poa_count < this->poa_count_)
 103             {
 104               arg_shifter.consume_arg ();
 105
 106               POA_Holder *poa_holder = 0;
 107
 108               ACE_NEW_RETURN (poa_holder, POA_Holder (), -1);
 109
 110               if (poa_holder->init (arg_shifter) == -1)
 111                 {
 112                   delete poa_holder;
 113                   return -1;
 114                 }
 115
 116               this->poa_list_[poa_count++] = poa_holder;
 117             }
 118           else
 119             return -1;
 120         }
 121       else
 122         {
 123           arg_shifter.ignore_arg ();
 124         }
 125     }
 126
 127   return 0;
 128 }
 129
 130 int
 131 Builder::fini (void)
 132 {
 133   // It's only a hack for proper cleanup of this badly designed test.
 134   static bool already_cleaned = false;
 135   if (already_cleaned)
 136     return 0;
 137
 138   int count;
 139
 140   for (count = 0; count < this->task_count_; ++count)
 141     delete this->task_list_[count];
 142   delete [] this->task_list_;
 143
 144   delete [] this->job_list_;
 145
 146   for (count = 0; count < this->poa_count_; ++count)
 147     delete this->poa_list_[count];
 148   delete [] this->poa_list_;
 149
 150   already_cleaned = true;
 151
 152   return 0;
 153 }
 154
 155 int
 156 Builder::poa_list (POA_LIST& poa_list)
 157 {
 158   poa_list = poa_list_;
 159   return poa_count_;
 160 }
 161
 162 int
 163 Builder::task_list (TASK_LIST& task_list)
 164 {
 165   task_list = task_list_;
 166   return task_count_;
 167 }
 168
 169 int
 170 Builder::job_list (JOB_LIST& job_list)
 171 {
 172   job_list = job_list_;
 173   return job_count_;
 174 }
 175
 176
 177 ACE_STATIC_SVC_DEFINE(Builder,
 178                       ACE_TEXT ("Builder"),
 179                       ACE_SVC_OBJ_T,
 180                       &ACE_SVC_NAME (Builder),
 181                       ACE_Service_Type::DELETE_THIS | ACE_Service_Type::DELETE_OBJ,
 182                       0)
 183
 184 ACE_FACTORY_DEFINE (ACE_Local_Service, Builder)