00001
00002
00003 #include "ace/Service_Types.h"
00004
00005 #if !defined (__ACE_INLINE__)
00006 #include "ace/Service_Types.inl"
00007 #endif
00008
00009 #include "ace/Stream_Modules.h"
00010 #include "ace/Stream.h"
00011 #include "ace/OS_NS_stdio.h"
00012 #include "ace/OS_NS_string.h"
00013
00014
00015 ACE_RCSID (ace,
00016 Service_Types,
00017 "$Id: Service_Types.cpp 90072 2010-05-04 21:34:39Z cbeaulac $")
00018
00019 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00020
00021 typedef ACE_Stream<ACE_SYNCH> MT_Stream;
00022 typedef ACE_Module<ACE_SYNCH> MT_Module;
00023 typedef ACE_Task<ACE_SYNCH> MT_Task;
00024
00025 ACE_ALLOC_HOOK_DEFINE(ACE_Service_Type_Impl)
00026
00027 void
00028 ACE_Service_Type_Impl::dump (void) const
00029 {
00030 #if defined (ACE_HAS_DUMP)
00031 ACE_TRACE ("ACE_Service_Type_Impl::dump");
00032 #endif
00033 }
00034
00035 ACE_Service_Type_Impl::ACE_Service_Type_Impl (void *so,
00036 const ACE_TCHAR *s_name,
00037 u_int f,
00038 ACE_Service_Object_Exterminator gobbler,
00039 int stype)
00040 : name_ (0),
00041 obj_ (so),
00042 gobbler_ (gobbler),
00043 flags_ (f),
00044 service_type_ (stype)
00045 {
00046 ACE_TRACE ("ACE_Service_Type_Impl::ACE_Service_Type_Impl");
00047 this->name (s_name);
00048 }
00049
00050 ACE_Service_Type_Impl::~ACE_Service_Type_Impl (void)
00051 {
00052 ACE_TRACE ("ACE_Service_Type_Impl::~ACE_Service_Type_Impl");
00053
00054
00055
00056 delete [] const_cast <ACE_TCHAR *> (this->name_);
00057 }
00058
00059 int
00060 ACE_Service_Type_Impl::fini (void) const
00061 {
00062 ACE_TRACE ("ACE_Service_Type_Impl::fini");
00063
00064 delete [] const_cast <ACE_TCHAR *> (this->name_);
00065 (const_cast <ACE_Service_Type_Impl *> (this))->name_ = 0;
00066
00067 if (ACE_BIT_ENABLED (this->flags_,
00068 ACE_Service_Type::DELETE_OBJ))
00069 {
00070 if (gobbler_ != 0)
00071 gobbler_ (this->object ());
00072 else
00073
00074 operator delete ((void *) this->object ());
00075 }
00076
00077 if (ACE_BIT_ENABLED (this->flags_,
00078 ACE_Service_Type::DELETE_THIS))
00079 delete const_cast <ACE_Service_Type_Impl *> (this);
00080
00081 return 0;
00082 }
00083
00084 ACE_Service_Object_Type::ACE_Service_Object_Type (void *so,
00085 const ACE_TCHAR *s_name,
00086 u_int f,
00087 ACE_Service_Object_Exterminator gobbler,
00088 int stype)
00089 : ACE_Service_Type_Impl (so, s_name, f, gobbler, stype)
00090 , initialized_ (-1)
00091 {
00092 ACE_TRACE ("ACE_Service_Object_Type::ACE_Service_Object_Type");
00093 }
00094
00095 int
00096 ACE_Service_Object_Type::init (int argc, ACE_TCHAR *argv[]) const
00097 {
00098 ACE_TRACE ("ACE_Service_Object_Type::init");
00099
00100 void * const obj = this->object ();
00101
00102 ACE_Service_Object * const so =
00103 static_cast<ACE_Service_Object *> (obj);
00104
00105 if (so == 0)
00106 return -1;
00107
00108 this->initialized_ = so->init (argc, argv);
00109
00110 return this->initialized_;
00111 }
00112
00113 int
00114 ACE_Service_Object_Type::fini (void) const
00115 {
00116 ACE_TRACE ("ACE_Service_Object_Type::fini");
00117
00118 void * const obj = this->object ();
00119
00120 ACE_Service_Object * const so =
00121 static_cast<ACE_Service_Object *> (obj);
00122
00123
00124
00125
00126 if (so != 0 && this->initialized_ == 0)
00127 so->fini ();
00128
00129 return ACE_Service_Type_Impl::fini ();
00130 }
00131
00132 ACE_Service_Object_Type::~ACE_Service_Object_Type (void)
00133 {
00134 ACE_TRACE ("ACE_Service_Object_Type::~ACE_Service_Object_Type");
00135 }
00136
00137 int
00138 ACE_Service_Object_Type::suspend (void) const
00139 {
00140 ACE_TRACE ("ACE_Service_Object_Type::suspend");
00141 return static_cast<ACE_Service_Object *> (this->object ())->suspend ();
00142 }
00143
00144 int
00145 ACE_Service_Object_Type::resume (void) const
00146 {
00147 ACE_TRACE ("ACE_Service_Object_Type::resume");
00148 return static_cast<ACE_Service_Object *> (this->object ())->resume ();
00149 }
00150
00151 int
00152 ACE_Service_Object_Type::info (ACE_TCHAR **str, size_t len) const
00153 {
00154 ACE_TRACE ("ACE_Service_Object_Type::info");
00155 return static_cast<ACE_Service_Object *> (this->object ())->info (str, len);
00156 }
00157
00158 ACE_ALLOC_HOOK_DEFINE(ACE_Module_Type)
00159
00160 void
00161 ACE_Module_Type::dump (void) const
00162 {
00163 #if defined (ACE_HAS_DUMP)
00164 ACE_TRACE ("ACE_Module_Type::dump");
00165 #endif
00166 }
00167
00168 ACE_Module_Type::ACE_Module_Type (void *m,
00169 const ACE_TCHAR *m_name,
00170 u_int f,
00171 int stype)
00172 : ACE_Service_Type_Impl (m, m_name, f, 0, stype)
00173 {
00174 ACE_TRACE ("ACE_Module_Type::ACE_Module_Type");
00175 }
00176
00177 ACE_Module_Type::~ACE_Module_Type (void)
00178 {
00179 ACE_TRACE ("ACE_Module_Type::~ACE_Module_Type");
00180 }
00181
00182 int
00183 ACE_Module_Type::init (int argc, ACE_TCHAR *argv[]) const
00184 {
00185 ACE_TRACE ("ACE_Module_Type::init");
00186 void *obj = this->object ();
00187 MT_Module *mod = (MT_Module *) obj;
00188
00189
00190
00191
00192
00193
00194
00195
00196 mod->name (this->name_);
00197 MT_Task *reader = mod->reader ();
00198 MT_Task *writer = mod->writer ();
00199
00200 if (reader->init (argc, argv) == -1
00201 || writer->init (argc, argv) == -1)
00202 return -1;
00203 else
00204 return 0;
00205 }
00206
00207 int
00208 ACE_Module_Type::suspend (void) const
00209 {
00210 ACE_TRACE ("ACE_Module_Type::suspend");
00211 void *obj = this->object ();
00212 MT_Module *mod = (MT_Module *) obj;
00213 MT_Task *reader = mod->reader ();
00214 MT_Task *writer = mod->writer ();
00215
00216 if (reader->suspend () == -1
00217 || writer->suspend () == -1)
00218 return -1;
00219 else
00220 return 0;
00221 }
00222
00223 int
00224 ACE_Module_Type::resume (void) const
00225 {
00226 ACE_TRACE ("ACE_Module_Type::resume");
00227 void *obj = this->object ();
00228 MT_Module *mod = (MT_Module *) obj;
00229 MT_Task *reader = mod->reader ();
00230 MT_Task *writer = mod->writer ();
00231
00232 if (reader->resume () == -1
00233 || writer->resume () == -1)
00234 return -1;
00235 else
00236 return 0;
00237 }
00238
00239
00240
00241
00242 int
00243 ACE_Module_Type::fini (void) const
00244 {
00245 ACE_TRACE ("ACE_Module_Type::fini");
00246 void *obj = this->object ();
00247 MT_Module *mod = (MT_Module *) obj;
00248 MT_Task *reader = mod->reader ();
00249 MT_Task *writer = mod->writer ();
00250
00251 if (reader != 0)
00252 reader->fini ();
00253
00254 if (writer != 0)
00255 writer->fini ();
00256
00257
00258 mod->close (MT_Module::M_DELETE);
00259 return ACE_Service_Type_Impl::fini ();
00260 }
00261
00262 int
00263 ACE_Module_Type::info (ACE_TCHAR **str, size_t len) const
00264 {
00265 ACE_TRACE ("ACE_Module_Type::info");
00266 ACE_TCHAR buf[BUFSIZ];
00267
00268 ACE_OS::sprintf (buf,
00269 ACE_TEXT ("%s\t %s"),
00270 this->name (),
00271 ACE_TEXT ("# ACE_Module\n"));
00272
00273 if (*str == 0 && (*str = ACE_OS::strdup (buf)) == 0)
00274 return -1;
00275 else
00276 ACE_OS::strsncpy (*str, buf, len);
00277 return static_cast<int> (ACE_OS::strlen (buf));
00278 }
00279
00280 void
00281 ACE_Module_Type::link (ACE_Module_Type *n)
00282 {
00283 ACE_TRACE ("ACE_Module_Type::link");
00284 this->link_ = n;
00285 }
00286
00287 ACE_Module_Type *
00288 ACE_Module_Type::link (void) const
00289 {
00290 ACE_TRACE ("ACE_Module_Type::link");
00291 return this->link_;
00292 }
00293
00294 ACE_ALLOC_HOOK_DEFINE(ACE_Stream_Type)
00295
00296 void
00297 ACE_Stream_Type::dump (void) const
00298 {
00299 #if defined (ACE_HAS_DUMP)
00300 ACE_TRACE ("ACE_Stream_Type::dump");
00301 #endif
00302 }
00303
00304 int
00305 ACE_Stream_Type::init (int, ACE_TCHAR *[]) const
00306 {
00307 ACE_TRACE ("ACE_Stream_Type::init");
00308 return 0;
00309 }
00310
00311 int
00312 ACE_Stream_Type::suspend (void) const
00313 {
00314 ACE_TRACE ("ACE_Stream_Type::suspend");
00315
00316 for (ACE_Module_Type *m = this->head_;
00317 m != 0;
00318 m = m->link ())
00319 m->suspend ();
00320
00321 return 0;
00322 }
00323
00324 int
00325 ACE_Stream_Type::resume (void) const
00326 {
00327 ACE_TRACE ("ACE_Stream_Type::resume");
00328
00329 for (ACE_Module_Type *m = this->head_;
00330 m != 0;
00331 m = m->link ())
00332 m->resume ();
00333
00334 return 0;
00335 }
00336
00337 ACE_Stream_Type::ACE_Stream_Type (void *s,
00338 const ACE_TCHAR *s_name,
00339 u_int f,
00340 int stype)
00341 : ACE_Service_Type_Impl (s, s_name, f, 0, stype),
00342 head_ (0)
00343 {
00344 ACE_TRACE ("ACE_Stream_Type::ACE_Stream_Type");
00345 }
00346
00347 ACE_Stream_Type::~ACE_Stream_Type (void)
00348 {
00349 ACE_TRACE ("ACE_Stream_Type::~ACE_Stream_Type");
00350 }
00351
00352 int
00353 ACE_Stream_Type::info (ACE_TCHAR **str, size_t len) const
00354 {
00355 ACE_TRACE ("ACE_Stream_Type::info");
00356 ACE_TCHAR buf[BUFSIZ];
00357
00358 ACE_OS::sprintf (buf,
00359 ACE_TEXT ("%s\t %s"),
00360 this->name (),
00361 ACE_TEXT ("# STREAM\n"));
00362
00363 if (*str == 0 && (*str = ACE_OS::strdup (buf)) == 0)
00364 return -1;
00365 else
00366 ACE_OS::strsncpy (*str, buf, len);
00367 return static_cast<int> (ACE_OS::strlen (buf));
00368 }
00369
00370 int
00371 ACE_Stream_Type::fini (void) const
00372 {
00373 ACE_TRACE ("ACE_Stream_Type::fini");
00374 void *obj = this->object ();
00375 MT_Stream *str = (MT_Stream *) obj;
00376
00377 for (ACE_Module_Type *m = this->head_; m != 0;)
00378 {
00379 ACE_Module_Type *t = m->link ();
00380
00381
00382 str->remove (m->name (),
00383 MT_Module::M_DELETE_NONE);
00384 m = t;
00385 }
00386 str->close ();
00387
00388 return ACE_Service_Type_Impl::fini ();
00389 }
00390
00391
00392
00393 int
00394 ACE_Stream_Type::remove (ACE_Module_Type *mod)
00395 {
00396 ACE_TRACE ("ACE_Stream_Type::remove");
00397
00398 ACE_Module_Type *prev = 0;
00399 void *obj = this->object ();
00400 MT_Stream *str = (MT_Stream *) obj;
00401 int result = 0;
00402
00403 for (ACE_Module_Type *m = this->head_; m != 0; )
00404 {
00405
00406 ACE_Module_Type *link = m->link ();
00407
00408 if (m == mod)
00409 {
00410 if (prev == 0)
00411 this->head_ = link;
00412 else
00413 prev->link (link);
00414
00415
00416 if (str->remove (m->name (),
00417 MT_Module::M_DELETE_NONE) == -1)
00418 result = -1;
00419
00420
00421
00422 }
00423 else
00424 prev = m;
00425
00426 m = link;
00427 }
00428
00429 return result;
00430 }
00431
00432 int
00433 ACE_Stream_Type::push (ACE_Module_Type *new_module)
00434 {
00435 ACE_TRACE ("ACE_Stream_Type::push");
00436 void *obj = this->object ();
00437 MT_Stream *str = (MT_Stream *) obj;
00438
00439 new_module->link (this->head_);
00440 this->head_ = new_module;
00441 obj = new_module->object ();
00442 return str->push ((MT_Module *) obj);
00443 }
00444
00445 ACE_Module_Type *
00446 ACE_Stream_Type::find (const ACE_TCHAR *module_name) const
00447 {
00448 ACE_TRACE ("ACE_Stream_Type::find");
00449
00450 for (ACE_Module_Type *m = this->head_;
00451 m != 0;
00452 m = m->link ())
00453 if (ACE_OS::strcmp (m->name (), module_name) == 0)
00454 return m;
00455
00456 return 0;
00457 }
00458
00459
00460
00461 ACE_END_VERSIONED_NAMESPACE_DECL