ACE.inl

Go to the documentation of this file.
00001 // -*- C++ -*-
00002 //
00003 // ACE.inl,v 4.9 2006/05/30 13:15:24 schmidt Exp
00004 
00005 #include "ace/OS_NS_unistd.h"
00006 #include "ace/OS_NS_Thread.h"
00007 #include "ace/os_include/os_ctype.h"
00008 #include "ace/OS_NS_sys_socket.h"
00009 
00010 // Open versioned namespace, if enabled by the user.
00011 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00012 
00013 
00014 // Wrappers for methods that have been moved to ACE_OS.
00015 
00016 ACE_INLINE ssize_t
00017 ACE::read_n (ACE_HANDLE handle,
00018              void *buf,
00019              size_t len,
00020              size_t *bytes_transferred)
00021 {
00022   return ACE_OS::read_n (handle,
00023                          buf,
00024                          len,
00025                          bytes_transferred);
00026 }
00027 
00028 ACE_INLINE ssize_t
00029 ACE::write_n (ACE_HANDLE handle,
00030               const void *buf,
00031               size_t len,
00032               size_t *bytes_transferred)
00033 {
00034   return ACE_OS::write_n (handle,
00035                           buf,
00036                           len,
00037                           bytes_transferred);
00038 }
00039 
00040 ACE_INLINE ssize_t
00041 ACE::recv_n (ACE_HANDLE handle,
00042              void *buf,
00043              size_t len,
00044              int flags,
00045              const ACE_Time_Value *timeout,
00046              size_t *bytes_transferred)
00047 {
00048   if (timeout == 0)
00049     return ACE::recv_n_i (handle,
00050                           buf,
00051                           len,
00052                           flags,
00053                           bytes_transferred);
00054   else
00055     return ACE::recv_n_i (handle,
00056                           buf,
00057                           len,
00058                           flags,
00059                           timeout,
00060                           bytes_transferred);
00061 }
00062 
00063 #if defined (ACE_HAS_TLI)
00064 
00065 ACE_INLINE ssize_t
00066 ACE::t_rcv_n (ACE_HANDLE handle,
00067               void *buf,
00068               size_t len,
00069               int *flags,
00070               const ACE_Time_Value *timeout,
00071               size_t *bytes_transferred)
00072 {
00073   if (timeout == 0)
00074     return ACE::t_rcv_n_i (handle,
00075                            buf,
00076                            len,
00077                            flags,
00078                            bytes_transferred);
00079   else
00080     return ACE::t_rcv_n_i (handle,
00081                            buf,
00082                            len,
00083                            flags,
00084                            timeout,
00085                            bytes_transferred);
00086 }
00087 
00088 #endif /* ACE_HAS_TLI */
00089 
00090 ACE_INLINE ssize_t
00091 ACE::recv_n (ACE_HANDLE handle,
00092              void *buf,
00093              size_t len,
00094              const ACE_Time_Value *timeout,
00095              size_t *bytes_transferred)
00096 {
00097   if (timeout == 0)
00098     return ACE::recv_n_i (handle,
00099                           buf,
00100                           len,
00101                           bytes_transferred);
00102   else
00103     return ACE::recv_n_i (handle,
00104                           buf,
00105                           len,
00106                           timeout,
00107                           bytes_transferred);
00108 }
00109 
00110 ACE_INLINE ssize_t
00111 ACE::recvv_n (ACE_HANDLE handle,
00112               iovec *iov,
00113               int iovcnt,
00114               const ACE_Time_Value *timeout,
00115               size_t *bytes_transferred)
00116 {
00117   if (timeout == 0)
00118     return ACE::recvv_n_i (handle,
00119                            iov,
00120                            iovcnt,
00121                            bytes_transferred);
00122   else
00123     return ACE::recvv_n_i (handle,
00124                            iov,
00125                            iovcnt,
00126                            timeout,
00127                            bytes_transferred);
00128 }
00129 
00130 ACE_INLINE ssize_t
00131 ACE::send_n (ACE_HANDLE handle,
00132              const void *buf,
00133              size_t len,
00134              int flags,
00135              const ACE_Time_Value *timeout,
00136              size_t *bytes_transferred)
00137 {
00138   if (timeout == 0)
00139     return ACE::send_n_i (handle,
00140                           buf,
00141                           len,
00142                           flags,
00143                           bytes_transferred);
00144   else
00145     return ACE::send_n_i (handle,
00146                           buf,
00147                           len,
00148                           flags,
00149                           timeout,
00150                           bytes_transferred);
00151 }
00152 
00153 #if defined (ACE_HAS_TLI)
00154 
00155 ACE_INLINE ssize_t
00156 ACE::t_snd_n (ACE_HANDLE handle,
00157               const void *buf,
00158               size_t len,
00159               int flags,
00160               const ACE_Time_Value *timeout,
00161               size_t *bytes_transferred)
00162 {
00163   if (timeout == 0)
00164     return ACE::t_snd_n_i (handle,
00165                            buf,
00166                            len,
00167                            flags,
00168                            bytes_transferred);
00169   else
00170     return ACE::t_snd_n_i (handle,
00171                            buf,
00172                            len,
00173                            flags,
00174                            timeout,
00175                            bytes_transferred);
00176 }
00177 
00178 #endif /* ACE_HAS_TLI */
00179 
00180 ACE_INLINE ssize_t
00181 ACE::send_n (ACE_HANDLE handle,
00182              const void *buf,
00183              size_t len,
00184              const ACE_Time_Value *timeout,
00185              size_t *bytes_transferred)
00186 {
00187   if (timeout == 0)
00188     return ACE::send_n_i (handle,
00189                           buf,
00190                           len,
00191                           bytes_transferred);
00192   else
00193     return ACE::send_n_i (handle,
00194                           buf,
00195                           len,
00196                           timeout,
00197                           bytes_transferred);
00198 }
00199 
00200 ACE_INLINE ssize_t
00201 ACE::sendv_n (ACE_HANDLE handle,
00202               const iovec *iov,
00203               int iovcnt,
00204               const ACE_Time_Value *timeout,
00205               size_t *bytes_transferred)
00206 {
00207   if (timeout == 0)
00208     return ACE::sendv_n_i (handle,
00209                            iov,
00210                            iovcnt,
00211                            bytes_transferred);
00212   else
00213     return ACE::sendv_n_i (handle,
00214                            iov,
00215                            iovcnt,
00216                            timeout,
00217                            bytes_transferred);
00218 }
00219 
00220 ACE_INLINE ssize_t
00221 ACE::send_i (ACE_HANDLE handle, const void *buf, size_t len)
00222 {
00223 #if defined (ACE_WIN32) || defined (HPUX)
00224   return ACE_OS::send (handle, (const char *) buf, len);
00225 #else
00226   return ACE_OS::write (handle, (const char *) buf, len);
00227 #endif /* ACE_WIN32 */
00228 }
00229 
00230 ACE_INLINE ssize_t
00231 ACE::recv_i (ACE_HANDLE handle, void *buf, size_t len)
00232 {
00233 #if defined (ACE_WIN32) || defined (ACE_OPENVMS) || defined (ACE_TANDEM_T1248_PTHREADS)
00234   return ACE_OS::recv (handle, (char *) buf, len);
00235 #else
00236   return ACE_OS::read (handle, (char *) buf, len);
00237 #endif /* ACE_WIN32 */
00238 }
00239 
00240 ACE_INLINE int
00241 ACE::handle_read_ready (ACE_HANDLE handle,
00242                         const ACE_Time_Value *timeout)
00243 {
00244   return ACE::handle_ready (handle,
00245                             timeout,
00246                             1,
00247                             0,
00248                             0);
00249 }
00250 
00251 ACE_INLINE int
00252 ACE::handle_write_ready (ACE_HANDLE handle,
00253                          const ACE_Time_Value *timeout)
00254 {
00255   return ACE::handle_ready (handle,
00256                             timeout,
00257                             0,
00258                             1,
00259                             0);
00260 }
00261 
00262 ACE_INLINE int
00263 ACE::handle_exception_ready (ACE_HANDLE handle,
00264                              const ACE_Time_Value *timeout)
00265 {
00266   return ACE::handle_ready (handle,
00267                             timeout,
00268                             0,
00269                             0,
00270                             1);
00271 }
00272 
00273 ACE_INLINE void
00274 ACE::strdelete (char *s)
00275 {
00276   delete [] s;
00277 }
00278 
00279 #if defined (ACE_HAS_WCHAR)
00280 ACE_INLINE void
00281 ACE::strdelete (wchar_t *s)
00282 {
00283   delete [] s;
00284 }
00285 #endif /* ACE_HAS_WCHAR */
00286 
00287 ACE_INLINE void
00288 ACE::unique_name (const void *object,
00289                   ACE_TCHAR *name,
00290                   size_t length)
00291 {
00292   ACE_OS::unique_name (object, name, length);
00293 }
00294 
00295 ACE_INLINE u_long
00296 ACE::log2 (u_long num)
00297 {
00298   u_long log = 0;
00299 
00300   for (; num > 1; ++log)
00301     num >>= 1;
00302 
00303   return log;
00304 }
00305 
00306 ACE_INLINE ACE_TCHAR
00307 ACE::nibble2hex (u_int n)
00308 {
00309   // Hexadecimal characters.
00310 #if defined (ACE_VXWORKS) && !defined (__DCPLUSPLUS__)
00311   // temporary solution to prevent Windriver GNU toolchains from spewing
00312   // loads of warnings when inlining.
00313   // problem (incorrect warning leftover from older GNU) has been reported as
00314   // TSR to Windriver.
00315   const ACE_TCHAR hex_chars[] = ACE_LIB_TEXT ("0123456789abcdef");
00316 #else
00317   static const ACE_TCHAR hex_chars[] = ACE_LIB_TEXT ("0123456789abcdef");
00318 #endif
00319 
00320   // @@ UNICODE does this work?
00321   return hex_chars[n & 0x0f];
00322 }
00323 
00324 ACE_INLINE u_char
00325 ACE::hex2byte (ACE_TCHAR c)
00326 {
00327   if (isdigit (c))
00328     return (u_char) (c - ACE_LIB_TEXT ('0'));
00329   else if (islower (c))
00330     return (u_char) (10 + c - ACE_LIB_TEXT ('a'));
00331   else
00332     return (u_char) (10 + c - ACE_LIB_TEXT ('A'));
00333 }
00334 
00335 // Close versioned namespace, if enabled by the user.
00336 ACE_END_VERSIONED_NAMESPACE_DECL

Generated on Thu Nov 9 09:41:45 2006 for ACE by doxygen 1.3.6