/usr/include/cxxtools/queue.h is in libcxxtools-dev 2.2.1-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 | /*
* Copyright (C) 2010 Tommi Maekitalo
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* As a special exception, you may use this file as part of a free
* software library without restriction. Specifically, if other files
* instantiate templates or use macros or inline functions from this
* file, or you compile this file and link it with other files to
* produce an executable, this file does not by itself cause the
* resulting executable to be covered by the GNU General Public
* License. This exception does not however invalidate any other
* reasons why the executable file might be covered by the GNU Library
* General Public License.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef CXXTOOLS_QUEUE_H
#define CXXTOOLS_QUEUE_H
#include <queue>
#include <cxxtools/mutex.h>
#include <cxxtools/condition.h>
namespace cxxtools
{
/** @brief This class implements a thread safe queue.
A queue is a container where the elements put into the queue are
fetched in the same order (first-in-first-out, fifo).
The class has a optional maximum size. If the size is set to 0 the
queue has no limit. Otherwise putting a element to the queue may
block until another thread fetches a element or increases the limit.
*/
template <typename T>
class Queue
{
public:
typedef T value_type;
typedef typename std::deque<T>::size_type size_type;
typedef typename std::deque<T>::const_reference const_reference;
private:
mutable Mutex _mutex;
Condition _notEmpty;
Condition _notFull;
std::deque<value_type> _queue;
size_type _maxSize;
size_type _numWaiting;
public:
/// @brief Default Constructor.
Queue()
: _maxSize(0),
_numWaiting(0)
{ }
/** @brief Returns the next element.
This method returns the next element. If the queue is empty,
the thread will be locked until a element is available.
*/
value_type get();
/** @brief Returns the next element if the queue is not empty.
If the queue is empty, a default constructed value_type is returned.
The returned flag is set to false, if the queue was empty.
*/
std::pair<value_type, bool> tryGet();
/** @brief Adds a element to the queue.
This method adds a element to the queue. If the queue has
reached his maximum size, the method blocks until there is
space available.
*/
void put(const_reference element, bool force = false);
/// @brief Returns true, if the queue is empty.
bool empty() const
{
MutexLock lock(_mutex);
return _queue.empty();
}
/// @brief Returns the number of elements currently in queue.
size_type size() const
{
MutexLock lock(_mutex);
return _queue.size();
}
/** @brief sets the maximum size of the queue.
Setting the maximum size of the queue may wake up another
thread, if it is waiting for space to get available and the
limit is increased.
*/
void maxSize(size_type m);
/// @brief returns the maximum size of the queue.
size_type maxSize() const
{
MutexLock lock(_mutex);
return _maxSize;
}
/// @brief returns the number of threads blocked in the get method.
size_type numWaiting() const
{
MutexLock lock(_mutex);
return _numWaiting;
}
};
template <typename T>
typename Queue<T>::value_type Queue<T>::get()
{
MutexLock lock(_mutex);
++_numWaiting;
while (_queue.empty())
_notEmpty.wait(lock);
--_numWaiting;
value_type element = _queue.front();
_queue.pop_front();
if (!_queue.empty())
_notEmpty.signal();
_notFull.signal();
return element;
}
template <typename T>
std::pair<typename Queue<T>::value_type, bool> Queue<T>::tryGet()
{
typedef typename Queue<T>::value_type value_type;
typedef typename std::pair<value_type, bool> return_type;
MutexLock lock(_mutex);
if (_queue.empty())
return return_type(value_type(), false);
value_type element = _queue.front();
_queue.pop_front();
if (!_queue.empty())
_notEmpty.signal();
_notFull.signal();
return return_type(element, true);
}
template <typename T>
void Queue<T>::put(typename Queue<T>::const_reference element, bool force)
{
MutexLock lock(_mutex);
if (!force)
while (_maxSize > 0 && _queue.size() >= _maxSize)
_notFull.wait(lock);
_queue.push_back(element);
_notEmpty.signal();
if (_maxSize > 0 && _queue.size() < _maxSize)
_notFull.signal();
}
template <typename T>
void Queue<T>::maxSize(size_type m)
{
_maxSize = m;
MutexLock lock(_mutex);
if (_queue.size() < _maxSize)
_notFull.signal();
}
}
#endif // CXXTOOLS_QUEUE_H
|