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