#ifndef Nodes_H
#define Nodes_H
///////////////////////////////////////////////////////////////////////////
// Nodes.h - demonstrate how to define a template node class             //
// ver 1.1                                                               //
// Language:    Visual C++, 2008                                         //
// Platform:    Dell Precision T7400, Vista Ultimate, SP1                //
// Application: CSE687 - Demo for Project #1, Spring 2009                //
// Author:      Jim Fawcett, Syracuse University, CST 4-187,             //
//              (315) 443-3948, jfawcett@twcny.rr.com                    //
///////////////////////////////////////////////////////////////////////////
/*
 * Module Operations:
 * ==================
 * Provides a template Node class that holds a finite number of pointers
 * to child nodes, and a visitation predicate.  
 * 
 * Build Process:
 * ==============
 * cl /D:TEST_NODES Nodes.cpp
 * 
 * Maintenance History:
 * ====================
 * ver 1.1 : 27 Jan 10
 * - added private copy and assignment operations to
 *   prevent compiler from generating incorrect versions
 * ver 1.0 : 23 Jan 09
 * - first release
 */

#include <vector>

namespace AbstractDataTypes
{
  template <typename T>
  class MNode
  {
  public:
    MNode(const T& t=0);
    void add(MNode<T>* pMNode);
    bool remove(MNode<T>* pMNode);
    MNode<T>* nextUnmarkedChild();
    T& value();
    bool& isMarked();
    // Compiler generated copy and assignment are shallow.
    // That makes sense for a Node class.
  private:
    std::vector< MNode<T>* > children;
    T t_;
    bool marked_;
  };

  template <typename T>
  inline MNode<T>::MNode(const T& t=0) : t_(t), marked_(false) {};

  template <typename T>
  inline void MNode<T>::add(MNode<T>* pMNode)
  {
    children.push_back(pMNode);
  }
  
  template <typename T>
  inline T& MNode<T>::value() { return t_; }

  template <typename T>
  inline bool& MNode<T>::isMarked() { return marked_; }

  template <typename T>
  bool MNode<T>::remove(MNode<T>* pMNode)
  {
    std::vector< MNode<T>* >::iterator iter = children.begin();
    for(iter=children.begin(); iter!=children.end(); ++iter)
    {
      if(pMNode == *iter)
      {
        children.erase(iter);
        return true;
      }
    }
    return false;
  }

  template <typename T>
  MNode<T>* MNode<T>::nextUnmarkedChild()
  {
    for(size_t i=0; i<children.size(); ++i)
      if(!children[i]->isMarked())
        return children[i];
    return 0;
  }
}

#endif