tpl_dynListQueue.H

# ifndef TPL_DYNLISTQUEUE_H
# define TPL_DYNLISTQUEUE_H

# include <iostream>
# include <htlist.H>

using namespace std;


namespace Aleph {

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

public:

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

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

  DynListQueue(const DynListQueue & q) 
    : DynList<T>(q), num_items(q.num_items)
  {
    // empty
  }

  DynListQueue(DynListQueue && q) 
  {
    swap(q);
  }

  DynListQueue & operator = (const DynListQueue & q)
  {
    if (this == &q)
      return *this;

    *static_cast<DynList<T>*>(this) = q;
    num_items = q.num_items;

    return *this;
  }

  DynListQueue & operator = (DynListQueue && q)
  {
    std::swap(num_items, q.num_items);
    this->DynList<T>::swap(q);
    return *this;
  }

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

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

  typedef DynListQueue Set_Type;

  typedef T Item_Type;

  T & put(const T & data) 
  {
    T & ret_val = this->append(data);
    ++num_items;
    return ret_val;
  }

  T & put(T && data) 
  {
    T & ret_val = this->append(std::move(data));
    ++num_items;
    return ret_val;
  }

  T get() 
  {
    T ret_val = this->remove_first();
    --num_items;
    return ret_val;
  }
 
  T & front() 
  {
    return this->get_first();
  }

  T & rear() 
  {
    return this->get_last();
  } 

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

  const T & rear() const 
  {
    return this->get_last();
  } 

  void empty()
  {
    this->DynList<T>::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_DYNLISTQUEUE_H