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 */