simple-queue.hpp

Go to the documentation of this file.

#ifndef NDNPH_CORE_SIMPLE_QUEUE_HPP
#define NDNPH_CORE_SIMPLE_QUEUE_HPP
 
#include "common.hpp"
 
namespace ndnph {
 
template<typename T>
class SimpleQueue {
public:
  static_assert(std::is_default_constructible<T>::value, "");
  static_assert(std::is_move_assignable<T>::value, "");
  static_assert(std::is_move_constructible<T>::value, "");
  using Item = T;
 
  bool push(Item item) {
    size_t newTail = nextIndex(m_tail);
    if (newTail == m_head) {
      return false;
    }
 
    m_arr[m_tail] = std::move(item);
    m_tail = newTail;
    return true;
  }
  bool push(Item item) {…}
 
  std::tuple<Item, bool> pop() {
    if (m_head == m_tail) {
      return std::make_tuple(T(), false);
    }
    Item item = std::move(m_arr[m_head]);
    m_arr[m_head] = T();
    m_head = nextIndex(m_head);
    return std::make_tuple(std::move(item), true);
  }
  std::tuple<Item, bool> pop() {…}
 
  size_t capacity() const {
    return m_cap1 - 1;
  }
  size_t capacity() const  {…}
 
  size_t size() const {
    return (m_tail - m_head + m_cap1) % m_cap1;
  }
  size_t size() const  {…}
 
  size_t available() const {
    return capacity() - size();
  }
  size_t available() const  {…}
 
protected:
  explicit SimpleQueue(Item* arr, size_t cap)
    : m_arr(arr)
    , m_cap1(cap + 1) {}
  explicit SimpleQueue(Item* arr, size_t cap) {…}
 
  Item* getArray() {
    return m_arr;
  }
  Item* getArray() {…}
 
private:
  size_t nextIndex(size_t i) const {
    return (i + 1) % m_cap1;
  }
 
private:
  Item* m_arr;
  size_t m_cap1 = 0;
  size_t m_head = 0;
  size_t m_tail = 0;
};
class SimpleQueue {…};
 
template<typename T, size_t C>
class StaticSimpleQueue : public SimpleQueue<T> {
public:
  explicit StaticSimpleQueue()
    : SimpleQueue<T>(m_array, C) {}
  explicit StaticSimpleQueue() {…}
 
private:
  T m_array[C + 1];
};
class StaticSimpleQueue : public SimpleQueue<T> {…};
 
template<typename T>
class DynamicSimpleQueue : public SimpleQueue<T> {
public:
  explicit DynamicSimpleQueue(size_t capacity)
    : SimpleQueue<T>(new T[capacity + 1], capacity) {}
  explicit DynamicSimpleQueue(size_t capacity) {…}
 
  ~DynamicSimpleQueue() {
    delete[] this->getArray();
  }
  ~DynamicSimpleQueue() {…}
};
class DynamicSimpleQueue : public SimpleQueue<T> {…};
 
} // namespace ndnph
 
#endif // NDNPH_CORE_SIMPLE_QUEUE_HPP