ACE/ace/MEM_IO.inl

   1 // -*- C++ -*-
   2 #include "ace/OS_NS_string.h"
   3 #include "ace/Truncate.h"
   4
   5 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   6
   7 ACE_INLINE
   8 ACE_Reactive_MEM_IO::ACE_Reactive_MEM_IO ()
   9 {
  10 }
  11
  12 #if defined (ACE_WIN32) || !defined (_ACE_USE_SV_SEM)
  13 ACE_INLINE
  14 ACE_MT_MEM_IO::Simple_Queue::Simple_Queue ()
  15   : mq_ (0),
  16     malloc_ (0)
  17 {
  18 }
  19
  20 ACE_INLINE
  21 ACE_MT_MEM_IO::ACE_MT_MEM_IO ()
  22 {
  23   this->recv_channel_.sema_ = 0;
  24   this->recv_channel_.lock_ = 0;
  25   this->send_channel_.sema_ = 0;
  26   this->send_channel_.lock_ = 0;
  27 }
  28
  29 ACE_INLINE
  30 ACE_MT_MEM_IO::Simple_Queue::Simple_Queue (MQ_Struct *mq)
  31   : mq_ (mq),
  32     malloc_ (0)
  33 {
  34 }
  35
  36 ACE_INLINE int
  37 ACE_MT_MEM_IO::Simple_Queue::init (MQ_Struct *mq,
  38                                    ACE_MEM_SAP::MALLOC_TYPE *malloc)
  39 {
  40   if (this->mq_ != 0)
  41     return -1;
  42
  43   this->mq_ = mq;
  44   this->malloc_ = malloc;
  45   return 0;
  46 }
  47 #endif /* ACE_WIN32 || !_ACE_USE_SV_SEM */
  48
  49 ACE_INLINE ssize_t
  50 ACE_Reactive_MEM_IO::get_buf_len (const ACE_OFF_T off, ACE_MEM_SAP_Node *&buf)
  51 {
  52 #if !defined (ACE_HAS_WIN32_STRUCTURED_EXCEPTIONS)
  53   ACE_TRACE ("ACE_Reactive_MEM_IO::get_buf_len");
  54 #endif /* ACE_HAS_WIN32_STRUCTURED_EXCEPTIONS */
  55
  56   if (this->shm_malloc_ == 0)
  57     {
  58       return -1;
  59     }
  60
  61   ssize_t retv = 0;
  62
  63   ACE_SEH_TRY
  64     {
  65       buf =
  66         reinterpret_cast<ACE_MEM_SAP_Node *> (
  67           static_cast<char *> (this->shm_malloc_->base_addr ()) + off);
  68       retv = ACE_Utils::truncate_cast<ssize_t> (buf->size ());
  69     }
  70   ACE_SEH_EXCEPT (this->shm_malloc_->memory_pool ().seh_selector (GetExceptionInformation ()))
  71     {
  72     }
  73
  74   return retv;
  75 }
  76
  77 // Send an n byte message to the connected socket.
  78 ACE_INLINE
  79 ACE_MEM_IO::ACE_MEM_IO ()
  80   : deliver_strategy_ (0),
  81     recv_buffer_ (0),
  82     buf_size_ (0),
  83     cur_offset_ (0)
  84 {
  85   // ACE_TRACE ("ACE_MEM_IO::ACE_MEM_IO");
  86 }
  87
  88 ACE_INLINE ssize_t
  89 ACE_MEM_IO::fetch_recv_buf (int flag, const ACE_Time_Value *timeout)
  90 {
  91   ACE_TRACE ("ACE_MEM_IO::fetch_recv_buf");
  92
  93   if (this->deliver_strategy_ == 0)
  94     return -1;
  95
  96   // This method can only be called when <buf_size_> == <cur_offset_>.
  97   ACE_ASSERT (this->buf_size_ == this->cur_offset_);
  98
  99   // We have done using the previous buffer, return it to malloc.
 100   if (this->recv_buffer_ != 0)
 101     this->deliver_strategy_->release_buffer (this->recv_buffer_);
 102
 103   this->cur_offset_ = 0;
 104   ssize_t retv = 0;
 105
 106   if ((retv = this->deliver_strategy_->recv_buf (this->recv_buffer_,
 107                                                  flag,
 108                                                  timeout)) > 0)
 109     this->buf_size_ = retv;
 110   else
 111     this->buf_size_ = 0;
 112
 113   return retv;
 114 }
 115
 116 ACE_INLINE
 117 ACE_MEM_IO::~ACE_MEM_IO ()
 118 {
 119   delete this->deliver_strategy_;
 120 }
 121
 122 ACE_INLINE ssize_t
 123 ACE_MEM_IO::send (const void *buf,
 124                   size_t len,
 125                   int flags,
 126                   const ACE_Time_Value *timeout)
 127 {
 128   ACE_TRACE ("ACE_MEM_IO::send");
 129
 130   if (this->deliver_strategy_ == 0)
 131     {
 132       return 0;
 133     }
 134
 135   ACE_MEM_SAP_Node *sbuf =
 136     this->deliver_strategy_->acquire_buffer (
 137       ACE_Utils::truncate_cast<ssize_t> (len));
 138
 139   if (sbuf == 0)
 140     {
 141       return -1;                  // Memory buffer not initialized.
 142     }
 143
 144   ACE_OS::memcpy (sbuf->data (), buf, len);
 145
 146   ///
 147
 148   sbuf->size_ = len;
 149
 150   return this->deliver_strategy_->send_buf (sbuf,
 151                                             flags,
 152                                             timeout);
 153 }
 154
 155 ACE_INLINE ssize_t
 156 ACE_MEM_IO::recv (void *buf,
 157                   size_t len,
 158                   int flags,
 159                   const ACE_Time_Value *timeout)
 160 {
 161   ACE_TRACE ("ACE_MEM_IO::recv");
 162
 163   size_t count = 0;
 164
 165   size_t buf_len = this->buf_size_ - this->cur_offset_;
 166
 167   if (buf_len == 0)
 168     {
 169       ssize_t blen =         // Buffer length
 170         this->fetch_recv_buf (flags, timeout);
 171
 172       if (blen <= 0)
 173         {
 174           return blen;
 175         }
 176
 177       buf_len = this->buf_size_;
 178     }
 179
 180   size_t length = (len > buf_len ? buf_len : len);
 181
 182   ACE_OS::memcpy ((char *) buf + count,
 183                   (char *) this->recv_buffer_->data () + this->cur_offset_,
 184                   length);
 185   this->cur_offset_ += ACE_Utils::truncate_cast<ssize_t> (length);
 186   count += length;
 187
 188   return ACE_Utils::truncate_cast<ssize_t> (count);
 189 }
 190
 191 ACE_INLINE ssize_t
 192 ACE_MEM_IO::send (const void *buf, size_t n, int flags)
 193 {
 194   ACE_TRACE ("ACE_MEM_IO::send");
 195   return this->send (buf, n, flags, 0);
 196 }
 197
 198 // Recv an n byte message from the connected socket.
 199
 200 ACE_INLINE ssize_t
 201 ACE_MEM_IO::recv (void *buf, size_t n, int flags)
 202 {
 203   ACE_TRACE ("ACE_MEM_IO::recv");
 204   return this->recv (buf, n, flags, 0);
 205 }
 206
 207 // Send an n byte message to the connected socket.
 208
 209 ACE_INLINE ssize_t
 210 ACE_MEM_IO::send (const void *buf, size_t n)
 211 {
 212   ACE_TRACE ("ACE_MEM_IO::send");
 213   return this->send (buf, n, 0);
 214 }
 215
 216 // Recv an n byte message from the connected socket.
 217
 218 ACE_INLINE ssize_t
 219 ACE_MEM_IO::recv (void *buf, size_t n)
 220 {
 221   ACE_TRACE ("ACE_MEM_IO::recv");
 222
 223   return this->recv (buf, n, 0);
 224 }
 225
 226 ACE_INLINE ssize_t
 227 ACE_MEM_IO::recv (void *buf,
 228                   size_t len,
 229                   const ACE_Time_Value *timeout)
 230 {
 231   ACE_TRACE ("ACE_MEM_IO::recv");
 232   return this->recv (buf, len, 0, timeout);
 233 }
 234
 235 ACE_INLINE ssize_t
 236 ACE_MEM_IO::send (const void *buf,
 237                   size_t len,
 238                   const ACE_Time_Value *timeout)
 239 {
 240   ACE_TRACE ("ACE_MEM_IO::send");
 241   return this->send (buf, len, 0, timeout);
 242 }
 243
 244 ACE_END_VERSIONED_NAMESPACE_DECL