Stream_Modules.cpp

Go to the documentation of this file.
00001 // Stream_Modules.cpp,v 4.26 2005/10/28 16:14:56 ossama Exp
00002 
00003 #ifndef ACE_STREAM_MODULES_CPP
00004 #define ACE_STREAM_MODULES_CPP
00005 
00006 #include "ace/Stream_Modules.h"
00007 #include "ace/OS_NS_string.h"
00008 
00009 #if !defined (ACE_LACKS_PRAGMA_ONCE)
00010 # pragma once
00011 #endif /* ACE_LACKS_PRAGMA_ONCE */
00012 
00013 
00014 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00015 
00016 ACE_ALLOC_HOOK_DEFINE(ACE_Stream_Head)
00017 
00018 template <ACE_SYNCH_DECL>
00019 ACE_Stream_Head<ACE_SYNCH_USE>::ACE_Stream_Head (void)
00020 {
00021   ACE_TRACE ("ACE_Stream_Head<ACE_SYNCH_USE>::ACE_Stream_Head");
00022 }
00023 
00024 template <ACE_SYNCH_DECL>
00025 ACE_Stream_Head<ACE_SYNCH_USE>::~ACE_Stream_Head (void)
00026 {
00027   ACE_TRACE ("ACE_Stream_Head<ACE_SYNCH_USE>::~ACE_Stream_Head");
00028 }
00029 
00030 template <ACE_SYNCH_DECL> void
00031 ACE_Stream_Head<ACE_SYNCH_USE>::dump (void) const
00032 {
00033 #if defined (ACE_HAS_DUMP)
00034   ACE_TRACE ("ACE_Stream_Head<ACE_SYNCH_USE>::dump");
00035 #endif /* ACE_HAS_DUMP */
00036 }
00037 
00038 // ACE_Module that act as the head and tail of a Stream.
00039 
00040 template <ACE_SYNCH_DECL> int
00041 ACE_Stream_Head<ACE_SYNCH_USE>::open (void *)
00042 {
00043   ACE_TRACE ("ACE_Stream_Head<ACE_SYNCH_USE>::open");
00044   return 0;
00045 }
00046 
00047 template <ACE_SYNCH_DECL> int
00048 ACE_Stream_Head<ACE_SYNCH_USE>::close (u_long)
00049 {
00050   ACE_TRACE ("ACE_Stream_Head<ACE_SYNCH_USE>::close");
00051   return 0;
00052 }
00053 
00054 template <ACE_SYNCH_DECL> int
00055 ACE_Stream_Head<ACE_SYNCH_USE>::svc (void)
00056 {
00057   ACE_TRACE ("ACE_Stream_Head<ACE_SYNCH_USE>::svc");
00058   return -1;
00059 }
00060 
00061 template <ACE_SYNCH_DECL> int
00062 ACE_Stream_Head<ACE_SYNCH_USE>::control (ACE_Message_Block *mb)
00063 {
00064   ACE_TRACE ("ACE_Stream_Head<ACE_SYNCH_USE>::control");
00065   ACE_IO_Cntl_Msg *ioc = (ACE_IO_Cntl_Msg *) mb->rd_ptr ();
00066   ACE_IO_Cntl_Msg::ACE_IO_Cntl_Cmds cmd;
00067 
00068   switch (cmd = ioc->cmd ())
00069     {
00070     case ACE_IO_Cntl_Msg::SET_LWM:
00071     case ACE_IO_Cntl_Msg::SET_HWM:
00072       this->water_marks (cmd, *(size_t *) mb->cont ()->rd_ptr ());
00073       ioc->rval (0);
00074       break;
00075     default:
00076       return 0;
00077     }
00078   return ioc->rval ();
00079 }
00080 
00081 // Performs canonical flushing at the ACE_Stream Head.
00082 
00083 template <ACE_SYNCH_DECL> int
00084 ACE_Stream_Head<ACE_SYNCH_USE>::canonical_flush (ACE_Message_Block *mb)
00085 {
00086   ACE_TRACE ("ACE_Stream_Head<ACE_SYNCH_USE>::canonical_flush");
00087   char *cp = mb->rd_ptr ();
00088 
00089   if (ACE_BIT_ENABLED (*cp, ACE_Task_Flags::ACE_FLUSHR))
00090     {
00091       this->flush (ACE_Task_Flags::ACE_FLUSHALL);
00092       ACE_CLR_BITS (*cp, ACE_Task_Flags::ACE_FLUSHR);
00093     }
00094 
00095   if (ACE_BIT_ENABLED (*cp, ACE_Task_Flags::ACE_FLUSHW))
00096     return this->reply (mb);
00097   else
00098     mb->release ();
00099   return 0;
00100 }
00101 
00102 template <ACE_SYNCH_DECL> int
00103 ACE_Stream_Head<ACE_SYNCH_USE>::put (ACE_Message_Block *mb,
00104                                      ACE_Time_Value *tv)
00105 {
00106   ACE_TRACE ("ACE_Stream_Head<ACE_SYNCH_USE>::put");
00107   int res = 0;
00108 
00109   if (mb->msg_type () == ACE_Message_Block::MB_IOCTL
00110       && (res = this->control (mb)) == -1)
00111     return res;
00112 
00113   if (this->is_writer ())
00114     return this->put_next (mb, tv);
00115   else // this->is_reader ()
00116     {
00117       switch (mb->msg_type ())
00118         {
00119         case ACE_Message_Block::MB_FLUSH:
00120           return this->canonical_flush (mb);
00121         default:
00122           break;
00123         }
00124 
00125       return this->putq (mb, tv);
00126     }
00127 }
00128 
00129 template <ACE_SYNCH_DECL> int
00130 ACE_Stream_Head<ACE_SYNCH_USE>::init (int, ACE_TCHAR *[])
00131 {
00132   ACE_TRACE ("ACE_Stream_Head<ACE_SYNCH_USE>::init");
00133   return 0;
00134 }
00135 
00136 template <ACE_SYNCH_DECL> int
00137 ACE_Stream_Head<ACE_SYNCH_USE>::info (ACE_TCHAR **strp, size_t length) const
00138 {
00139   ACE_TRACE ("ACE_Stream_Head<ACE_SYNCH_USE>::info");
00140   const ACE_TCHAR *name = this->name ();
00141 
00142   if (*strp == 0 && (*strp = ACE_OS::strdup (name)) == 0)
00143     return -1;
00144   else
00145     ACE_OS::strsncpy (*strp, name, length);
00146   return static_cast<int> (ACE_OS::strlen (name));
00147 }
00148 
00149 template <ACE_SYNCH_DECL> int
00150 ACE_Stream_Head<ACE_SYNCH_USE>::fini (void)
00151 {
00152   ACE_TRACE ("ACE_Stream_Head<ACE_SYNCH_USE>::fini");
00153   return 0;
00154 }
00155 
00156 ACE_ALLOC_HOOK_DEFINE(ACE_Stream_Tail)
00157 
00158 template <ACE_SYNCH_DECL>
00159 ACE_Stream_Tail<ACE_SYNCH_USE>::ACE_Stream_Tail (void)
00160 {
00161   ACE_TRACE ("ACE_Stream_Tail<ACE_SYNCH_USE>::ACE_Stream_Tail");
00162 }
00163 
00164 template <ACE_SYNCH_DECL>
00165 ACE_Stream_Tail<ACE_SYNCH_USE>::~ACE_Stream_Tail (void)
00166 {
00167   ACE_TRACE ("ACE_Stream_Tail<ACE_SYNCH_USE>::~ACE_Stream_Tail");
00168 }
00169 
00170 template <ACE_SYNCH_DECL> void
00171 ACE_Stream_Tail<ACE_SYNCH_USE>::dump (void) const
00172 {
00173 #if defined (ACE_HAS_DUMP)
00174   ACE_TRACE ("ACE_Stream_Tail<ACE_SYNCH_USE>::dump");
00175 #endif /* ACE_HAS_DUMP */
00176 }
00177 
00178 template <ACE_SYNCH_DECL> int
00179 ACE_Stream_Tail<ACE_SYNCH_USE>::open (void *)
00180 {
00181   ACE_TRACE ("ACE_Stream_Tail<ACE_SYNCH_USE>::open");
00182   return 0;
00183 }
00184 
00185 template <ACE_SYNCH_DECL> int
00186 ACE_Stream_Tail<ACE_SYNCH_USE>::close (u_long)
00187 {
00188   ACE_TRACE ("ACE_Stream_Tail<ACE_SYNCH_USE>::close");
00189   return 0;
00190 }
00191 
00192 template <ACE_SYNCH_DECL> int
00193 ACE_Stream_Tail<ACE_SYNCH_USE>::svc (void)
00194 {
00195   ACE_TRACE ("ACE_Stream_Tail<ACE_SYNCH_USE>::svc");
00196   return -1;
00197 }
00198 
00199 template <ACE_SYNCH_DECL> int
00200 ACE_Stream_Tail<ACE_SYNCH_USE>::control (ACE_Message_Block *mb)
00201 {
00202   ACE_TRACE ("ACE_Stream_Tail<ACE_SYNCH_USE>::control");
00203   ACE_IO_Cntl_Msg *ioc = (ACE_IO_Cntl_Msg *) mb->rd_ptr ();
00204   ACE_IO_Cntl_Msg::ACE_IO_Cntl_Cmds cmd;
00205 
00206   switch (cmd = ioc->cmd ())
00207     {
00208     case ACE_IO_Cntl_Msg::SET_LWM:
00209     case ACE_IO_Cntl_Msg::SET_HWM:
00210       {
00211         size_t wm_size = *(size_t *) mb->cont ()->rd_ptr ();
00212 
00213         this->water_marks (cmd, wm_size);
00214         this->sibling ()->water_marks (cmd, wm_size);
00215         ioc->rval (0);
00216         break;
00217       }
00218     default:
00219       mb->msg_type (ACE_Message_Block::MB_IOCNAK);
00220     }
00221   return this->reply (mb);
00222 }
00223 
00224 // Perform flush algorithm as though we were the driver.
00225 
00226 template <ACE_SYNCH_DECL> int
00227 ACE_Stream_Tail<ACE_SYNCH_USE>::canonical_flush (ACE_Message_Block *mb)
00228 {
00229   ACE_TRACE ("ACE_Stream_Tail<ACE_SYNCH_USE>::canonical_flush");
00230   char *cp = mb->rd_ptr ();
00231 
00232   if (ACE_BIT_ENABLED (*cp, ACE_Task_Flags::ACE_FLUSHW))
00233     {
00234       this->flush (ACE_Task_Flags::ACE_FLUSHALL);
00235       ACE_CLR_BITS (*cp, ACE_Task_Flags::ACE_FLUSHW);
00236     }
00237 
00238   if (ACE_BIT_ENABLED (*cp, ACE_Task_Flags::ACE_FLUSHR))
00239     {
00240       this->sibling ()->flush (ACE_Task_Flags::ACE_FLUSHALL);
00241       return this->reply (mb);
00242     }
00243   else
00244     mb->release ();
00245 
00246   return 0;
00247 }
00248 
00249 template <ACE_SYNCH_DECL> int
00250 ACE_Stream_Tail<ACE_SYNCH_USE>::put (ACE_Message_Block *mb,
00251                                    ACE_Time_Value *)
00252 {
00253   ACE_TRACE ("ACE_Stream_Tail<ACE_SYNCH_USE>::put");
00254 
00255   if (this->is_writer ())
00256     {
00257       switch (mb->msg_type ())
00258         {
00259         case ACE_Message_Block::MB_IOCTL:
00260           return this->control (mb);
00261           /* NOTREACHED */
00262         default:
00263           mb->release ();
00264           return 0;
00265           /* NOTREACHED */
00266         }
00267     }
00268 
00269   return -1;
00270 }
00271 
00272 template <ACE_SYNCH_DECL> int
00273 ACE_Stream_Tail<ACE_SYNCH_USE>::init (int, ACE_TCHAR *[])
00274 {
00275   ACE_TRACE ("ACE_Stream_Tail<ACE_SYNCH_USE>::init");
00276   return 0;
00277 }
00278 
00279 template <ACE_SYNCH_DECL> int
00280 ACE_Stream_Tail<ACE_SYNCH_USE>::info (ACE_TCHAR **strp, size_t length) const
00281 {
00282   ACE_TRACE ("ACE_Stream_Tail<ACE_SYNCH_USE>::info");
00283   const ACE_TCHAR *name = this->name ();
00284 
00285   if (*strp == 0 && (*strp = ACE_OS::strdup (name)) == 0)
00286     return -1;
00287   else
00288     ACE_OS::strsncpy (*strp, name, length);
00289   return static_cast<int> (ACE_OS::strlen (name));
00290 }
00291 
00292 template <ACE_SYNCH_DECL> int
00293 ACE_Stream_Tail<ACE_SYNCH_USE>::fini (void)
00294 {
00295   ACE_TRACE ("ACE_Stream_Tail<ACE_SYNCH_USE>::fini");
00296   return 0;
00297 }
00298 
00299 ACE_ALLOC_HOOK_DEFINE(ACE_Thru_Task)
00300 
00301 template <ACE_SYNCH_DECL>
00302 ACE_Thru_Task<ACE_SYNCH_USE>::ACE_Thru_Task (void)
00303 {
00304   ACE_TRACE ("ACE_Thru_Task<ACE_SYNCH_USE>::ACE_Thru_Task");
00305 }
00306 
00307 template <ACE_SYNCH_DECL>
00308 ACE_Thru_Task<ACE_SYNCH_USE>::~ACE_Thru_Task (void)
00309 {
00310   ACE_TRACE ("ACE_Thru_Task<ACE_SYNCH_USE>::~ACE_Thru_Task");
00311 }
00312 
00313 template <ACE_SYNCH_DECL> void
00314 ACE_Thru_Task<ACE_SYNCH_USE>::dump (void) const
00315 {
00316 #if defined (ACE_HAS_DUMP)
00317   ACE_TRACE ("ACE_Thru_Task<ACE_SYNCH_USE>::dump");
00318 #endif /* ACE_HAS_DUMP */
00319 }
00320 
00321 template <ACE_SYNCH_DECL> int
00322 ACE_Thru_Task<ACE_SYNCH_USE>::open (void *)
00323 {
00324   ACE_TRACE ("ACE_Thru_Task<ACE_SYNCH_USE>::open");
00325   return 0;
00326 }
00327 
00328 template <ACE_SYNCH_DECL> int
00329 ACE_Thru_Task<ACE_SYNCH_USE>::close (u_long)
00330 {
00331   ACE_TRACE ("ACE_Thru_Task<ACE_SYNCH_USE>::close");
00332   return 0;
00333 }
00334 
00335 template <ACE_SYNCH_DECL> int
00336 ACE_Thru_Task<ACE_SYNCH_USE>::svc (void)
00337 {
00338   ACE_TRACE ("ACE_Thru_Task<ACE_SYNCH_USE>::svc");
00339   return -1;
00340 }
00341 
00342 template <ACE_SYNCH_DECL> int
00343 ACE_Thru_Task<ACE_SYNCH_USE>::put (ACE_Message_Block *msg,
00344                                  ACE_Time_Value *tv)
00345 {
00346   ACE_TRACE ("ACE_Thru_Task<ACE_SYNCH_USE>::put");
00347   return this->put_next (msg, tv);
00348 }
00349 
00350 template <ACE_SYNCH_DECL> int
00351 ACE_Thru_Task<ACE_SYNCH_USE>::init (int, ACE_TCHAR *[])
00352 {
00353   ACE_TRACE ("ACE_Thru_Task<ACE_SYNCH_USE>::init");
00354   return 0;
00355 }
00356 
00357 template <ACE_SYNCH_DECL> int
00358 ACE_Thru_Task<ACE_SYNCH_USE>::info (ACE_TCHAR **strp,
00359                                     size_t length) const
00360 {
00361   ACE_TRACE ("ACE_Thru_Task<ACE_SYNCH_USE>::info");
00362   const ACE_TCHAR *name = this->name ();
00363 
00364   if (*strp == 0 && (*strp = ACE_OS::strdup (name)) == 0)
00365     return -1;
00366   else
00367     ACE_OS::strsncpy (*strp, name, length);
00368   return static_cast<int> (ACE_OS::strlen (name));
00369 }
00370 
00371 template <ACE_SYNCH_DECL> int
00372 ACE_Thru_Task<ACE_SYNCH_USE>::fini (void)
00373 {
00374   ACE_TRACE ("ACE_Thru_Task<ACE_SYNCH_USE>::fini");
00375   return 0;
00376 }
00377 
00378 ACE_END_VERSIONED_NAMESPACE_DECL
00379 
00380 #endif /* ACE_STREAM_MODULES_CPP */

Generated on Thu Nov 9 09:42:05 2006 for ACE by doxygen 1.3.6