tpl_arrayStack.H

# ifndef TPL_ARRAYSTACK_H
# define TPL_ARRAYSTACK_H

# include <iostream>
# include <aleph.H>
# include <tpl_memArray.H>

using namespace std;

using namespace Aleph;

namespace Aleph {

    template <typename T> 
class ArrayStack
{
  MemArray<T> array;

public:

  ArrayStack(size_t dim = 8) : array(dim) { /* empty */ }

  ArrayStack(const ArrayStack & s) : array(s.array) { /* empty */ }

  ArrayStack(ArrayStack && s) : array(std::move(s.array)) { /* empty */ }

  ArrayStack & operator = (const ArrayStack & s)
  {
    if (this == &s)
      return *this;

    array = s.array;

    return *this;
  }

  void swap(ArrayStack & s)
  {
    std::swap(*this, s);
  }

  ArrayStack & operator = (ArrayStack && s)
  {
    array.swap(s.array);
    return *this;
  }

  T & push(const T & data) throw(std::exception, std::overflow_error)
  {
    return array.put(data);
  }

  T & push(T && data) throw(std::exception, std::overflow_error)
  {
    return array.put(std::move(data));
  }

  T & pushn(const size_t & n = 1) throw(std::exception, std::overflow_error)
  {
    array.putn(n);
    return array.last();
  }

  T pop() throw(std::exception, std::underflow_error)
  {
    return array.get(1);
  }

  T popn(const int & n) throw(std::exception, std::underflow_error)
  {
    return array.get(n);
  }

  T & top() throw(std::exception,std::underflow_error)
  {
    return array.last();
  }

  T & base() 
  {
    return array.first();
  }

  const T & top() const throw(std::exception,std::underflow_error)
  {
    return array.last();
  }

  T & top(const int & i) throw(std::exception, std::underflow_error)
  {
    return array.access(array.size() - i - 1);
  }

  const T & top(const int & i) const throw(std::exception, std::underflow_error)
  {
    return array.access(array.size() - i - 1);
  }

  void empty() { array.empty(); }

  bool is_empty() const { return array.size() == 0; }

  const size_t & size() const { return array.size(); }

  const size_t & capacity() const { return array.capacity(); }

  template <class Operation>
  bool traverse(Operation & operation)
  {
    return array.traverse(operation);
  }

  template <class Operation>
  bool traverse(Operation & operation) const
  {
    return array.traverse(operation);
  }

  template <class Operation>
  bool traverse(Operation && operation = Operation()) const
  {
    return array.traverse(operation);
  }

  template <class Operation>
  bool traverse(Operation && operation = Operation())
  {
    return array.traverse(operation);
  }

  Functional_Methods(T);

  Generic_Items(T);
};

    template <typename T> 
class FixedStack
{
  T *    array = NULL; 
  size_t head;
  size_t dim;

public:

  FixedStack(size_t d = 512) 
    : array(new T [d]), head(0), dim(d) { /* empty */ }

  ~FixedStack()
  {
    if (array)
      delete [] array;
  }

  FixedStack(const FixedStack & s) 
    : array(new T [s.dim]), head(s.head), dim(s.dim)
  {
    for (int i = 0; i < head; ++i)
      array[i] = s.array[i];
  }

  void swap(FixedStack & s)
  {
    std::swap(array, s.array);
    std::swap(head, s.head);
    std::swap(dim, s.dim);
  }

  FixedStack(FixedStack && s) 
    : array(NULL), head(0), dim(0)
  {
    swap(s);
  }

  FixedStack & operator = (const FixedStack & s)
  {
    if (this == &s)
      return *this;

    T * ptr = new T [s.dim];
    if (array)
      delete [] array;
    array = ptr;
    for (size_t i = 0; i < s.head; ++i)
      array[i] = s.array[i];
    head  = s.head;
    dim   = s.dim;

    return *this;
  }

  FixedStack & operator = (FixedStack && s)
  {
    swap(s);
    return *this;
  }

  T & push(const T & data) 
  {
    I(head < dim );

    array[head++] = data;
    return array[head - 1];
  }

  T & push(T && data) 
  {
    I(head < dim );

    std::swap(array[head++], data);
    return array[head - 1];
  }

  T & pushn(const size_t & n = 1) 
  {
    I(head + n <= dim);

    head += n;
    return array[head - 1];
  }

  T pop() 
  {
    I(head > 0);

    return std::move(array[--head]);
  }

  T popn(const int & n) 
  {
    I((int (head - n)) >= 0);

    head -= n;
    return std::move(array[head]);
  }

  T & top() 
  {
    I(head > 0);

    return array[head - 1]; 
  }

  T & top() const 
  {
    I(head > 0);

    return array[head - 1]; 
  }

  T & base() { return array[0]; }

  T & top(const int & i) 

  {
    I(i < head);

    return array[head - i - 1];   
  }

  bool is_empty() const { return head == 0; }

  void empty() { head = 0; }

  const size_t & size() const { return head; }

  template <class Operation>
  bool traverse(Operation & operation)
  {
    for (int i = 0; i < head; i++)
      if (not operation(array[i]))
        return false;

    return true;
  }

  template <class Operation>
  bool traverse(Operation & operation) const
  {
    return const_cast<FixedStack*>(this)->traverse(operation);
  }

  template <class Operation>
  bool traverse(Operation && operation = Operation()) const
  {
    return traverse<Operation>(operation);
  }

  template <class Operation>
  bool traverse(Operation && operation = Operation())
  {
    return traverse<Operation>(operation);
  }

  Functional_Methods(T);

  Generic_Items(T);
};

} // end namespace Aleph

# endif /* TPL_ARRAYSTACK_H */