dep/ACE_wrappers/ace/Message_Block.inl

   1 // -*- C++ -*-
   2 //
   3 // $Id: Message_Block.inl 80826 2008-03-04 14:51:23Z wotte $
   4
   5 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   6
   7 ACE_INLINE ACE_Data_Block *
   8 ACE_Message_Block::data_block (void) const
   9 {
  10   ACE_TRACE ("ACE_Message_Block::data_block");
  11   return this->data_block_;
  12 }
  13
  14 ACE_INLINE ACE_Message_Block::Message_Flags
  15 ACE_Message_Block::set_self_flags (ACE_Message_Block::Message_Flags more_flags)
  16 {
  17   ACE_TRACE ("ACE_Message_Block::set_self_flags");
  18   // Later we might mask more_glags so that user can't change internal
  19   // ones: more_flags &= ~(USER_FLAGS -1).
  20   return ACE_SET_BITS (this->flags_, more_flags);
  21 }
  22
  23 ACE_INLINE ACE_Message_Block::Message_Flags
  24 ACE_Message_Block::clr_self_flags (ACE_Message_Block::Message_Flags less_flags)
  25 {
  26   ACE_TRACE ("ACE_Message_Block::clr_self_flags");
  27   // Later we might mask more_flags so that user can't change internal
  28   // ones: less_flags &= ~(USER_FLAGS -1).
  29   return ACE_CLR_BITS (this->flags_, less_flags);
  30 }
  31
  32 ACE_INLINE ACE_Message_Block::Message_Flags
  33 ACE_Message_Block::self_flags (void) const
  34 {
  35   ACE_TRACE ("ACE_Message_Block::self_flags");
  36   return this->flags_;
  37 }
  38
  39 ACE_INLINE int
  40 ACE_Data_Block::reference_count_i (void) const
  41 {
  42   return reference_count_;
  43 }
  44
  45 ACE_INLINE int
  46 ACE_Message_Block::reference_count (void) const
  47 {
  48   return data_block () ? data_block ()->reference_count () : 0;
  49 }
  50
  51 ACE_INLINE char *
  52 ACE_Data_Block::base (void) const
  53 {
  54   ACE_TRACE ("ACE_Data_Block::base");
  55   return this->base_;
  56 }
  57
  58 ACE_INLINE size_t
  59 ACE_Data_Block::size (void) const
  60 {
  61   ACE_TRACE ("ACE_Data_Block::size");
  62   return this->cur_size_;
  63 }
  64
  65 ACE_INLINE size_t
  66 ACE_Data_Block::capacity (void) const
  67 {
  68   ACE_TRACE ("ACE_Data_Block::capacity");
  69   return this->max_size_;
  70 }
  71
  72 ACE_INLINE ACE_Message_Block::Message_Flags
  73 ACE_Data_Block::set_flags (ACE_Message_Block::Message_Flags more_flags)
  74 {
  75   ACE_TRACE ("ACE_Data_Block::set_flags");
  76   // Later we might mask more_glags so that user can't change internal
  77   // ones: more_flags &= ~(USER_FLAGS -1).
  78   return ACE_SET_BITS (this->flags_, more_flags);
  79 }
  80
  81 ACE_INLINE ACE_Message_Block::Message_Flags
  82 ACE_Data_Block::clr_flags (ACE_Message_Block::Message_Flags less_flags)
  83 {
  84   ACE_TRACE ("ACE_Data_Block::clr_flags");
  85   // Later we might mask more_flags so that user can't change internal
  86   // ones: less_flags &= ~(USER_FLAGS -1).
  87   return ACE_CLR_BITS (this->flags_, less_flags);
  88 }
  89
  90 ACE_INLINE ACE_Message_Block::Message_Flags
  91 ACE_Data_Block::flags (void) const
  92 {
  93   ACE_TRACE ("ACE_Data_Block::flags");
  94    return this->flags_;
  95 }
  96
  97 ACE_INLINE ACE_Allocator*
  98 ACE_Data_Block::data_block_allocator (void) const
  99 {
 100   ACE_TRACE ("ACE_Data_Block::data_block_allocator");
 101   return this->data_block_allocator_;
 102 }
 103
 104 ACE_INLINE ACE_Message_Block::Message_Flags
 105 ACE_Message_Block::set_flags (ACE_Message_Block::Message_Flags more_flags)
 106 {
 107   ACE_TRACE ("ACE_Message_Block::set_flags");
 108   return this->data_block ()->set_flags (more_flags);
 109 }
 110
 111 ACE_INLINE ACE_Message_Block::Message_Flags
 112 ACE_Message_Block::clr_flags (ACE_Message_Block::Message_Flags less_flags)
 113 {
 114   ACE_TRACE ("ACE_Message_Block::clr_flags");
 115   return this->data_block ()->clr_flags (less_flags);
 116 }
 117
 118 ACE_INLINE ACE_Message_Block::Message_Flags
 119 ACE_Message_Block::flags (void) const
 120 {
 121   ACE_TRACE ("ACE_Message_Block::flags");
 122    return this->data_block ()->flags ();
 123 }
 124
 125 // Return the length of the "active" portion of the message.
 126
 127 ACE_INLINE size_t
 128 ACE_Message_Block::length (void) const
 129 {
 130   ACE_TRACE ("ACE_Message_Block::length");
 131   return this->wr_ptr_ - this->rd_ptr_;
 132 }
 133
 134 // Sets the length of the "active" portion of the message.  This is
 135 // defined as the offset from RD_PTR to WR_PTR.
 136
 137 ACE_INLINE void
 138 ACE_Message_Block::length (size_t len)
 139 {
 140   ACE_TRACE ("ACE_Message_Block::length");
 141   this->wr_ptr_ = this->rd_ptr_ + len;
 142 }
 143
 144 // Return the length of the potential size of the message.
 145
 146 ACE_INLINE size_t
 147 ACE_Message_Block::size (void) const
 148 {
 149   ACE_TRACE ("ACE_Message_Block::size");
 150   return this->data_block ()->size ();
 151 }
 152
 153 ACE_INLINE size_t
 154 ACE_Message_Block::capacity (void) const
 155 {
 156   ACE_TRACE ("ACE_Message_Block::capacity");
 157   return this->data_block ()->capacity ();
 158 }
 159
 160 ACE_INLINE ACE_Message_Block::ACE_Message_Type
 161 ACE_Data_Block::msg_type (void) const
 162 {
 163   ACE_TRACE ("ACE_Data_Block::msg_type");
 164   return this->type_;
 165 }
 166
 167 ACE_INLINE void
 168 ACE_Data_Block::msg_type (ACE_Message_Block::ACE_Message_Type t)
 169 {
 170   ACE_TRACE ("ACE_Data_Block::msg_type");
 171   this->type_ = t;
 172 }
 173
 174 ACE_INLINE ACE_Message_Block::ACE_Message_Type
 175 ACE_Message_Block::msg_type (void) const
 176 {
 177   ACE_TRACE ("ACE_Message_Block::msg_type");
 178   return this->data_block ()->msg_type ();
 179 }
 180
 181 ACE_INLINE void
 182 ACE_Message_Block::msg_type (ACE_Message_Block::ACE_Message_Type t)
 183 {
 184   ACE_TRACE ("ACE_Message_Block::msg_type");
 185   this->data_block ()->msg_type (t);
 186 }
 187
 188 ACE_INLINE ACE_Message_Block::ACE_Message_Type
 189 ACE_Message_Block::msg_class (void) const
 190 {
 191   ACE_TRACE ("ACE_Message_Block::msg_class");
 192
 193   if (this->msg_type () < ACE_Message_Block::MB_PRIORITY)
 194     return ACE_Message_Block::MB_NORMAL;
 195   else if (this->msg_type () < ACE_Message_Block::MB_USER)
 196     return ACE_Message_Block::MB_PRIORITY;
 197   else
 198     return ACE_Message_Block::MB_USER;
 199 }
 200
 201 ACE_INLINE int
 202 ACE_Message_Block::is_data_msg (void) const
 203 {
 204   ACE_TRACE ("ACE_Message_Block::is_data_msg");
 205   ACE_Message_Type mt = this->msg_type ();
 206   return
 207     mt == ACE_Message_Block::MB_DATA
 208     || mt == ACE_Message_Block::MB_PROTO
 209     || mt == ACE_Message_Block::MB_PCPROTO;
 210 }
 211
 212 ACE_INLINE unsigned long
 213 ACE_Message_Block::msg_priority (void) const
 214 {
 215   ACE_TRACE ("ACE_Message_Block::msg_priority");
 216   return this->priority_;
 217 }
 218
 219 ACE_INLINE void
 220 ACE_Message_Block::msg_priority (unsigned long pri)
 221 {
 222   ACE_TRACE ("ACE_Message_Block::msg_priority");
 223   this->priority_ = pri;
 224 }
 225
 226 ACE_INLINE const ACE_Time_Value &
 227 ACE_Message_Block::msg_execution_time (void) const
 228 {
 229   ACE_TRACE ("ACE_Message_Block::msg_execution_time (void)");
 230 #if defined (ACE_HAS_TIMED_MESSAGE_BLOCKS)
 231   return this->execution_time_;
 232 #else
 233   return ACE_Time_Value::zero;
 234 #endif /* ACE_HAS_TIMED_MESSAGE_BLOCKS */
 235 }
 236
 237 ACE_INLINE void
 238 ACE_Message_Block::msg_execution_time (const ACE_Time_Value &et)
 239 {
 240   ACE_TRACE ("ACE_Message_Block::msg_execution_time (const ACE_Time_Value & et)");
 241 #if defined (ACE_HAS_TIMED_MESSAGE_BLOCKS)
 242   this->execution_time_ = et;
 243 #else
 244   ACE_UNUSED_ARG (et);
 245 #endif /* ACE_HAS_TIMED_MESSAGE_BLOCKS */
 246 }
 247
 248 ACE_INLINE const ACE_Time_Value &
 249 ACE_Message_Block::msg_deadline_time (void) const
 250 {
 251   ACE_TRACE ("ACE_Message_Block::msg_deadline_time (void)");
 252
 253 #if defined (ACE_HAS_TIMED_MESSAGE_BLOCKS)
 254   return this->deadline_time_;
 255 #else
 256   return ACE_Time_Value::max_time; // absolute time of deadline
 257 #endif /* ACE_HAS_TIMED_MESSAGE_BLOCKS */
 258 }
 259
 260 ACE_INLINE void
 261 ACE_Message_Block::msg_deadline_time (const ACE_Time_Value &dt)
 262 {
 263   ACE_TRACE ("ACE_Message_Block::msg_deadline_time (const ACE_Time_Value & et)");
 264 #if defined (ACE_HAS_TIMED_MESSAGE_BLOCKS)
 265   this->deadline_time_ = dt;
 266 #else
 267   ACE_UNUSED_ARG (dt);
 268 #endif /* ACE_HAS_TIMED_MESSAGE_BLOCKS */
 269 }
 270
 271 ACE_INLINE void
 272 ACE_Message_Block::access_allocators (ACE_Allocator *& allocator_strategy,
 273                                       ACE_Allocator *& data_block_allocator,
 274                                       ACE_Allocator *& message_block_allocator)
 275 {
 276   allocator_strategy =
 277     this->data_block_->allocator_strategy_;
 278   data_block_allocator =
 279     this->data_block_->data_block_allocator_;
 280   message_block_allocator =
 281     this->message_block_allocator_;
 282 }
 283
 284 ACE_INLINE char *
 285 ACE_Message_Block::base (void) const
 286 {
 287   ACE_TRACE ("ACE_Message_Block::base");
 288   return this->data_block ()->base ();
 289 }
 290
 291 ACE_INLINE void
 292 ACE_Message_Block::base (char *msg_data,
 293                          size_t msg_length,
 294                          Message_Flags msg_flags)
 295 {
 296   ACE_TRACE ("ACE_Message_Block::base");
 297   this->rd_ptr_ = 0;
 298   this->wr_ptr_ = 0;
 299   this->data_block ()->base (msg_data, msg_length, msg_flags);
 300 }
 301
 302 ACE_INLINE char *
 303 ACE_Message_Block::rd_ptr (void) const
 304 {
 305   ACE_TRACE ("ACE_Message_Block::rd_ptr");
 306   return this->base () + this->rd_ptr_;
 307 }
 308
 309 ACE_INLINE void
 310 ACE_Message_Block::wr_ptr (char *new_ptr)
 311 {
 312   ACE_TRACE ("ACE_Message_Block::wr_ptr");
 313   this->wr_ptr_ = new_ptr - this->base ();
 314 }
 315
 316 // Return a pointer to 1 past the end of the data buffer.
 317
 318 ACE_INLINE char *
 319 ACE_Data_Block::mark (void) const
 320 {
 321   ACE_TRACE ("ACE_Data_Block::mark");
 322   return this->base_ + this->cur_size_;
 323 }
 324
 325 ACE_INLINE char *
 326 ACE_Message_Block::mark (void) const
 327 {
 328   ACE_TRACE ("ACE_Message_Block::mark");
 329   return this->data_block ()->mark ();
 330 }
 331
 332 ACE_INLINE char *
 333 ACE_Data_Block::end (void) const
 334 {
 335   ACE_TRACE ("ACE_Data_Block::end");
 336   return this->base_ + this->max_size_;
 337 }
 338
 339 ACE_INLINE char *
 340 ACE_Message_Block::end (void) const
 341 {
 342   ACE_TRACE ("ACE_Message_Block::end");
 343   return this->data_block ()->end ();
 344 }
 345
 346
 347 ACE_INLINE void
 348 ACE_Message_Block::rd_ptr (char *new_ptr)
 349 {
 350   ACE_TRACE ("ACE_Message_Block::rd_ptr");
 351   this->rd_ptr_ = new_ptr - this->base ();
 352 }
 353
 354 ACE_INLINE void
 355 ACE_Message_Block::rd_ptr (size_t n)
 356 {
 357   ACE_TRACE ("ACE_Message_Block::rd_ptr");
 358   this->rd_ptr_ += n;
 359 }
 360
 361 ACE_INLINE char *
 362 ACE_Message_Block::wr_ptr (void) const
 363 {
 364   ACE_TRACE ("ACE_Message_Block::wr_ptr");
 365   return this->base () + this->wr_ptr_;
 366 }
 367
 368 ACE_INLINE void
 369 ACE_Message_Block::wr_ptr (size_t n)
 370 {
 371   ACE_TRACE ("ACE_Message_Block::wr_ptr");
 372   this->wr_ptr_ += n;
 373 }
 374
 375 ACE_INLINE void
 376 ACE_Message_Block::reset (void)
 377 {
 378   ACE_TRACE ("ACE_Message_Block::reset");
 379   this->rd_ptr_ = 0;
 380   this->wr_ptr_ = 0;
 381 }
 382
 383 ACE_INLINE size_t
 384 ACE_Message_Block::space (void) const
 385 {
 386   ACE_TRACE ("ACE_Message_Block::space");
 387   return this->mark () - this->wr_ptr ();
 388 }
 389
 390 ACE_INLINE ACE_Data_Block *
 391 ACE_Message_Block::replace_data_block (ACE_Data_Block *db)
 392 {
 393   ACE_TRACE ("ACE_Message_Block::replace_data_block");
 394   ACE_Data_Block *old = this->data_block_;
 395   this->data_block_ = db;
 396
 397   if (db != 0)
 398     {
 399       // Set the read and write pointers in the <Message_Block> to point
 400       // to the buffer in the <ACE_Data_Block>.
 401       this->rd_ptr (this->data_block ()->base ());
 402       this->wr_ptr (this->data_block ()->base ());
 403     }
 404
 405   return old;
 406 }
 407
 408 ACE_INLINE void
 409 ACE_Message_Block::cont (ACE_Message_Block *cont_msg)
 410 {
 411   ACE_TRACE ("ACE_Message_Block::cont");
 412   this->cont_ = cont_msg;
 413 }
 414
 415 ACE_INLINE ACE_Message_Block *
 416 ACE_Message_Block::cont (void) const
 417 {
 418   ACE_TRACE ("ACE_Message_Block::cont");
 419   return this->cont_;
 420 }
 421
 422 ACE_INLINE void
 423 ACE_Message_Block::reset_allocators (ACE_Allocator *allocator_strategy,
 424                                      ACE_Allocator *data_block_allocator,
 425                                      ACE_Allocator *message_block_allocator)
 426 {
 427   this->data_block_->allocator_strategy_ =
 428     allocator_strategy;
 429   this->data_block_->data_block_allocator_ =
 430     data_block_allocator;
 431   this->message_block_allocator_ =
 432     message_block_allocator;
 433
 434   if (this->cont () != 0)
 435     this->cont ()->reset_allocators (allocator_strategy,
 436                                      data_block_allocator,
 437                                      message_block_allocator);
 438 }
 439
 440 ACE_INLINE void
 441 ACE_Message_Block::next (ACE_Message_Block *next_msg)
 442 {
 443   ACE_TRACE ("ACE_Message_Block::next");
 444   this->next_ = next_msg;
 445 }
 446
 447 ACE_INLINE ACE_Message_Block *
 448 ACE_Message_Block::next (void) const
 449 {
 450   ACE_TRACE ("ACE_Message_Block::next");
 451   return this->next_;
 452 }
 453
 454 ACE_INLINE void
 455 ACE_Message_Block::prev (ACE_Message_Block *next_msg)
 456 {
 457   ACE_TRACE ("ACE_Message_Block::prev");
 458   this->prev_ = next_msg;
 459 }
 460
 461 ACE_INLINE ACE_Message_Block *
 462 ACE_Message_Block::prev (void) const
 463 {
 464   ACE_TRACE ("ACE_Message_Block::prev");
 465   return this->prev_;
 466 }
 467
 468 ACE_INLINE ACE_Allocator *
 469 ACE_Data_Block::allocator_strategy (void) const
 470 {
 471   ACE_TRACE ("ACE_Data_Block::allocator_strategy");
 472   return this->allocator_strategy_;
 473 }
 474
 475 ACE_INLINE ACE_Lock *
 476 ACE_Data_Block::locking_strategy (void)
 477 {
 478   ACE_TRACE ("ACE_Data_Block::locking_strategy");
 479   return this->locking_strategy_;
 480 }
 481
 482 ACE_INLINE ACE_Lock *
 483 ACE_Data_Block::locking_strategy (ACE_Lock *nls)
 484 {
 485   ACE_TRACE ("ACE_Data_Block::locking_strategy");
 486   ACE_Lock *ols = this->locking_strategy_;
 487
 488   this->locking_strategy_ = nls;
 489   return ols;
 490 }
 491
 492 ACE_INLINE ACE_Lock *
 493 ACE_Message_Block::locking_strategy (void)
 494 {
 495   ACE_TRACE ("ACE_Message_Block::locking_strategy");
 496   return this->data_block ()->locking_strategy ();
 497 }
 498
 499 ACE_INLINE ACE_Lock *
 500 ACE_Message_Block::locking_strategy (ACE_Lock *nls)
 501 {
 502   ACE_TRACE ("ACE_Message_Block::locking_strategy");
 503   ACE_Lock *ols = this->data_block ()->locking_strategy ();
 504   this->data_block ()->locking_strategy (nls);
 505   return ols;
 506 }
 507
 508 ACE_END_VERSIONED_NAMESPACE_DECL