ACE/ace/Stream_Modules.cpp

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