#ifndef NODEPOOL_H
#define NODEPOOL_H
///////////////////////////////////////////////////////////////
//  nodePool.h  - class that manages a pool of nodes         //
//  ver 1.0                                                  //
//  Language:     Visual C++, ver 6.0                        //
//  Platform:     Micron Dual Pentium Pro 200, Win NT 4.0    //
//  Application:  CSE691 - Project #3 prototype              //
//  Author:       Jim Fawcett, CST 2-187, Syracuse Univ      //
//                (315) 443-3948, fawcett@syr.edu            //
///////////////////////////////////////////////////////////////
/*
  Class Operation
  ===============
  An object of the nodePool class recycles nodes used by the
  mtqueue class.  When an mtqueue object deQs a node, it hands
  the node to the nodePool object for safekeeping.  When it
  enQs a node it retrieves the node from the nodePool object.

  The nodePool object saves recycled nodes on a singly-linked
  list.  If mtqueue requests a node when the free list is empty
  the nodePool object creates one from the heap.

  Public Interface:
  =================
  nodePool<int> np;  // create nodePool object with empty free list
  saveNode(pNode);   // add node to free list
  node<int> *pNode = retrieveNode();
                     // pop node of free list or create it
*/

///////////////////////////////////////////////////////////////
//  build process                                            //
///////////////////////////////////////////////////////////////
//  required files:                                          //
//    nodePool.h, nodePool.cpp                               //
//                                                           //
//  command line compile:                                    //
//    cl /GX /GZ /DTEST_NODEPOOL nodePool.cpp                //
///////////////////////////////////////////////////////////////
/*
    Maintenance History:
    ====================
    ver 1.0 : 31 Jan 2000
      - first release
*/
//

///////////////////////////////////////////////////////////////
//  class declaration for node                               //
///////////////////////////////////////////////////////////////

template <class T> class node {

  public:
    node(const T &t, node<T> *link);
    ~node();
    T& value();
    node<T>*& prev();   // read or write prev pointer
    node<T>*& next();   // read or write next pointer

  private:
    node<T> *_prev;
    node<T> *_next;
    T _t;
};

//----< node constructor >-------------------------------------
//
//  construct node, give it a value, and link to
//  head of the list
//
template <class T> 
node<T>::node(const T &t, node<T> *link) 
       : _t(t), _prev(NULL), _next(link) {

  // _t is stored value
  // _prev is at head of list so there is no prev
  // _next is link to old first node
}

//----< destructor doesn't need to do anything >---------------

template <class T> 
inline node<T>::~node() { }

//----< return node's value >----------------------------------
//
//  must return by reference so new value can be
//  written to _t as well as read from _t
//
template <class T> 
inline T& node<T>::value() { return _t; }

//

//----< get pointer to previous node >-------------------------
//
//  must return reference so prev() can write a new value
//  to _prev as well as read the value from _prev
//
template <class T> 
inline node<T>*& node<T>::prev() { return _prev; }

//----< get pointer to next node >-----------------------------
//
//  must return reference so next() can write a new value
//  to _next as well as return the value from _next
//
template <class T> 
inline node<T>*& node<T>::next() { return _next; }

///////////////////////////////////////////////////////////////
//  declarations for class nodePool                          //
///////////////////////////////////////////////////////////////

template <class T> class nodePool {

public:
  nodePool();
  ~nodePool();
  void saveNode(node<T> *pNode);
  node<T>* retrieveNode(const T &t, node<T> *link);
  int size();

private:
  node<T> *free;
  int _size;
};

//----< return number of saved nodes >-------------------------

template <class T>
inline nodePool<T>::size() { return _size; }

//

//----< void constructor >-------------------------------------

template <class T>
nodePool<T>::nodePool() : free(NULL), _size(0) { }

//----< destructor >-------------------------------------------

template <class T>
nodePool<T>::~nodePool() { 

  while(free != NULL) {
    node<T> *pNode = free->next();
    delete free;
    free = pNode;
  }
  _size = 0;
}

//----< node saver >-------------------------------------------

template <class T>
void nodePool<T>::saveNode(node<T> *pNode) { 

  pNode->next() = free;
  free = pNode;
  _size++;
}

//----< node retriever >---------------------------------------

template <class T>
node<T>* nodePool<T>::retrieveNode(const T &t, node<T> *link) { 

  if(free == NULL)
    return new node<T>(t,link);

  _size--;
  node<T> *pNode = free;
  free = free->next();
  pNode->next()  = link;
  pNode->value() = t;
  return pNode;
}

#endif