LQueue.h

Go to the documentation of this file.

/* -*- C++ -*- */
#ifndef _MADARA_LQUEUE_H
#define _MADARA_LQUEUE_H
 
// This header defines "size_t"
#include <stdlib.h>
 
#include <stdexcept>
 
namespace madara
{
namespace utility
{
// Solve circular include problem via forward decls.
template<typename T>
class LQueueNode;
 
template<typename T>
class LQueueIterator;
 
template<typename T>
class LQueueConstIterator;
 
template<class T>
class LQueue
{
  friend class LQueueIterator<T>;
  friend class LQueueConstIterator<T>;
 
public:
  // Define a "trait"
  typedef T value_type;
 
  class Underflow
  {
  };
 
  class Overflow
  {
  };
 
  LQueue(size_t size_hint = 0);
 
  LQueue(const LQueue<T>& rhs);
 
  LQueue<T>& operator=(const LQueue<T>& rhs);
 
  ~LQueue(void);
 
  void enqueue(const T& new_item);
 
  T dequeue(void);
 
  T front(void) const;
 
  bool is_empty(void) const;
 
  bool is_full(void) const;
 
  size_t size(void) const;
 
  bool operator==(const LQueue<T>& rhs) const;
 
  bool operator!=(const LQueue<T>& s) const;
 
  typedef LQueueIterator<T> iterator;
  typedef LQueueConstIterator<T> const_iterator;
 
  iterator begin(void);
 
  const_iterator begin(void) const;
 
  iterator end(void);
 
  const_iterator end(void) const;
 
protected:
  void dequeue_i(void);
 
  // Copy a linked list of nodes.  This can throw a @a ::std::bad_alloc
  // exception.
  void copy_list(const LQueue<T>& rhs);
 
  // Delete a linked list of nodes.
  void delete_list(void);
 
private:
  LQueueNode<T>* tail_;
 
  size_t count_;
};
 
template<typename T>
class LQueueIterator
{
public:
  LQueueIterator(LQueue<T>& queue, size_t pos = 0);
 
  LQueueIterator(LQueue<T>& queue, LQueueNode<T>* pos = 0);
 
  T& operator*(void);
 
  const T& operator*(void)const;
 
  LQueueIterator<T>& operator++(void);
 
  LQueueIterator<T> operator++(int);
 
  bool operator==(const LQueueIterator<T>& rhs) const;
 
  bool operator!=(const LQueueIterator<T>& lhs) const;
 
  // = Necessary traits
  typedef ::std::forward_iterator_tag iterator_category;
  typedef T value_type;
  typedef T* pointer;
  typedef T& reference;
  typedef int difference_type;
 
private:
  LQueue<T>& queue_;
 
  // the position in the linked list
  mutable LQueueNode<T>* pos_;
};
 
template<typename T>
class LQueueConstIterator
{
public:
  LQueueConstIterator(const LQueue<T>& queue, size_t pos = 0);
 
  LQueueConstIterator(const LQueue<T>& queue, LQueueNode<T>* pos);
 
  const T& operator*(void)const;
 
  const LQueueConstIterator<T>& operator++(void)const;
 
  LQueueConstIterator<T> operator++(int)const;
 
  bool operator==(const LQueueConstIterator<T>& rhs) const;
 
  bool operator!=(const LQueueConstIterator<T>& lhs) const;
 
  // = Necessary traits
  typedef ::std::forward_iterator_tag iterator_category;
  typedef T value_type;
  typedef T* pointer;
  typedef T& reference;
  typedef int difference_type;
 
private:
  const LQueue<T>& queue_;
 
  // the position in the linked list
  mutable LQueueNode<T>* pos_;
};
}
}
 
#include "LQueue.cpp"
#endif /* _MADARA_LQUEUE_H */