tpl_listQueue.H

# ifndef TPL_LISTQUEUE_H
# define TPL_LISTQUEUE_H

# include <tpl_snode.H>

using namespace Aleph;

namespace Aleph {

    template <typename T> 
class ListQueue 
{
public:

    typedef Snode<T>  Node;

    typedef ListQueue Set_Type;

    typedef Node *    Item_Type;

private:

  Node * rear_ptr;
  size_t num_nodes;

public:

  ListQueue() : rear_ptr(NULL), num_nodes(0) { /* empty */ }

  void put(Node * node)
  {
    I(node->is_empty());

    if (num_nodes > 0)
      rear_ptr->insert_next(node);
    num_nodes++;
    rear_ptr = node;
  }

  Node * get() throw(std::exception, std::underflow_error)
  {
    if (num_nodes == 0)
      throw std::underflow_error("stack is empty");

    Node * ret_val = rear_ptr->remove_next(); 
    num_nodes--;
    if (num_nodes == 0)
      rear_ptr = NULL;

    return ret_val;
  }

  Node * front() const throw(std::exception, std::underflow_error)
  {
    if (num_nodes == 0)
      throw std::underflow_error("stack is empty");

    return rear_ptr->get_next();
  }

  Node * rear() const throw(std::exception, std::underflow_error)
  {
    if (num_nodes == 0)
      throw std::underflow_error("stack is empty");

    return rear_ptr;
  }

  size_t size() const { return num_nodes; }

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

  void swap(ListQueue & q)
  {
    std::swap(num_nodes, q.num_nodes);
    std::swap(rear_ptr, q.rear_ptr);
  }
};

} // end namespace Aleph

# endif /* TPL_LISTQUEUE_H */