Amebis/WinStd
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Move vector_queue from WinStd to stdex

Browse Source 
Signed-off-by: Simon Rozman <simon@rozman.si>
This commit is contained in:
Simon Rozman 2022-02-04 13:49:05 +01:00
parent 89a79c330b
commit 2bfb369692
1 changed files with 0 additions and 409 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

409
include/WinStd/Common.h
View File

@ -967,415 +967,6 @@ namespace winstd
/// @} /// @}
/// \addtogroup WinStdGeneral
/// @{
///
/// Helper class to allow limited size FIFO queues implemented as vector of elements
///
template <class T>
class vector_queue
{
public:
///
/// Type to measure element count and indices in
///
typedef size_t size_type;
///
/// Element type
///
typedef T value_type;
///
/// Reference to element type
///
typedef T& reference;
///
/// Constant reference to element type
///
typedef const T& const_reference;
///
/// Pointer to element
///
typedef T* pointer;
///
/// Constant pointer to element
///
typedef const T* const_pointer;
public:
///
/// Construct queue of fixed size.
///
/// \param[in] size_max Maximum number of elements. Please note this cannot be changed later.
///
vector_queue(_In_ size_type size_max) :
m_data(new value_type[size_max]),
m_head(0),
m_count(0),
m_size_max(size_max)
{
}
///
/// Copies existing queue.
///
/// \param[in] other Queue to copy from
///
vector_queue(_In_ const vector_queue<value_type> &other) :
m_data(new value_type[other.m_size_max]),
m_head(other.m_head),
m_count(other.m_count),
m_size_max(other.m_size_max)
{
// Copy elements.
for (size_type i = 0; i < m_count; i++) {
size_type i_l = abs(i);
m_data[i_l] = other.m_data[i_l];
}
}
///
/// Destroys the queue
///
virtual ~vector_queue()
{
if (m_data) delete [] m_data;
}
///
/// Moves existing queue.
///
/// \param[inout] other Queue to move
///
vector_queue(_Inout_ vector_queue<value_type> &&other) :
m_data (std::move(other.m_data )),
m_head (std::move(other.m_head )),
m_count (std::move(other.m_count )),
m_size_max(std::move(other.m_size_max))
{
// Reset other to consistent state.
other.m_data = NULL;
other.m_head = 0;
other.m_count = 0;
other.m_size_max = 0;
}
///
/// Copies existing queue.
///
/// \param[in] other Queue to copy from
///
vector_queue<value_type>& operator=(_In_ const vector_queue<value_type> &other)
{
if (this != std::addressof(other)) {
m_head = other.m_head;
m_count = other.m_count;
m_size_max = other.m_size_max;
// Copy elements.
if (m_data) delete [] m_data;
m_data = new value_type[other.m_size_max];
for (size_type i = 0; i < m_count; i++) {
size_type i_l = abs(i);
m_data[i_l] = other.m_data[i_l];
}
}
return *this;
}
///
/// Moves existing queue.
///
/// \param[inout] other Queue to move
///
vector_queue<value_type>& operator=(_Inout_ vector_queue<value_type> &&other)
{
if (this != std::addressof(other)) {
m_data = std::move(other.m_data );
m_head = std::move(other.m_head );
m_count = std::move(other.m_count );
m_size_max = std::move(other.m_size_max);
// Reset other to consistent state.
other.m_data = NULL;
other.m_head = 0;
other.m_count = 0;
other.m_size_max = 0;
}
return *this;
}
///
/// Returns the number of elements in the vector.
///
size_type size() const
{
return m_count;
}
///
/// Returns the number of elements that the queue can contain before overwriting head ones.
///
size_type capacity() const
{
return m_size_max;
}
///
/// Erases the elements of the queue.
///
void clear()
{
m_count = 0;
}
///
/// Tests if the queue is empty.
///
bool empty() const
{
return m_count == 0;
}
///
/// Returns a reference to the element at a specified location in the queue.
///
/// \param[in] pos The subscript or position number of the element to reference in the queue.
///
reference at(_In_ size_type pos)
{
if (pos >= m_count) throw std::invalid_argument("Invalid subscript");
return m_data[abs(pos)];
}
///
/// Returns a reference to the element at a specified location in the queue.
///
/// \param[in] pos The subscript or position number of the element to reference in the queue.
///
reference operator[](_In_ size_type pos)
{
if (pos >= m_count) throw std::invalid_argument("Invalid subscript");
return m_data[abs(pos)];
}
///
/// Returns a constant reference to the element at a specified location in the queue.
///
/// \param[in] pos The subscript or position number of the element to reference in the queue.
///
const_reference at(_In_ size_type pos) const
{
if (pos >= m_count) throw std::invalid_argument("Invalid subscript");
return m_data[abs(pos)];
}
///
/// Returns a constant reference to the element at a specified location in the queue.
///
/// \param[in] pos The subscript or position number of the element to reference in the queue.
///
const_reference operator[](_In_ size_type pos) const
{
if (pos >= m_count) throw std::invalid_argument("Invalid subscript");
return m_data[abs(pos)];
}
///
/// Returns a reference to the element at the absolute location in the queue.
///
/// \note Absolute means "measured from the beginning of the storage".
///
/// \param[in] pos The absolute subscript or position number of the element to reference in the queue.
///
reference at_abs(_In_ size_type pos)
{
if (pos >= m_size_max) throw std::invalid_argument("Invalid subscript");
return m_data[pos];
}
///
/// Returns a constant reference to the element at the absolute location in the queue: measured from the beginning of the storage.
///
/// \note Absolute means "measured from the beginning of the storage".
///
/// \param[in] pos The absolute subscript or position number of the element to reference in the queue.
///
const_reference at_abs(_In_ size_type pos) const
{
if (pos >= m_size_max) throw std::invalid_argument("Invalid subscript");
return m_data[pos];
}
///
/// Copies an existing element to the end of the queue, overriding the first one when queue is out of space.
///
/// \param[in] v Element to copy to the end of the queue.
///
/// \returns The absolute subscript or position number the element was copied to.
///
size_type push_back(_In_ const value_type &v)
{
if (m_count < m_size_max) {
size_type pos = abs(m_count);
m_data[pos] = v;
m_count++;
return pos;
} else {
size_type pos = m_head;
m_data[pos] = v;
m_head = abs(1);
return pos;
}
}
///
/// Moves the element to the end of the queue, overriding the first one when queue is out of space.
///
/// \param[in] v Element to move to the end of the queue.
///
/// \returns The absolute subscript or position number the element was moved to.
///
size_type push_back(_Inout_ value_type&&v)
{
if (m_count < m_size_max) {
size_type pos = abs(m_count);
m_data[pos] = std::move(v);
m_count++;
return pos;
} else {
size_type pos = m_head;
m_data[pos] = std::move(v);
m_head = abs(1);
return pos;
}
}
///
/// Removes (dequeues) the last element of the queue.
///
void pop_back()
{
if (!m_count) throw std::invalid_argument("Empty storage");
m_count--;
}
///
/// Copies an existing element to the head of the queue, overriding the last one when queue is out of space and moving all others one place right.
///
/// \param[in] v Element to copy to the head of the queue.
///
/// \returns The absolute subscript or position number the element was copied to.
///
size_type push_front(_In_ const value_type &v)
{
m_head = abs(-1);
if (m_count < m_size_max)
m_count++;
m_data[m_head] = v;
return m_head;
}
///
/// Moves the element to the head of the queue, overriding the last one when queue is out of space and moving all others one place right.
///
/// \param[in] v Element to move to the head of the queue.
///
/// \returns The absolute subscript or position number the element was moved to.
///
size_type push_front(_Inout_ value_type&&v)
{
m_head = abs(-1);
if (m_count < m_size_max)
m_count++;
m_data[m_head] = std::move(v);
return m_head;
}
///
/// Removes (dequeues) the head element of the queue.
///
void pop_front()
{
if (!m_count) throw std::invalid_argument("Empty storage");
m_head = abs(1);
m_count--;
}
///
/// Returns a reference to the head element in the queue.
///
reference front()
{
if (!m_count) throw std::invalid_argument("Empty storage");
return m_data[m_head];
}
///
/// Returns a constant reference to the head element in the queue.
///
const_reference front() const
{
if (!m_count) throw std::invalid_argument("Empty storage");
return m_data[m_head];
}
///
/// Returns a reference to the last element in the queue.
///
reference back()
{
return m_data[tail()];
}
///
/// Returns a constant reference to the last element in the queue.
///
const_reference back() const
{
return m_data[tail()];
}
///
/// Returns absolute subscript or position number of the head element in the queue. The element does not need to exist.
///
size_type head() const
{
return m_head;
}
///
/// Returns absolute subscript or position number of the last element in the queue. The element must exist.
///
size_type tail() const
{
if (!m_count) throw std::invalid_argument("Empty storage");
return abs(m_count - 1);
}
///
/// Returns absolute subscript or position number of the given element in the queue.
size_type abs(_In_ size_type pos) const
{
return (m_head + pos) % m_size_max;
}
protected:
value_type *m_data; ///< Underlying data container
size_type m_head; ///< Index of the first element
size_type m_count; ///< Number of elements
size_type m_size_max; ///< Maximum size
};
/// @}
/// ///
/// \defgroup WinStdExceptions Exceptions /// \defgroup WinStdExceptions Exceptions
/// Additional exceptions /// Additional exceptions