LStack.h

Go to the documentation of this file.

/* -*- C++ -*- */
#ifndef _MADARA_LSTACK_H_
#define _MADARA_LSTACK_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 LStackNode;

    template <typename T>
    class LStackIterator;

    template <typename T>
    class LStackConstIterator;

    template <class T> 
    class LStack
    {
      friend class LStackIterator<T>;
      friend class LStackConstIterator<T>;
    public:
      // Define a "trait"
      typedef T value_type;

      class Underflow {};

      class Overflow {};

      LStack (size_t size_hint = 0);

      LStack (const LStack<T> &rhs);

      LStack<T> &operator = (const LStack<T> &rhs);

      ~LStack (void);

      void push (const T &new_item);

      T pop (void);

      T top (void) const;

      bool is_empty (void) const;

      bool is_full (void) const;

      size_t size (void) const;

      bool operator== (const LStack<T> &rhs) const;

      // Compare this stack with @a rhs for inequality such that @a
      // *this!=s is always the complement of the boolean return value of
      // @a *this==s.
      bool operator!= (const LStack<T> &s) const;

      void erase (void);

      typedef LStackIterator<T> iterator;
      typedef LStackConstIterator<T> const_iterator;

      iterator begin (void);

      const_iterator begin (void) const;

      iterator end (void);

      const_iterator end (void) const;

    protected:
      void pop_i (void);

      void copy_list (const LStack<T> &rhs);

      void delete_list (void);

    private:
      LStackNode<T> *head_;

      size_t count_;
    };

    template <typename T>
    class LStackIterator 
    {
    public:
      LStackIterator (LStack<T> &stack,
        size_t pos = 0);

      LStackIterator (LStack<T> &stack,
        LStackNode<T> *pos = 0);

      T& operator* (void);

      const T& operator* (void) const;

      LStackIterator<T> &operator++ (void);

      LStackIterator<T> operator++ (int);

      bool operator== (const LStackIterator<T> &rhs) const;

      bool operator!= (const LStackIterator<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:
      LStack<T> &stack_;

      // the position in the linked list
      mutable LStackNode<T> *pos_;
    };

    template <typename T>
    class LStackConstIterator 
    {
    public:
      LStackConstIterator (const LStack<T> &stack,
        size_t pos = 0);

      LStackConstIterator (const LStack<T> &stack,
        LStackNode<T> *pos);

      const T& operator* (void) const;

      const LStackConstIterator<T> &operator++ (void) const;

      LStackConstIterator<T> operator++ (int) const;

      bool operator== (const LStackConstIterator<T> &rhs) const;

      bool operator!= (const LStackConstIterator<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 LStack<T> &stack_;

      // the position in the linked list
      mutable LStackNode<T> *pos_;
    };
  }
}

#include "LStack.cpp"

#endif /* _MADARA_LSTACK_H_ */