dep/ACE_wrappers/ace/Message_Queue_Vx.cpp

   1 // $Id: Message_Queue_Vx.cpp 80826 2008-03-04 14:51:23Z wotte $
   2
   3 #include "ace/Message_Queue_Vx.h"
   4 #include "ace/Log_Msg.h"
   5
   6 #if !defined (__ACE_INLINE__)
   7 #include "ace/Message_Queue_Vx.inl"
   8 #endif /* __ACE_INLINE__ */
   9
  10 ACE_RCSID (ace,
  11            Message_Queue_Vx,
  12            "$Id: Message_Queue_Vx.cpp 80826 2008-03-04 14:51:23Z wotte $")
  13
  14
  15 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  16
  17 #if defined (ACE_VXWORKS)
  18
  19 ////////////////////////////////
  20 // class ACE_Message_Queue_Vx //
  21 ////////////////////////////////
  22
  23 void
  24 ACE_Message_Queue_Vx::dump (void) const
  25 {
  26 #if defined (ACE_HAS_DUMP)
  27   ACE_TRACE ("ACE_Message_Queue_Vx::dump");
  28   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
  29   switch (this->state_)
  30     {
  31     case ACE_Message_Queue_Base::ACTIVATED:
  32       ACE_DEBUG ((LM_DEBUG,
  33                   ACE_TEXT ("state = ACTIVATED\n")));
  34       break;
  35     case ACE_Message_Queue_Base::DEACTIVATED:
  36       ACE_DEBUG ((LM_DEBUG,
  37                   ACE_TEXT ("state = DEACTIVATED\n")));
  38       break;
  39     case ACE_Message_Queue_Base::PULSED:
  40       ACE_DEBUG ((LM_DEBUG,
  41                   ACE_TEXT ("state = PULSED\n")));
  42       break;
  43     }
  44   ACE_DEBUG ((LM_DEBUG,
  45               ACE_TEXT ("low_water_mark = %d\n")
  46               ACE_TEXT ("high_water_mark = %d\n")
  47               ACE_TEXT ("cur_bytes = %d\n")
  48               ACE_TEXT ("cur_length = %d\n")
  49               ACE_TEXT ("cur_count = %d\n")
  50               ACE_TEXT ("head_ = %u\n")
  51               ACE_TEXT ("MSG_Q_ID = %u\n"),
  52               this->low_water_mark_,
  53               this->high_water_mark_,
  54               this->cur_bytes_,
  55               this->cur_length_,
  56               this->cur_count_,
  57               this->head_,
  58               this->tail_));
  59   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
  60 #endif /* ACE_HAS_DUMP */
  61 }
  62
  63 ACE_Message_Queue_Vx::ACE_Message_Queue_Vx (size_t max_messages,
  64                                             size_t max_message_length,
  65                                             ACE_Notification_Strategy *ns)
  66   : ACE_Message_Queue<ACE_NULL_SYNCH> (0, 0, ns),
  67     max_messages_ (static_cast<int> (max_messages)),
  68     max_message_length_ (static_cast<int> (max_message_length))
  69 {
  70   ACE_TRACE ("ACE_Message_Queue_Vx::ACE_Message_Queue_Vx");
  71
  72   if (this->open (max_messages_, max_message_length_, ns) == -1)
  73     ACE_ERROR ((LM_ERROR, ACE_TEXT ("open")));
  74 }
  75
  76 ACE_Message_Queue_Vx::~ACE_Message_Queue_Vx (void)
  77 {
  78   ACE_TRACE ("ACE_Message_Queue_Vx::~ACE_Message_Queue_Vx");
  79
  80   if (this->tail_ != 0  &&  this->close () == -1)
  81     ACE_ERROR ((LM_ERROR, ACE_TEXT ("close")));
  82 }
  83
  84 // Don't bother locking since if someone calls this function more than
  85 // once for the same queue, we're in bigger trouble than just
  86 // concurrency control!
  87
  88 int
  89 ACE_Message_Queue_Vx::open (size_t max_messages,
  90                             size_t max_message_length,
  91                             ACE_Notification_Strategy *ns)
  92 {
  93   ACE_TRACE ("ACE_Message_Queue_Vx::open");
  94   this->high_water_mark_ = 0;
  95   this->low_water_mark_  = 0;
  96   this->cur_bytes_ = 0;
  97   this->cur_length_ = 0;
  98   this->cur_count_ = 0;
  99   this->head_ = 0;
 100   this->notification_strategy_ = ns;
 101   this->max_messages_ = static_cast<int> (max_messages);
 102   this->max_message_length_ = static_cast<int> (max_message_length);
 103
 104   if (tail_)
 105     {
 106       // Had already created a msgQ, so delete it.
 107       close ();
 108       activate_i ();
 109     }
 110
 111   return (this->tail_ =
 112           reinterpret_cast<ACE_Message_Block *> (
 113               ::msgQCreate (max_messages_,
 114                             max_message_length_,
 115                             MSG_Q_FIFO))) == 0 ? -1 : 0;
 116 }
 117
 118 // Clean up the queue if we have not already done so!
 119
 120 int
 121 ACE_Message_Queue_Vx::close (void)
 122 {
 123   ACE_TRACE ("ACE_Message_Queue_Vx::close");
 124   // Don't lock, because we don't have a lock.  It shouldn't be
 125   // necessary, anyways.
 126
 127   this->deactivate_i ();
 128
 129   // Don't bother to free up the remaining message on the list,
 130   // because we don't have any way to iterate over what's in the
 131   // queue.
 132
 133   return ::msgQDelete (msgq ());
 134 }
 135
 136 bool
 137 ACE_Message_Queue_Vx::is_empty_i (void)
 138 {
 139   ACE_TRACE ("ACE_Message_Queue_Vx::is_empty_i");
 140   return ::msgQNumMsgs (msgq ()) == 0;
 141 }
 142
 143 bool
 144 ACE_Message_Queue_Vx::is_full_i (void)
 145 {
 146   ACE_TRACE ("ACE_Message_Queue_Vx::is_full_i");
 147   return ::msgQNumMsgs (msgq ()) >= max_messages_;
 148 }
 149
 150 size_t
 151 ACE_Message_Queue_Vx::high_water_mark (void)
 152 {
 153   ACE_TRACE ("ACE_Message_Queue_Vx::high_water_mark");
 154   ACE_NOTSUP_RETURN ((size_t) -1);
 155 }
 156
 157 void
 158 ACE_Message_Queue_Vx::high_water_mark (size_t)
 159 {
 160   ACE_TRACE ("ACE_Message_Queue_Vx::high_water_mark");
 161   ACE_NOTSUP;
 162 }
 163
 164 size_t
 165 ACE_Message_Queue_Vx::low_water_mark (void)
 166 {
 167   ACE_TRACE ("ACE_Message_Queue_Vx::low_water_mark");
 168   // Don't need to guard, because this is fixed.
 169
 170   ACE_NOTSUP_RETURN ((size_t) -1);
 171 }
 172
 173 void
 174 ACE_Message_Queue_Vx::low_water_mark (size_t)
 175 {
 176   ACE_TRACE ("ACE_Message_Queue_Vx::low_water_mark");
 177   ACE_NOTSUP;
 178 }
 179
 180 size_t
 181 ACE_Message_Queue_Vx::message_bytes (void)
 182 {
 183   ACE_TRACE ("ACE_Message_Queue_Vx::message_bytes");
 184   ACE_NOTSUP_RETURN ((size_t) -1);
 185 }
 186
 187 size_t
 188 ACE_Message_Queue_Vx::message_length (void)
 189 {
 190   ACE_TRACE ("ACE_Message_Queue_Vx::message_length");
 191   ACE_NOTSUP_RETURN ((size_t) -1);
 192 }
 193
 194 size_t
 195 ACE_Message_Queue_Vx::message_count (void)
 196 {
 197   ACE_TRACE ("ACE_Message_Queue_Vx::message_count");
 198   // Don't need to guard, because this is a system call.
 199
 200   return ::msgQNumMsgs (msgq ());
 201 }
 202
 203 void
 204 ACE_Message_Queue_Vx::message_bytes (size_t)
 205 {
 206   ACE_TRACE ("ACE_Message_Queue_Vx::message_bytes");
 207   ACE_NOTSUP;
 208 }
 209
 210 void
 211 ACE_Message_Queue_Vx::message_length (size_t)
 212 {
 213   ACE_TRACE ("ACE_Message_Queue_Vx::message_length");
 214   ACE_NOTSUP;
 215 }
 216
 217 int
 218 ACE_Message_Queue_Vx::signal_enqueue_waiters (void)
 219 {
 220   // No-op.
 221   return 0;
 222 }
 223
 224 int
 225 ACE_Message_Queue_Vx::signal_dequeue_waiters (void)
 226 {
 227   // No-op.
 228   return 0;
 229 }
 230
 231 int
 232 ACE_Message_Queue_Vx::enqueue_tail_i (ACE_Message_Block *new_item)
 233 {
 234   ACE_TRACE ("ACE_Message_Queue_Vx::enqueue_tail_i");
 235
 236   if (new_item == 0)
 237     return -1;
 238
 239   // Don't try to send a composite message!!!!  Only the first
 240   // block will be sent.
 241
 242   ++this->cur_count_;
 243
 244   // Always use this method to actually send a message on the queue.
 245   if (::msgQSend (msgq (),
 246                   new_item->rd_ptr (),
 247                   new_item->size (),
 248                   WAIT_FOREVER,
 249                   MSG_PRI_NORMAL) == OK)
 250     return ::msgQNumMsgs (msgq ());
 251   else
 252     return -1;
 253 }
 254
 255 int
 256 ACE_Message_Queue_Vx::enqueue_head_i (ACE_Message_Block *new_item)
 257 {
 258   ACE_TRACE ("ACE_Message_Queue_Vx::enqueue_head_i");
 259
 260   // Just delegate to enqueue_tail_i.
 261   return enqueue_tail_i (new_item);
 262 }
 263
 264 int
 265 ACE_Message_Queue_Vx::enqueue_i (ACE_Message_Block *new_item)
 266 {
 267   ACE_TRACE ("ACE_Message_Queue_Vx::enqueue_i");
 268
 269   if (new_item == 0)
 270     return -1;
 271
 272   if (this->head_ == 0)
 273     // Should always take this branch.
 274     return this->enqueue_head_i (new_item);
 275   else
 276     ACE_NOTSUP_RETURN (-1);
 277 }
 278
 279 int
 280 ACE_Message_Queue_Vx::enqueue_deadline_i (ACE_Message_Block *new_item)
 281 {
 282   ACE_TRACE ("ACE_Message_Queue_Vx::enqueue_deadline_i");
 283
 284   // Just delegate to enqueue_tail_i.
 285   return enqueue_tail_i (new_item);
 286 }
 287
 288 // Actually get the first ACE_Message_Block (no locking, so must be
 289 // called with locks held).  This method assumes that the queue has at
 290 // least one item in it when it is called.
 291
 292 int
 293 ACE_Message_Queue_Vx::dequeue_head_i (ACE_Message_Block *&first_item)
 294 {
 295   ACE_TRACE ("ACE_Message_Queue_Vx::dequeue_head_i");
 296
 297   // We don't allocate a new Message_Block:  the caller must provide
 298   // it, and must ensure that it is big enough (without chaining).
 299
 300   if (first_item == 0  ||  first_item->wr_ptr () == 0)
 301     return -1;
 302
 303   if (::msgQReceive (msgq (),
 304                      first_item->wr_ptr (),
 305                      first_item->size (),
 306                      WAIT_FOREVER) == ERROR)
 307     return -1;
 308   else
 309     return ::msgQNumMsgs (msgq ());
 310 }
 311
 312 int
 313 ACE_Message_Queue_Vx::dequeue_prio_i (ACE_Message_Block *& /*dequeued*/)
 314 {
 315   ACE_TRACE ("ACE_Message_Queue_Vx::dequeue_prio_i");
 316   ACE_NOTSUP_RETURN (-1);
 317 }
 318
 319 int
 320 ACE_Message_Queue_Vx::dequeue_tail_i (ACE_Message_Block *& /*dequeued*/)
 321 {
 322   ACE_TRACE ("ACE_Message_Queue_Vx::dequeue_tail_i");
 323   ACE_NOTSUP_RETURN (-1);
 324 }
 325
 326 int
 327 ACE_Message_Queue_Vx::dequeue_deadline_i (ACE_Message_Block *& /*dequeued*/)
 328 {
 329   ACE_TRACE ("ACE_Message_Queue_Vx::dequeue_deadline_i");
 330   ACE_NOTSUP_RETURN (-1);
 331 }
 332
 333 // Take a look at the first item without removing it.
 334
 335 int
 336 ACE_Message_Queue_Vx::wait_not_full_cond (ACE_Guard<ACE_Null_Mutex> &mon,
 337                                           ACE_Time_Value *tv)
 338 {
 339   // Always return here, and let the VxWorks message queue handle blocking.
 340   ACE_UNUSED_ARG (mon);
 341   ACE_UNUSED_ARG (tv);
 342
 343   return 0;
 344 }
 345
 346 int
 347 ACE_Message_Queue_Vx::wait_not_empty_cond (ACE_Guard<ACE_Null_Mutex> &mon,
 348                                            ACE_Time_Value *tv)
 349 {
 350   // Always return here, and let the VxWorks message queue handle blocking.
 351   ACE_UNUSED_ARG (mon);
 352   ACE_UNUSED_ARG (tv);
 353
 354   return 0;
 355 }
 356
 357 #if ! defined (ACE_NEEDS_FUNC_DEFINITIONS)
 358 int
 359 ACE_Message_Queue_Vx::peek_dequeue_head (ACE_Message_Block *&,
 360                                          ACE_Time_Value *)
 361 {
 362   ACE_NOTSUP_RETURN (-1);
 363 }
 364 #endif /* ! ACE_NEEDS_FUNC_DEFINITIONS */
 365
 366 #endif /* ACE_VXWORKS */
 367
 368 ACE_END_VERSIONED_NAMESPACE_DECL