ACE/ace/Message_Block.inl

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