dep/ACE_wrappers/ace/Stream_Modules.cpp

   1 // $Id: Stream_Modules.cpp 80826 2008-03-04 14:51:23Z wotte $
   2
   3 #ifndef ACE_STREAM_MODULES_CPP
   4 #define ACE_STREAM_MODULES_CPP
   5
   6 #include "ace/Stream_Modules.h"
   7 #include "ace/OS_NS_string.h"
   8
   9 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  10 # pragma once
  11 #endif /* ACE_LACKS_PRAGMA_ONCE */
  12
  13
  14 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  15
  16 ACE_ALLOC_HOOK_DEFINE(ACE_Stream_Head)
  17
  18 template <ACE_SYNCH_DECL>
  19 ACE_Stream_Head<ACE_SYNCH_USE>::ACE_Stream_Head (void)
  20 {
  21   ACE_TRACE ("ACE_Stream_Head<ACE_SYNCH_USE>::ACE_Stream_Head");
  22 }
  23
  24 template <ACE_SYNCH_DECL>
  25 ACE_Stream_Head<ACE_SYNCH_USE>::~ACE_Stream_Head (void)
  26 {
  27   ACE_TRACE ("ACE_Stream_Head<ACE_SYNCH_USE>::~ACE_Stream_Head");
  28 }
  29
  30 template <ACE_SYNCH_DECL> void
  31 ACE_Stream_Head<ACE_SYNCH_USE>::dump (void) const
  32 {
  33 #if defined (ACE_HAS_DUMP)
  34   ACE_TRACE ("ACE_Stream_Head<ACE_SYNCH_USE>::dump");
  35 #endif /* ACE_HAS_DUMP */
  36 }
  37
  38 // ACE_Module that act as the head and tail of a Stream.
  39
  40 template <ACE_SYNCH_DECL> int
  41 ACE_Stream_Head<ACE_SYNCH_USE>::open (void *)
  42 {
  43   ACE_TRACE ("ACE_Stream_Head<ACE_SYNCH_USE>::open");
  44   return 0;
  45 }
  46
  47 template <ACE_SYNCH_DECL> int
  48 ACE_Stream_Head<ACE_SYNCH_USE>::close (u_long)
  49 {
  50   ACE_TRACE ("ACE_Stream_Head<ACE_SYNCH_USE>::close");
  51   return 0;
  52 }
  53
  54 template <ACE_SYNCH_DECL> int
  55 ACE_Stream_Head<ACE_SYNCH_USE>::svc (void)
  56 {
  57   ACE_TRACE ("ACE_Stream_Head<ACE_SYNCH_USE>::svc");
  58   return -1;
  59 }
  60
  61 template <ACE_SYNCH_DECL> int
  62 ACE_Stream_Head<ACE_SYNCH_USE>::control (ACE_Message_Block *mb)
  63 {
  64   ACE_TRACE ("ACE_Stream_Head<ACE_SYNCH_USE>::control");
  65   ACE_IO_Cntl_Msg *ioc = (ACE_IO_Cntl_Msg *) mb->rd_ptr ();
  66   ACE_IO_Cntl_Msg::ACE_IO_Cntl_Cmds cmd;
  67
  68   switch (cmd = ioc->cmd ())
  69     {
  70     case ACE_IO_Cntl_Msg::SET_LWM:
  71     case ACE_IO_Cntl_Msg::SET_HWM:
  72       this->water_marks (cmd, *(size_t *) mb->cont ()->rd_ptr ());
  73       ioc->rval (0);
  74       break;
  75     default:
  76       return 0;
  77     }
  78   return ioc->rval ();
  79 }
  80
  81 // Performs canonical flushing at the ACE_Stream Head.
  82
  83 template <ACE_SYNCH_DECL> int
  84 ACE_Stream_Head<ACE_SYNCH_USE>::canonical_flush (ACE_Message_Block *mb)
  85 {
  86   ACE_TRACE ("ACE_Stream_Head<ACE_SYNCH_USE>::canonical_flush");
  87   char *cp = mb->rd_ptr ();
  88
  89   if (ACE_BIT_ENABLED (*cp, ACE_Task_Flags::ACE_FLUSHR))
  90     {
  91       this->flush (ACE_Task_Flags::ACE_FLUSHALL);
  92       ACE_CLR_BITS (*cp, ACE_Task_Flags::ACE_FLUSHR);
  93     }
  94
  95   if (ACE_BIT_ENABLED (*cp, ACE_Task_Flags::ACE_FLUSHW))
  96     return this->reply (mb);
  97   else
  98     mb->release ();
  99   return 0;
 100 }
 101
 102 template <ACE_SYNCH_DECL> int
 103 ACE_Stream_Head<ACE_SYNCH_USE>::put (ACE_Message_Block *mb,
 104                                      ACE_Time_Value *tv)
 105 {
 106   ACE_TRACE ("ACE_Stream_Head<ACE_SYNCH_USE>::put");
 107   int res = 0;
 108
 109   if (mb->msg_type () == ACE_Message_Block::MB_IOCTL
 110       && (res = this->control (mb)) == -1)
 111     return res;
 112
 113   if (this->is_writer ())
 114     return this->put_next (mb, tv);
 115   else // this->is_reader ()
 116     {
 117       switch (mb->msg_type ())
 118         {
 119         case ACE_Message_Block::MB_FLUSH:
 120           return this->canonical_flush (mb);
 121         default:
 122           break;
 123         }
 124
 125       return this->putq (mb, tv);
 126     }
 127 }
 128
 129 template <ACE_SYNCH_DECL> int
 130 ACE_Stream_Head<ACE_SYNCH_USE>::init (int, ACE_TCHAR *[])
 131 {
 132   ACE_TRACE ("ACE_Stream_Head<ACE_SYNCH_USE>::init");
 133   return 0;
 134 }
 135
 136 template <ACE_SYNCH_DECL> int
 137 ACE_Stream_Head<ACE_SYNCH_USE>::info (ACE_TCHAR **strp, size_t length) const
 138 {
 139   ACE_TRACE ("ACE_Stream_Head<ACE_SYNCH_USE>::info");
 140   const ACE_TCHAR *name = this->name ();
 141
 142   if (*strp == 0 && (*strp = ACE_OS::strdup (name)) == 0)
 143     return -1;
 144   else
 145     ACE_OS::strsncpy (*strp, name, length);
 146   return static_cast<int> (ACE_OS::strlen (name));
 147 }
 148
 149 template <ACE_SYNCH_DECL> int
 150 ACE_Stream_Head<ACE_SYNCH_USE>::fini (void)
 151 {
 152   ACE_TRACE ("ACE_Stream_Head<ACE_SYNCH_USE>::fini");
 153   return 0;
 154 }
 155
 156 ACE_ALLOC_HOOK_DEFINE(ACE_Stream_Tail)
 157
 158 template <ACE_SYNCH_DECL>
 159 ACE_Stream_Tail<ACE_SYNCH_USE>::ACE_Stream_Tail (void)
 160 {
 161   ACE_TRACE ("ACE_Stream_Tail<ACE_SYNCH_USE>::ACE_Stream_Tail");
 162 }
 163
 164 template <ACE_SYNCH_DECL>
 165 ACE_Stream_Tail<ACE_SYNCH_USE>::~ACE_Stream_Tail (void)
 166 {
 167   ACE_TRACE ("ACE_Stream_Tail<ACE_SYNCH_USE>::~ACE_Stream_Tail");
 168 }
 169
 170 template <ACE_SYNCH_DECL> void
 171 ACE_Stream_Tail<ACE_SYNCH_USE>::dump (void) const
 172 {
 173 #if defined (ACE_HAS_DUMP)
 174   ACE_TRACE ("ACE_Stream_Tail<ACE_SYNCH_USE>::dump");
 175 #endif /* ACE_HAS_DUMP */
 176 }
 177
 178 template <ACE_SYNCH_DECL> int
 179 ACE_Stream_Tail<ACE_SYNCH_USE>::open (void *)
 180 {
 181   ACE_TRACE ("ACE_Stream_Tail<ACE_SYNCH_USE>::open");
 182   return 0;
 183 }
 184
 185 template <ACE_SYNCH_DECL> int
 186 ACE_Stream_Tail<ACE_SYNCH_USE>::close (u_long)
 187 {
 188   ACE_TRACE ("ACE_Stream_Tail<ACE_SYNCH_USE>::close");
 189   return 0;
 190 }
 191
 192 template <ACE_SYNCH_DECL> int
 193 ACE_Stream_Tail<ACE_SYNCH_USE>::svc (void)
 194 {
 195   ACE_TRACE ("ACE_Stream_Tail<ACE_SYNCH_USE>::svc");
 196   return -1;
 197 }
 198
 199 template <ACE_SYNCH_DECL> int
 200 ACE_Stream_Tail<ACE_SYNCH_USE>::control (ACE_Message_Block *mb)
 201 {
 202   ACE_TRACE ("ACE_Stream_Tail<ACE_SYNCH_USE>::control");
 203   ACE_IO_Cntl_Msg *ioc = (ACE_IO_Cntl_Msg *) mb->rd_ptr ();
 204   ACE_IO_Cntl_Msg::ACE_IO_Cntl_Cmds cmd;
 205
 206   switch (cmd = ioc->cmd ())
 207     {
 208     case ACE_IO_Cntl_Msg::SET_LWM:
 209     case ACE_IO_Cntl_Msg::SET_HWM:
 210       {
 211         size_t wm_size = *(size_t *) mb->cont ()->rd_ptr ();
 212
 213         this->water_marks (cmd, wm_size);
 214         this->sibling ()->water_marks (cmd, wm_size);
 215         ioc->rval (0);
 216         break;
 217       }
 218     default:
 219       mb->msg_type (ACE_Message_Block::MB_IOCNAK);
 220     }
 221   return this->reply (mb);
 222 }
 223
 224 // Perform flush algorithm as though we were the driver.
 225
 226 template <ACE_SYNCH_DECL> int
 227 ACE_Stream_Tail<ACE_SYNCH_USE>::canonical_flush (ACE_Message_Block *mb)
 228 {
 229   ACE_TRACE ("ACE_Stream_Tail<ACE_SYNCH_USE>::canonical_flush");
 230   char *cp = mb->rd_ptr ();
 231
 232   if (ACE_BIT_ENABLED (*cp, ACE_Task_Flags::ACE_FLUSHW))
 233     {
 234       this->flush (ACE_Task_Flags::ACE_FLUSHALL);
 235       ACE_CLR_BITS (*cp, ACE_Task_Flags::ACE_FLUSHW);
 236     }
 237
 238   if (ACE_BIT_ENABLED (*cp, ACE_Task_Flags::ACE_FLUSHR))
 239     {
 240       this->sibling ()->flush (ACE_Task_Flags::ACE_FLUSHALL);
 241       return this->reply (mb);
 242     }
 243   else
 244     mb->release ();
 245
 246   return 0;
 247 }
 248
 249 template <ACE_SYNCH_DECL> int
 250 ACE_Stream_Tail<ACE_SYNCH_USE>::put (ACE_Message_Block *mb,
 251                                    ACE_Time_Value *)
 252 {
 253   ACE_TRACE ("ACE_Stream_Tail<ACE_SYNCH_USE>::put");
 254
 255   if (this->is_writer ())
 256     {
 257       switch (mb->msg_type ())
 258         {
 259         case ACE_Message_Block::MB_IOCTL:
 260           return this->control (mb);
 261           /* NOTREACHED */
 262         default:
 263           mb->release ();
 264           return 0;
 265           /* NOTREACHED */
 266         }
 267     }
 268
 269   return -1;
 270 }
 271
 272 template <ACE_SYNCH_DECL> int
 273 ACE_Stream_Tail<ACE_SYNCH_USE>::init (int, ACE_TCHAR *[])
 274 {
 275   ACE_TRACE ("ACE_Stream_Tail<ACE_SYNCH_USE>::init");
 276   return 0;
 277 }
 278
 279 template <ACE_SYNCH_DECL> int
 280 ACE_Stream_Tail<ACE_SYNCH_USE>::info (ACE_TCHAR **strp, size_t length) const
 281 {
 282   ACE_TRACE ("ACE_Stream_Tail<ACE_SYNCH_USE>::info");
 283   const ACE_TCHAR *name = this->name ();
 284
 285   if (*strp == 0 && (*strp = ACE_OS::strdup (name)) == 0)
 286     return -1;
 287   else
 288     ACE_OS::strsncpy (*strp, name, length);
 289   return static_cast<int> (ACE_OS::strlen (name));
 290 }
 291
 292 template <ACE_SYNCH_DECL> int
 293 ACE_Stream_Tail<ACE_SYNCH_USE>::fini (void)
 294 {
 295   ACE_TRACE ("ACE_Stream_Tail<ACE_SYNCH_USE>::fini");
 296   return 0;
 297 }
 298
 299 ACE_ALLOC_HOOK_DEFINE(ACE_Thru_Task)
 300
 301 template <ACE_SYNCH_DECL>
 302 ACE_Thru_Task<ACE_SYNCH_USE>::ACE_Thru_Task (void)
 303 {
 304   ACE_TRACE ("ACE_Thru_Task<ACE_SYNCH_USE>::ACE_Thru_Task");
 305 }
 306
 307 template <ACE_SYNCH_DECL>
 308 ACE_Thru_Task<ACE_SYNCH_USE>::~ACE_Thru_Task (void)
 309 {
 310   ACE_TRACE ("ACE_Thru_Task<ACE_SYNCH_USE>::~ACE_Thru_Task");
 311 }
 312
 313 template <ACE_SYNCH_DECL> void
 314 ACE_Thru_Task<ACE_SYNCH_USE>::dump (void) const
 315 {
 316 #if defined (ACE_HAS_DUMP)
 317   ACE_TRACE ("ACE_Thru_Task<ACE_SYNCH_USE>::dump");
 318 #endif /* ACE_HAS_DUMP */
 319 }
 320
 321 template <ACE_SYNCH_DECL> int
 322 ACE_Thru_Task<ACE_SYNCH_USE>::open (void *)
 323 {
 324   ACE_TRACE ("ACE_Thru_Task<ACE_SYNCH_USE>::open");
 325   return 0;
 326 }
 327
 328 template <ACE_SYNCH_DECL> int
 329 ACE_Thru_Task<ACE_SYNCH_USE>::close (u_long)
 330 {
 331   ACE_TRACE ("ACE_Thru_Task<ACE_SYNCH_USE>::close");
 332   return 0;
 333 }
 334
 335 template <ACE_SYNCH_DECL> int
 336 ACE_Thru_Task<ACE_SYNCH_USE>::svc (void)
 337 {
 338   ACE_TRACE ("ACE_Thru_Task<ACE_SYNCH_USE>::svc");
 339   return -1;
 340 }
 341
 342 template <ACE_SYNCH_DECL> int
 343 ACE_Thru_Task<ACE_SYNCH_USE>::put (ACE_Message_Block *msg,
 344                                  ACE_Time_Value *tv)
 345 {
 346   ACE_TRACE ("ACE_Thru_Task<ACE_SYNCH_USE>::put");
 347   return this->put_next (msg, tv);
 348 }
 349
 350 template <ACE_SYNCH_DECL> int
 351 ACE_Thru_Task<ACE_SYNCH_USE>::init (int, ACE_TCHAR *[])
 352 {
 353   ACE_TRACE ("ACE_Thru_Task<ACE_SYNCH_USE>::init");
 354   return 0;
 355 }
 356
 357 template <ACE_SYNCH_DECL> int
 358 ACE_Thru_Task<ACE_SYNCH_USE>::info (ACE_TCHAR **strp,
 359                                     size_t length) const
 360 {
 361   ACE_TRACE ("ACE_Thru_Task<ACE_SYNCH_USE>::info");
 362   const ACE_TCHAR *name = this->name ();
 363
 364   if (*strp == 0 && (*strp = ACE_OS::strdup (name)) == 0)
 365     return -1;
 366   else
 367     ACE_OS::strsncpy (*strp, name, length);
 368   return static_cast<int> (ACE_OS::strlen (name));
 369 }
 370
 371 template <ACE_SYNCH_DECL> int
 372 ACE_Thru_Task<ACE_SYNCH_USE>::fini (void)
 373 {
 374   ACE_TRACE ("ACE_Thru_Task<ACE_SYNCH_USE>::fini");
 375   return 0;
 376 }
 377
 378 ACE_END_VERSIONED_NAMESPACE_DECL
 379
 380 #endif /* ACE_STREAM_MODULES_CPP */