tpl_dynListStack.H

# ifndef TPL_DYNLISTSTACK_H
# define TPL_DYNLISTSTACK_H

# include <htlist.H>

namespace Aleph {

    template <typename T> 
class DynListStack : private DynList<T>
{
  size_t num_items;

public:

  DynListStack() : num_items(0) { /* empty */ }

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

  bool is_empty() const { return this->DynList<T>::is_empty(); }

  void swap(DynListStack & s)
  {
    this->DynList<T>::swap(s);
    std::swap(num_items, s.num_items);
  }

  DynListStack(const DynListStack & s) : num_items(0)
  {
    s.for_each([this] (const T & d) { this->append(d); ++num_items; });
  }

  DynListStack(DynListStack && s) : num_items(0)
  {
    swap(s);
  }

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

    num_items = s.num_items;
    (DynList<T>&) *this = s;
    return *this;
  }

  DynListStack & operator = (DynListStack && s)
  {
    this->swap(s);
    return *this;
  }

  typedef DynListStack Set_Type;

  typedef T Item_Type;

  const T & top() const 
  {
    return this->get_first();
  }

  T & push(const T & item) 
  {
    T & ret_val = this->insert(item);
    ++num_items;

    return ret_val;
  }

  T & push(T && item) 
  {
    T & ret_val = this->insert(std::move(item));
    ++num_items;

    return ret_val;
  }

  T & put(const T & item) { return push(item); }

  T & put(T && item) { return push(std::move(item)); }

  T pop() throw(std::exception, std::underflow_error)
  {
    T retVal = this->remove_first();
    --num_items;

    return retVal;
  }

  T get() { return pop(); }

  void empty()
  {
    this->DynList<T>::empty();
    num_items = 0;
  }

  virtual ~DynListStack()
  {
    empty();
  }

  template <class Operation>
  bool traverse(Operation & operation)
  {
    return this->DynList<T>::traverse(operation);
  }

  template <class Operation>
  bool traverse(Operation & operation) const
  {
    return this->DynList<T>::traverse(operation);
  }

  template <class Operation>
  bool traverse(Operation && operation = Operation()) const
  {
    return this->DynList<T>::traverse(std::move(operation));
  }

  template <class Operation>
  bool traverse(Operation && operation = Operation()) 
  {
    return this->DynList<T>::traverse(std::move(operation));
  }

  Functional_Methods(T);

  Generic_Items(T);
};

} // end namespace Aleph
# endif /* TPL_DYNLISTSTACK_H */