dep/ACE_wrappers/ace/Notification_Queue.cpp

   1 // $Id: Notification_Queue.cpp 81315 2008-04-10 07:14:15Z johnnyw $
   2
   3 #include "ace/Notification_Queue.h"
   4
   5 #if !defined (__ACE_INLINE__)
   6 #include "ace/Notification_Queue.inl"
   7 #endif /* __ACE_INLINE__ */
   8
   9 #include "ace/Guard_T.h"
  10
  11 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  12
  13 ACE_Notification_Queue::
  14 ACE_Notification_Queue()
  15   : ACE_Copy_Disabled()
  16   , alloc_queue_()
  17   , notify_queue_()
  18   , free_queue_()
  19 {
  20 }
  21
  22 ACE_Notification_Queue::
  23 ~ACE_Notification_Queue()
  24 {
  25   reset();
  26 }
  27
  28 int
  29 ACE_Notification_Queue::
  30 open()
  31 {
  32   ACE_TRACE ("ACE_Notification_Queue::open");
  33
  34   ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, mon, this->notify_queue_lock_, -1);
  35
  36   if (!this->free_queue_.is_empty ())
  37     return 0;
  38
  39   return allocate_more_buffers();
  40 }
  41
  42 void
  43 ACE_Notification_Queue::
  44 reset()
  45 {
  46   ACE_TRACE ("ACE_Notification_Queue::reset");
  47
  48   // Release all the event handlers still in the queue ...
  49   for (ACE_Notification_Queue_Node * node = notify_queue_.head();
  50        node != 0;
  51        node = node->next())
  52     {
  53       if (node->get().eh_ == 0)
  54         {
  55           continue;
  56         }
  57       (void) node->get().eh_->remove_reference();
  58     }
  59
  60   // ... free up the dynamically allocated resources ...
  61   ACE_Notification_Queue_Node **b = 0;
  62   for (ACE_Unbounded_Queue_Iterator<ACE_Notification_Queue_Node *> alloc_iter (this->alloc_queue_);
  63        alloc_iter.next (b) != 0;
  64        alloc_iter.advance ())
  65     {
  66       delete [] *b;
  67       *b = 0;
  68     }
  69
  70   // ... cleanup the list of allocated blocks ...
  71   this->alloc_queue_.reset ();
  72
  73   // ... swap with empty lists to reset the contents ...
  74   Buffer_List().swap(notify_queue_);
  75   Buffer_List().swap(free_queue_);
  76 }
  77
  78 int ACE_Notification_Queue::
  79 allocate_more_buffers()
  80 {
  81   ACE_TRACE ("ACE_Notification_Queue::allocate_more_buffers");
  82
  83   ACE_Notification_Queue_Node *temp = 0;
  84
  85   ACE_NEW_RETURN (temp,
  86                   ACE_Notification_Queue_Node[ACE_REACTOR_NOTIFICATION_ARRAY_SIZE],
  87                   -1);
  88
  89   if (this->alloc_queue_.enqueue_head (temp) == -1)
  90     {
  91       delete [] temp;
  92       return -1;
  93     }
  94
  95   for (size_t i = 0; i < ACE_REACTOR_NOTIFICATION_ARRAY_SIZE; ++i)
  96     {
  97       free_queue_.push_front(temp + i);
  98     }
  99
 100   return 0;
 101 }
 102
 103 int
 104 ACE_Notification_Queue::
 105 purge_pending_notifications(ACE_Event_Handler * eh,
 106                             ACE_Reactor_Mask mask)
 107 {
 108   ACE_TRACE ("ACE_Notification_Queue::purge_pending_notifications");
 109
 110   ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, mon, this->notify_queue_lock_, -1);
 111
 112   if (this->notify_queue_.is_empty ())
 113     return 0;
 114
 115   int number_purged = 0;
 116   ACE_Notification_Queue_Node * node = notify_queue_.head();
 117   while(node != 0)
 118     {
 119       if (!node->matches_for_purging(eh))
 120         {
 121           // Easy case, skip to the next node
 122           node = node->next();
 123           continue;
 124         }
 125
 126       if (!node->mask_disables_all_notifications(mask))
 127         {
 128           // ... another easy case, skip this node too, but clear the
 129           // mask first ...
 130           node->clear_mask(mask);
 131           node = node->next();
 132           continue;
 133         }
 134
 135       // ... this is the more complicated case, we want to remove the
 136       // node from the notify_queue_ list.  First save the next node
 137       // on the list:
 138       ACE_Notification_Queue_Node * next = node->next();
 139
 140       // ... then remove it ...
 141       notify_queue_.unsafe_remove(node);
 142       ++number_purged;
 143
 144       // ... release resources ...
 145       ACE_Event_Handler *event_handler = node->get().eh_;
 146       event_handler->remove_reference ();
 147
 148       // ... now this is a free node ...
 149       free_queue_.push_front(node);
 150
 151       // ... go to the next node, if there is one ...
 152       node = next;
 153     }
 154
 155   return number_purged;
 156 }
 157
 158 int ACE_Notification_Queue::
 159 push_new_notification(
 160   ACE_Notification_Buffer const & buffer)
 161 {
 162   ACE_TRACE ("ACE_Notification_Queue::push_new_notification");
 163
 164   bool notification_required = false;
 165
 166   ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, mon, this->notify_queue_lock_, -1);
 167
 168   // No pending notifications.
 169   if (this->notify_queue_.is_empty ())
 170     notification_required = true;
 171
 172   if (free_queue_.is_empty())
 173     {
 174       if (allocate_more_buffers() == -1)
 175         {
 176           return -1;
 177         }
 178     }
 179
 180   ACE_Notification_Queue_Node * node =
 181     free_queue_.pop_front();
 182
 183   ACE_ASSERT (node != 0);
 184   node->set(buffer);
 185
 186   notify_queue_.push_back(node);
 187
 188   if (!notification_required)
 189     {
 190       return 0;
 191     }
 192
 193   return 1;
 194 }
 195
 196 int
 197 ACE_Notification_Queue::pop_next_notification(
 198   ACE_Notification_Buffer & current,
 199   bool & more_messages_queued,
 200   ACE_Notification_Buffer & next)
 201 {
 202   ACE_TRACE ("ACE_Notification_Queue::pop_next_notification");
 203
 204   more_messages_queued = false;
 205
 206   ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, mon, this->notify_queue_lock_, -1);
 207
 208   if (notify_queue_.is_empty ())
 209     {
 210       return 0;
 211     }
 212
 213   ACE_Notification_Queue_Node * node =
 214     notify_queue_.pop_front();
 215
 216   current = node->get();
 217   free_queue_.push_front(node);
 218
 219   if(!this->notify_queue_.is_empty())
 220     {
 221       more_messages_queued = true;
 222       next = notify_queue_.head()->get();
 223     }
 224
 225   return 1;
 226 }
 227
 228 ACE_END_VERSIONED_NAMESPACE_DECL