#ifndef COLLECTION_H
#define COLLECTION_H
/////////////////////////////////////////////////////////////////////
// collection.h - defines collection of name, value pairs          //
// ver 1.1                                                         //
// Language:    Visual C++, ver 7.0                                //
// Platform:    Dell Dimension 8300, Windows XP Pro, SP1.0         //
// Application: CSE687 - Object Oriented Design, Pr#3 prototype    //
// Author:      Jim Fawcett, CST 2-187, Syracuse University        //
//              (315) 443-3948, jfawcett@twcny.rr.com              //
/////////////////////////////////////////////////////////////////////
/*
 * Module Operations:
 * ==================
 * This module defines class collection<Name,Value> that holds and
 * discloses Name, Value pairs.
 *
 * Public Interface:
 * =================
 * collection<std::string,int> fingers;
 * fingers.push_back("thumb",1);
 * fingers.push_back("index",2);
 *   :
 * std::string finger;
 * int count;
 * while(fingers.next(finger,count))
 *  cout << "\n  " << finger << " - " << count;
 *
 *
 * Build Process:
 * ==============
 * Required files: collection.h, collection.cpp
 *
 * Build command: cl /EHsc /DTEST_COLLECTION collection.cpp
 *
 * Maintenance History:
 * ====================
 * ver 1.0 : 28 Mar 04
 * - first release
 * ver 1.1 : 06 Apr 04
 * - fixed wrong way increments in operator--(int), reported by
 *   Pritesh Valenkar.  Also added begin() member.
 *
 * Planned Modifications:
 * ======================
 * It was a bad idea to use begin() and end() to return bools
 * instead of iterators like all the STL.  I will rename these
 * functions when no one is using this class in a design.
 */
//
#include <list>

template <typename Name, typename Value>
class collection
{
public:
  collection();
  collection(const collection<Name,Value>& c);
  collection<Name,Value>& push_back(const Name& n, const Value& v);
  collection<Name,Value>& push_front(const Name& n, const Value& v);
  collection<Name,Value>& insert(const Name& n, const Value& v);
  collection<Name,Value>& front();
  collection<Name,Value>& back();
  bool next(Name& n, Value& v);
  collection<Name,Value>& item(Name& n, Value& v);
  collection<Name,Value>& name(Name& n);
  collection<Name,Value>& value(Value& v);
  collection<Name,Value>& operator=(const collection<Name,Value>& c);
  collection<Name,Value>& operator++();
  collection<Name,Value>  operator++(int);
  collection<Name,Value>& operator--();
  collection<Name,Value>  operator--(int);
  bool begin(); // change to isBegin()
  bool end();   // change to isEnd()
  size_t size();
private:
  std::list<Name> names;
  typename std::list<Name>::iterator nIter;
  std::list<Value> values;
  typename std::list<Value>::iterator vIter;
};
//----< void constructor >-------------------------------------------

template <typename Name, typename Value>
collection<Name,Value>::collection() 
{ 
  nIter = names.begin(); 
  vIter = values.begin();
}
//----< copy constructor >-------------------------------------------

template <typename Name, typename Value>
collection<Name,Value>::collection(const collection<Name,Value>& c) 
{ 
  std::list<Name>::const_iterator _nIter = c.names.begin();
  std::list<Value>::const_iterator _vIter = c.values.begin();
  for(_nIter=c.names.begin(); _nIter!=c.names.end(); ++_nIter)
  {
    names.push_back(*_nIter);
    values.push_back(*_vIter++);
  }
  nIter = names.begin();
  vIter = values.begin();
}
//
//----< assignment >-------------------------------------------------

template <typename Name, typename Value>
collection<Name,Value>& 
collection<Name,Value>::operator=(const collection<Name,Value>& c)
{
  if(this == &c) return *this;
  names.clear();
  values.clear();
  std::list<Name>::const_iterator _nIter = c.names.begin();
  std::list<Value>::const_iterator _vIter = c.values.begin();
  for(_nIter=c.names.begin(); _nIter!=c.names.end(); ++_nIter)
  {
    names.push_back(*_nIter);
    values.push_back(*_vIter++);
  }
  nIter = names.begin();
  vIter = values.begin();
  return *this;
}
//----< move to front of collection >--------------------------------

