Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members   Related Pages  

Message_Block.i

Go to the documentation of this file.
00001 /* -*- C++ -*- */
00002 // $Id: Message_Block.i,v 1.1.1.4 2003/02/21 18:36:32 chad Exp $
00003 
00004 // Message_Block.i
00005 
00006 ACE_INLINE ACE_Data_Block *
00007 ACE_Message_Block::data_block (void) const
00008 {
00009   ACE_TRACE ("ACE_Message_Block::data_block");
00010   return this->data_block_;
00011 }
00012 
00013 ACE_INLINE ACE_Message_Block::Message_Flags
00014 ACE_Message_Block::set_self_flags (ACE_Message_Block::Message_Flags more_flags)
00015 {
00016   ACE_TRACE ("ACE_Message_Block::set_self_flags");
00017   // Later we might mask more_glags so that user can't change internal
00018   // ones: more_flags &= ~(USER_FLAGS -1).
00019   return ACE_SET_BITS (this->flags_, more_flags);
00020 }
00021 
00022 ACE_INLINE ACE_Message_Block::Message_Flags
00023 ACE_Message_Block::clr_self_flags (ACE_Message_Block::Message_Flags less_flags)
00024 {
00025   ACE_TRACE ("ACE_Message_Block::clr_self_flags");
00026   // Later we might mask more_flags so that user can't change internal
00027   // ones: less_flags &= ~(USER_FLAGS -1).
00028   return ACE_CLR_BITS (this->flags_, less_flags);
00029 }
00030 
00031 ACE_INLINE ACE_Message_Block::Message_Flags
00032 ACE_Message_Block::self_flags (void) const
00033 {
00034   ACE_TRACE ("ACE_Message_Block::self_flags");
00035   return this->flags_;
00036 }
00037 
00038 
00039 // This function must comes before ACE_Message_Block::reference_count
00040 // to avoid a g++ warning.
00041 ACE_INLINE int
00042 ACE_Data_Block::reference_count (void) const
00043 {
00044   return reference_count_;
00045 }
00046 
00047 ACE_INLINE int
00048 ACE_Message_Block::reference_count (void) const
00049 {
00050   return data_block () ? data_block ()->reference_count () : 0;
00051 }
00052 
00053 ACE_INLINE char *
00054 ACE_Data_Block::base (void) const
00055 {
00056   ACE_TRACE ("ACE_Data_Block::base");
00057   return this->base_;
00058 }
00059 
00060 ACE_INLINE size_t
00061 ACE_Data_Block::size (void) const
00062 {
00063   ACE_TRACE ("ACE_Data_Block::size");
00064   return this->cur_size_;
00065 }
00066 
00067 ACE_INLINE size_t
00068 ACE_Data_Block::capacity (void) const
00069 {
00070   ACE_TRACE ("ACE_Data_Block::capacity");
00071   return this->max_size_;
00072 }
00073 
00074 ACE_INLINE ACE_Message_Block::Message_Flags
00075 ACE_Data_Block::set_flags (ACE_Message_Block::Message_Flags more_flags)
00076 {
00077   ACE_TRACE ("ACE_Data_Block::set_flags");
00078   // Later we might mask more_glags so that user can't change internal
00079   // ones: more_flags &= ~(USER_FLAGS -1).
00080   return ACE_SET_BITS (this->flags_, more_flags);
00081 }
00082 
00083 ACE_INLINE ACE_Message_Block::Message_Flags
00084 ACE_Data_Block::clr_flags (ACE_Message_Block::Message_Flags less_flags)
00085 {
00086   ACE_TRACE ("ACE_Data_Block::clr_flags");
00087   // Later we might mask more_flags so that user can't change internal
00088   // ones: less_flags &= ~(USER_FLAGS -1).
00089   return ACE_CLR_BITS (this->flags_, less_flags);
00090 }
00091 
00092 ACE_INLINE ACE_Message_Block::Message_Flags
00093 ACE_Data_Block::flags (void) const
00094 {
00095   ACE_TRACE ("ACE_Data_Block::flags");
00096    return this->flags_;
00097 }
00098 
00099 ACE_INLINE ACE_Allocator*
00100 ACE_Data_Block::data_block_allocator (void) const
00101 {
00102   ACE_TRACE ("ACE_Data_Block::data_block_allocator");
00103   return this->data_block_allocator_;
00104 }
00105 
00106 ACE_INLINE ACE_Message_Block::Message_Flags
00107 ACE_Message_Block::set_flags (ACE_Message_Block::Message_Flags more_flags)
00108 {
00109   ACE_TRACE ("ACE_Message_Block::set_flags");
00110   return this->data_block ()->set_flags (more_flags);
00111 }
00112 
00113 ACE_INLINE ACE_Message_Block::Message_Flags
00114 ACE_Message_Block::clr_flags (ACE_Message_Block::Message_Flags less_flags)
00115 {
00116   ACE_TRACE ("ACE_Message_Block::clr_flags");
00117   return this->data_block ()->clr_flags (less_flags);
00118 }
00119 
00120 ACE_INLINE ACE_Message_Block::Message_Flags
00121 ACE_Message_Block::flags (void) const
00122 {
00123   ACE_TRACE ("ACE_Message_Block::flags");
00124    return this->data_block ()->flags ();
00125 }
00126 
00127 // Return the length of the "active" portion of the message.
00128 
00129 ACE_INLINE size_t
00130 ACE_Message_Block::length (void) const
00131 {
00132   ACE_TRACE ("ACE_Message_Block::length");
00133   return this->wr_ptr_ - this->rd_ptr_;
00134 }
00135 
00136 // Sets the length of the "active" portion of the message.  This is
00137 // defined as the offset from RD_PTR to WR_PTR.
00138 
00139 ACE_INLINE void
00140 ACE_Message_Block::length (size_t len)
00141 {
00142   ACE_TRACE ("ACE_Message_Block::length");
00143   this->wr_ptr_ = this->rd_ptr_ + len;
00144 }
00145 
00146 // Return the length of the potential size of the message.
00147 
00148 ACE_INLINE size_t
00149 ACE_Message_Block::size (void) const
00150 {
00151   ACE_TRACE ("ACE_Message_Block::size");
00152   return this->data_block ()->size ();
00153 }
00154 
00155 ACE_INLINE size_t
00156 ACE_Message_Block::capacity (void) const
00157 {
00158   ACE_TRACE ("ACE_Message_Block::capacity");
00159   return this->data_block ()->capacity ();
00160 }
00161 
00162 ACE_INLINE ACE_Message_Block::ACE_Message_Type
00163 ACE_Data_Block::msg_type (void) const
00164 {
00165   ACE_TRACE ("ACE_Data_Block::msg_type");
00166   return this->type_;
00167 }
00168 
00169 ACE_INLINE void
00170 ACE_Data_Block::msg_type (ACE_Message_Block::ACE_Message_Type t)
00171 {
00172   ACE_TRACE ("ACE_Data_Block::msg_type");
00173   this->type_ = t;
00174 }
00175 
00176 ACE_INLINE ACE_Message_Block::ACE_Message_Type
00177 ACE_Message_Block::msg_type (void) const
00178 {
00179   ACE_TRACE ("ACE_Message_Block::msg_type");
00180   return this->data_block ()->msg_type ();
00181 }
00182 
00183 ACE_INLINE void
00184 ACE_Message_Block::msg_type (ACE_Message_Block::ACE_Message_Type t)
00185 {
00186   ACE_TRACE ("ACE_Message_Block::msg_type");
00187   this->data_block ()->msg_type (t);
00188 }
00189 
00190 ACE_INLINE ACE_Message_Block::ACE_Message_Type
00191 ACE_Message_Block::msg_class (void) const
00192 {
00193   ACE_TRACE ("ACE_Message_Block::msg_class");
00194 
00195   if (this->msg_type () < ACE_Message_Block::MB_PRIORITY)
00196     return ACE_Message_Block::MB_NORMAL;
00197   else if (this->msg_type () < ACE_Message_Block::MB_USER)
00198     return ACE_Message_Block::MB_PRIORITY;
00199   else
00200     return ACE_Message_Block::MB_USER;
00201 }
00202 
00203 ACE_INLINE int
00204 ACE_Message_Block::is_data_msg (void) const
00205 {
00206   ACE_TRACE ("ACE_Message_Block::is_data_msg");
00207   ACE_Message_Type mt = this->msg_type ();
00208   return
00209     mt == ACE_Message_Block::MB_DATA
00210     || mt == ACE_Message_Block::MB_PROTO
00211     || mt == ACE_Message_Block::MB_PCPROTO;
00212 }
00213 
00214 ACE_INLINE u_long
00215 ACE_Message_Block::msg_priority (void) const
00216 {
00217   ACE_TRACE ("ACE_Message_Block::msg_priority");
00218   return this->priority_;
00219 }
00220 
00221 ACE_INLINE void
00222 ACE_Message_Block::msg_priority (u_long pri)
00223 {
00224   ACE_TRACE ("ACE_Message_Block::msg_priority");
00225   this->priority_ = pri;
00226 }
00227 
00228 ACE_INLINE const ACE_Time_Value &
00229 ACE_Message_Block::msg_execution_time (void) const
00230 {
00231   ACE_TRACE ("ACE_Message_Block::msg_execution_time (void)");
00232 #if defined (ACE_HAS_TIMED_MESSAGE_BLOCKS)
00233   return this->execution_time_;
00234 #else
00235   return ACE_Time_Value::zero;
00236 #endif /* ACE_HAS_TIMED_MESSAGE_BLOCKS */
00237 }
00238 
00239 ACE_INLINE void
00240 ACE_Message_Block::msg_execution_time (const ACE_Time_Value &et)
00241 {
00242   ACE_TRACE ("ACE_Message_Block::msg_execution_time (const ACE_Time_Value & et)");
00243 #if defined (ACE_HAS_TIMED_MESSAGE_BLOCKS)
00244   this->execution_time_ = et;
00245 #else
00246   ACE_UNUSED_ARG (et);
00247 #endif /* ACE_HAS_TIMED_MESSAGE_BLOCKS */
00248 }
00249 
00250 ACE_INLINE const ACE_Time_Value &
00251 ACE_Message_Block::msg_deadline_time (void) const
00252 {
00253   ACE_TRACE ("ACE_Message_Block::msg_deadline_time (void)");
00254 
00255 #if defined (ACE_HAS_TIMED_MESSAGE_BLOCKS)
00256   return this->deadline_time_;
00257 #else
00258   return ACE_Time_Value::max_time; // absolute time of deadline
00259 #endif /* ACE_HAS_TIMED_MESSAGE_BLOCKS */
00260 }
00261 
00262 ACE_INLINE void
00263 ACE_Message_Block::msg_deadline_time (const ACE_Time_Value &dt)
00264 {
00265   ACE_TRACE ("ACE_Message_Block::msg_deadline_time (const ACE_Time_Value & et)");
00266 #if defined (ACE_HAS_TIMED_MESSAGE_BLOCKS)
00267   this->deadline_time_ = dt;
00268 #else
00269   ACE_UNUSED_ARG (dt);
00270 #endif /* ACE_HAS_TIMED_MESSAGE_BLOCKS */
00271 }
00272 
00273 ACE_INLINE void
00274 ACE_Message_Block::access_allocators (ACE_Allocator *& allocator_strategy,
00275                                       ACE_Allocator *& data_block_allocator,
00276                                       ACE_Allocator *& message_block_allocator)
00277 {
00278   allocator_strategy =
00279     this->data_block_->allocator_strategy_;
00280   data_block_allocator =
00281     this->data_block_->data_block_allocator_;
00282   message_block_allocator =
00283     this->message_block_allocator_;
00284 }
00285 
00286 ACE_INLINE char *
00287 ACE_Message_Block::base (void) const
00288 {
00289   ACE_TRACE ("ACE_Message_Block::base");
00290   return this->data_block ()->base ();
00291 }
00292 
00293 ACE_INLINE void
00294 ACE_Message_Block::base (char *msg_data,
00295                          size_t msg_length,
00296                          Message_Flags msg_flags)
00297 {
00298   ACE_TRACE ("ACE_Message_Block::base");
00299   this->rd_ptr_ = 0;
00300   this->wr_ptr_ = 0;
00301   this->data_block ()->base (msg_data, msg_length, msg_flags);
00302 }
00303 
00304 ACE_INLINE char *
00305 ACE_Message_Block::rd_ptr (void) const
00306 {
00307   ACE_TRACE ("ACE_Message_Block::rd_ptr");
00308   return this->base () + this->rd_ptr_;
00309 }
00310 
00311 ACE_INLINE void
00312 ACE_Message_Block::wr_ptr (char *new_ptr)
00313 {
00314   ACE_TRACE ("ACE_Message_Block::wr_ptr");
00315   this->wr_ptr_ = new_ptr - this->base ();
00316 }
00317 
00318 // Return a pointer to 1 past the end of the data buffer.
00319 
00320 ACE_INLINE char *
00321 ACE_Data_Block::mark (void) const
00322 {
00323   ACE_TRACE ("ACE_Data_Block::mark");
00324   return this->base_ + this->cur_size_;
00325 }
00326 
00327 ACE_INLINE char *
00328 ACE_Message_Block::mark (void) const
00329 {
00330   ACE_TRACE ("ACE_Message_Block::mark");
00331   return this->data_block ()->mark ();
00332 }
00333 
00334 ACE_INLINE char *
00335 ACE_Data_Block::end (void) const
00336 {
00337   ACE_TRACE ("ACE_Data_Block::end");
00338   return this->base_ + this->max_size_;
00339 }
00340 
00341 ACE_INLINE char *
00342 ACE_Message_Block::end (void) const
00343 {
00344   ACE_TRACE ("ACE_Message_Block::end");
00345   return this->data_block ()->end ();
00346 }
00347 
00348 
00349 ACE_INLINE void
00350 ACE_Message_Block::rd_ptr (char *new_ptr)
00351 {
00352   ACE_TRACE ("ACE_Message_Block::rd_ptr");
00353   this->rd_ptr_ = new_ptr - this->base ();
00354 }
00355 
00356 ACE_INLINE void
00357 ACE_Message_Block::rd_ptr (size_t n)
00358 {
00359   ACE_TRACE ("ACE_Message_Block::rd_ptr");
00360   this->rd_ptr_ += n;
00361 }
00362 
00363 ACE_INLINE char *
00364 ACE_Message_Block::wr_ptr (void) const
00365 {
00366   ACE_TRACE ("ACE_Message_Block::wr_ptr");
00367   return this->base () + this->wr_ptr_;
00368 }
00369 
00370 ACE_INLINE void
00371 ACE_Message_Block::wr_ptr (size_t n)
00372 {
00373   ACE_TRACE ("ACE_Message_Block::wr_ptr");
00374   this->wr_ptr_ += n;
00375 }
00376 
00377 ACE_INLINE void
00378 ACE_Message_Block::reset (void)
00379 {
00380   ACE_TRACE ("ACE_Message_Block::reset");
00381   this->rd_ptr_ = 0;
00382   this->wr_ptr_ = 0;
00383 }
00384 
00385 ACE_INLINE size_t
00386 ACE_Message_Block::space (void) const
00387 {
00388   ACE_TRACE ("ACE_Message_Block::space");
00389   return this->mark () - this->wr_ptr ();
00390 }
00391 
00392 ACE_INLINE ACE_Data_Block *
00393 ACE_Message_Block::replace_data_block (ACE_Data_Block *db)
00394 {
00395   ACE_TRACE ("ACE_Message_Block::replace_data_block");
00396   ACE_Data_Block *old = this->data_block_;
00397   this->data_block_ = db;
00398 
00399   if (db != 0)
00400     {
00401       // Set the read and write pointers in the <Message_Block> to point
00402       // to the buffer in the <ACE_Data_Block>.
00403       this->rd_ptr (this->data_block ()->base ());
00404       this->wr_ptr (this->data_block ()->base ());
00405     }
00406 
00407   return old;
00408 }
00409 
00410 ACE_INLINE void
00411 ACE_Message_Block::cont (ACE_Message_Block *cont_msg)
00412 {
00413   ACE_TRACE ("ACE_Message_Block::cont");
00414   this->cont_ = cont_msg;
00415 }
00416 
00417 ACE_INLINE ACE_Message_Block *
00418 ACE_Message_Block::cont (void) const
00419 {
00420   ACE_TRACE ("ACE_Message_Block::cont");
00421   return this->cont_;
00422 }
00423 
00424 ACE_INLINE void
00425 ACE_Message_Block::reset_allocators (ACE_Allocator *allocator_strategy,
00426                                      ACE_Allocator *data_block_allocator,
00427                                      ACE_Allocator *message_block_allocator)
00428 {
00429   this->data_block_->allocator_strategy_ =
00430     allocator_strategy;
00431   this->data_block_->data_block_allocator_ =
00432     data_block_allocator;
00433   this->message_block_allocator_ =
00434     message_block_allocator;
00435 
00436   if (this->cont () != 0)
00437     this->cont ()->reset_allocators (allocator_strategy,
00438                                      data_block_allocator,
00439                                      message_block_allocator);
00440 }
00441 
00442 ACE_INLINE void
00443 ACE_Message_Block::next (ACE_Message_Block *next_msg)
00444 {
00445   ACE_TRACE ("ACE_Message_Block::next");
00446   this->next_ = next_msg;
00447 }
00448 
00449 ACE_INLINE ACE_Message_Block *
00450 ACE_Message_Block::next (void) const
00451 {
00452   ACE_TRACE ("ACE_Message_Block::next");
00453   return this->next_;
00454 }
00455 
00456 ACE_INLINE void
00457 ACE_Message_Block::prev (ACE_Message_Block *next_msg)
00458 {
00459   ACE_TRACE ("ACE_Message_Block::prev");
00460   this->prev_ = next_msg;
00461 }
00462 
00463 ACE_INLINE ACE_Message_Block *
00464 ACE_Message_Block::prev (void) const
00465 {
00466   ACE_TRACE ("ACE_Message_Block::prev");
00467   return this->prev_;
00468 }
00469 
00470 ACE_INLINE ACE_Allocator *
00471 ACE_Data_Block::allocator_strategy (void) const
00472 {
00473   ACE_TRACE ("ACE_Data_Block::allocator_strategy");
00474   return this->allocator_strategy_;
00475 }
00476 
00477 ACE_INLINE ACE_Lock *
00478 ACE_Data_Block::locking_strategy (void)
00479 {
00480   ACE_TRACE ("ACE_Data_Block::locking_strategy");
00481   return this->locking_strategy_;
00482 }
00483 
00484 ACE_INLINE ACE_Lock *
00485 ACE_Data_Block::locking_strategy (ACE_Lock *nls)
00486 {
00487   ACE_TRACE ("ACE_Data_Block::locking_strategy");
00488   ACE_Lock *ols = this->locking_strategy_;
00489 
00490   this->locking_strategy_ = nls;
00491   return ols;
00492 }
00493 
00494 ACE_INLINE ACE_Lock *
00495 ACE_Message_Block::locking_strategy (void)
00496 {
00497   ACE_TRACE ("ACE_Message_Block::locking_strategy");
00498   return this->data_block ()->locking_strategy ();
00499 }
00500 
00501 ACE_INLINE ACE_Lock *
00502 ACE_Message_Block::locking_strategy (ACE_Lock *nls)
00503 {
00504   ACE_TRACE ("ACE_Message_Block::locking_strategy");
00505   ACE_Lock *ols = this->data_block ()->locking_strategy ();
00506   this->data_block ()->locking_strategy (nls);
00507   return ols;
00508 }
00509 
00510 
00511 ////////////////////////////////////////
00512 // class ACE_Dynamic_Message_Strategy //
00513 ////////////////////////////////////////
00514 
00515 ACE_INLINE u_long
00516 ACE_Dynamic_Message_Strategy::static_bit_field_mask (void) const
00517 {
00518   return static_bit_field_mask_;
00519 }
00520   // get static bit field mask
00521 
00522 ACE_INLINE void
00523 ACE_Dynamic_Message_Strategy::static_bit_field_mask (u_long ul)
00524 {
00525   static_bit_field_mask_ = ul;
00526 }
00527   // set static bit field mask
00528 
00529 ACE_INLINE u_long
00530 ACE_Dynamic_Message_Strategy::static_bit_field_shift (void) const
00531 {
00532   return static_bit_field_shift_;
00533 }
00534   // get left shift value to make room for static bit field
00535 
00536 ACE_INLINE void
00537 ACE_Dynamic_Message_Strategy::static_bit_field_shift (u_long ul)
00538 {
00539   static_bit_field_shift_ = ul;
00540 }
00541   // set left shift value to make room for static bit field
00542 
00543 ACE_INLINE u_long
00544 ACE_Dynamic_Message_Strategy::dynamic_priority_max (void) const
00545 {
00546   return dynamic_priority_max_;
00547 }
00548   // get maximum supported priority value
00549 
00550 ACE_INLINE void
00551 ACE_Dynamic_Message_Strategy::dynamic_priority_max (u_long ul)
00552 {
00553   // pending_shift_ depends on dynamic_priority_max_: for performance
00554   // reasons, the value in pending_shift_ is (re)calculated only when
00555   // dynamic_priority_max_ is initialized or changes, and is stored
00556   // as a class member rather than being a derived value.
00557   dynamic_priority_max_ = ul;
00558   pending_shift_ = ACE_Time_Value (0, ul);
00559 }
00560   // set maximum supported priority value
00561 
00562 ACE_INLINE u_long
00563 ACE_Dynamic_Message_Strategy::dynamic_priority_offset (void) const
00564 {
00565   return dynamic_priority_offset_;
00566 }
00567   // get offset for boundary between signed range and unsigned range
00568 
00569 ACE_INLINE void
00570 ACE_Dynamic_Message_Strategy::dynamic_priority_offset (u_long ul)
00571 {
00572   // max_late_ and min_pending_ depend on dynamic_priority_offset_:
00573   // for performance reasons, the values in max_late_ and min_pending_
00574   // are (re)calculated only when dynamic_priority_offset_ is
00575   // initialized or changes, and are stored as a class member rather
00576   // than being derived each time one of their values is needed.
00577   dynamic_priority_offset_ = ul;
00578   max_late_ = ACE_Time_Value (0, ul - 1);
00579   min_pending_ = ACE_Time_Value (0, ul);
00580 }
00581   // set offset for boundary between signed range and unsigned range
00582 
00583 
00584 ACE_INLINE ACE_Dynamic_Message_Strategy::Priority_Status
00585 ACE_Dynamic_Message_Strategy::priority_status (ACE_Message_Block & mb,
00586                                                const ACE_Time_Value & tv)
00587 {
00588   // default the message to have pending priority status
00589   Priority_Status status = ACE_Dynamic_Message_Strategy::PENDING;
00590 
00591   // start with the passed absolute time as the message's priority, then
00592   // call the polymorphic hook method to (at least partially) convert
00593   // the absolute time and message attributes into the message's priority
00594   ACE_Time_Value priority (tv);
00595   convert_priority (priority, mb);
00596 
00597   // if the priority is negative, the message is pending
00598   if (priority < ACE_Time_Value::zero)
00599     {
00600       // priority for pending messages must be shifted
00601       // upward above the late priority range
00602       priority += pending_shift_;
00603       if (priority < min_pending_)
00604         priority = min_pending_;
00605     }
00606   // otherwise, if the priority is greater than the maximum late
00607   // priority value that can be represented, it is beyond late
00608   else if (priority > max_late_)
00609     {
00610       // all messages that are beyond late are assigned lowest priority (zero)
00611       mb.msg_priority (0);
00612       return ACE_Dynamic_Message_Strategy::BEYOND_LATE;
00613     }
00614   // otherwise, the message is late, but its priority is correct
00615   else
00616     status = ACE_Dynamic_Message_Strategy::LATE;
00617 
00618   // use (fast) bitwise operators to isolate and replace
00619   // the dynamic portion of the message's priority
00620   mb.msg_priority((mb.msg_priority() & static_bit_field_mask_) |
00621                   ((priority.usec () + ACE_ONE_SECOND_IN_USECS * priority.sec ()) <<
00622                    static_bit_field_shift_));
00623 
00624   return status;
00625 }
00626   // returns the priority status of the message
00627 
00628 
00629 
00630 /////////////////////////////////////////
00631 // class ACE_Deadline_Message_Strategy //
00632 /////////////////////////////////////////
00633 
00634 ACE_INLINE void
00635 ACE_Deadline_Message_Strategy::convert_priority (ACE_Time_Value & priority,
00636                                                  const ACE_Message_Block & mb)
00637 {
00638   // Convert absolute time passed in tv to negative time
00639   // to deadline of mb with respect to that absolute time.
00640   priority -= mb.msg_deadline_time ();
00641 }
00642   // dynamic priority conversion function based on time to deadline
00643 
00644 
00645 ///////////////////////////////////////
00646 // class ACE_Laxity_Message_Strategy //
00647 ///////////////////////////////////////
00648 
00649 ACE_INLINE void
00650 ACE_Laxity_Message_Strategy::convert_priority (ACE_Time_Value & priority,
00651                                                const ACE_Message_Block & mb)
00652 {
00653   // Convert absolute time passed in tv to negative
00654   // laxity of mb with respect to that absolute time.
00655   priority += mb.msg_execution_time ();
00656   priority -= mb.msg_deadline_time ();
00657 }
00658   // dynamic priority conversion function based on laxity

Generated on Mon Jun 16 11:20:22 2003 for ACE by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002