src/shared/LockedQueue.h

   1 /*
   2  * Copyright (C) 2009 MaNGOS <http://getmangos.com/>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #ifndef LOCKEDQUEUE_H
  20 #define LOCKEDQUEUE_H
  21
  22 #include <ace/Guard_T.h>
  23 #include <ace/Thread_Mutex.h>
  24 #include <deque>
  25 #include <assert.h>
  26 #include "Errors.h"
  27
  28 namespace ACE_Based
  29 {
  30
  31     template <class T, class LockType, typename StorageType=std::deque<T> >
  32         class LockedQueue
  33     {
  34
  35         //! Serialize access to the Queue
  36         LockType _lock;
  37
  38         //! Storage backing the queue
  39         StorageType _queue;
  40
  41         //! Cancellation flag
  42         volatile bool _canceled;
  43
  44         public:
  45
  46             //! Create a LockedQueue
  47             LockedQueue() : _canceled(false) {}
  48
  49             //! Destroy a LockedQueue
  50             virtual ~LockedQueue() { }
  51
  52             /**
  53              * @see Queue::add(const T& item)
  54              */
  55             void add(const T& item)
  56             {
  57
  58                 ACE_Guard<LockType> g(_lock);
  59
  60                 ASSERT(!_canceled);
  61                 //      throw Cancellation_Exception();
  62
  63                 _queue.push_back(item);
  64
  65             }
  66
  67             /**
  68              * @see Queue::next()
  69              */
  70             T next()
  71             {
  72
  73                 ACE_Guard<LockType> g(_lock);
  74
  75                 ASSERT (!_queue.empty() || !_canceled);
  76                 //      throw Cancellation_Exception();
  77
  78                 T item = _queue.front();
  79                 _queue.pop_front();
  80
  81                 return item;
  82
  83             }
  84
  85             T front()
  86             {
  87                 ACE_Guard<LockType> g(_lock);
  88
  89                 ASSERT (!_queue.empty());
  90                 //      throw NoSuchElement_Exception();
  91
  92                 return _queue.front();
  93             }
  94
  95             /**
  96              * @see Queue::cancel()
  97              */
  98             void cancel()
  99             {
 100
 101                 ACE_Guard<LockType> g(_lock);
 102
 103                 _canceled = true;
 104
 105             }
 106
 107             /**
 108              * @see Queue::isCanceled()
 109              */
 110             bool isCanceled()
 111             {
 112
 113                 // Faster check since the queue will not become un-canceled
 114                 if(_canceled)
 115                     return true;
 116
 117                 ACE_Guard<LockType> g(_lock);
 118
 119                 return _canceled;
 120
 121             }
 122
 123             /**
 124              * @see Queue::size()
 125              */
 126             size_t size()
 127             {
 128
 129                 ACE_Guard<LockType> g(_lock);
 130                 return _queue.size();
 131
 132             }
 133
 134             bool empty()
 135             {
 136
 137                 ACE_Guard<LockType> g(_lock);
 138                 return _queue.empty();
 139             }
 140
 141     };
 142
 143 }
 144 #endif