template <typename Name, typename Value>
collection<Name,Value>& collection<Name,Value>::front() 
{ 
  nIter = names.begin(); 
  vIter = values.begin();
  return *this;
}
//----< move to back of collection >---------------------------------

template <typename Name, typename Value>
collection<Name,Value>& collection<Name,Value>::back() 
{ 
  nIter = names.end(); 
  vIter = values.end();
  return *this;
}
//----< returns Name and Value references then increments >----------

template <typename Name, typename Value>
bool collection<Name,Value>::next(Name& n, Value& v) 
{ 
  if(nIter == names.end())
    return false;
  n = *nIter++; 
  v = *vIter++; 
  return true;
}
//
//----< insert item at current location >----------------------------

template <typename Name, typename Value>
collection<Name,Value>& 
collection<Name,Value>::insert(const Name& n, const Value& v)
{
  names.insert(nIter,n);
  values.insert(vIter,v);
  return *this;
}
//----< push item on back >------------------------------------------

template <typename Name, typename Value>
collection<Name,Value>& 
collection<Name,Value>::push_back(const Name& n, const Value& v) 
{ 
  names.push_back(n); 
  values.push_back(v);
  nIter = names.begin();
  vIter = values.begin();
  return *this;
}
//----< push item on front >-----------------------------------------

template <typename Name, typename Value>
collection<Name,Value>& 
collection<Name,Value>::push_front(const Name& n, const Value& v) 
{ 
  names.push_front(n); 
  values.push_front(v);
  nIter = names.begin();
  vIter = values.begin();
  return *this;
}
//
//----< return item Name and Value references >----------------------

template <typename Name, typename Value>
collection<Name,Value>& collection<Name,Value>::item(Name& name, Value& value) 
{ 
  name = *nIter;
  value = *vIter;
  return *this;
}
//----< return item Name reference >---------------------------------

template <typename Name, typename Value>
collection<Name,Value>& collection<Name,Value>::name(Name& n) 
{ 
  n = *nIter;
  return *this;
}
//----< return item value reference >--------------------------------

template <typename Name, typename Value>
collection<Name,Value>& collection<Name,Value>::value(Value& v) 
{ 
  v = *vIter;
  return *this;
}
//
//----< pre-increment >----------------------------------------------

template <typename Name, typename Value>
collection<Name,Value>& collection<Name,Value>::operator++() 
{ 
  ++nIter;
  ++vIter;
  return *this;
}
//----< post-increment >---------------------------------------------

template <typename Name, typename Value>
collection<Name,Value> collection<Name,Value>::operator++(int) 
{ 
  collection<Name,Value> temp = *this;
  ++nIter;
  ++vIter;
  return temp;
}
//----< pre-decrement >----------------------------------------------

template <typename Name, typename Value>
collection<Name,Value>& collection<Name,Value>::operator--() 
{ 
  --nIter;
  --vIter;
  return *this;
}
//----< post-decrement >---------------------------------------------

template <typename Name, typename Value>
collection<Name,Value> collection<Name,Value>::operator--(int) 
{ 
  collection<Name,Value> temp = *this;
  --nIter;
  --vIter;
  return temp;
}
//----< at beginning? >----------------------------------------------

template <typename Name, typename Value>
bool collection<Name,Value>::begin()
{ 
  return (nIter == names.begin()); 
}
//----< at end? >----------------------------------------------------

template <typename Name, typename Value>
bool collection<Name,Value>::end()
{
  return (nIter == names.end());
}
//----< return size of collection >----------------------------------

template <typename Name, typename Value>
size_t collection<Name,Value>::size()
{
  return names.size();
}

#endif