#include "hmap.h"
#include "hiterator.h"
#include <stdlib.h>

// Owen Astrachan
// 11/8/95

template <class Key, class Value>
HMap<Key,Value>::HMap(unsigned int (*hash) (const Key &), int size)
 : myList(size,0),
   myFunction(hash)
// postcondition: all fields constructed, initialized
{
    // work done in initializer list
}

template <class Key, class Value>
HMap<Key,Value>::~HMap()
{
    // nothing to be freed
}

template <class Key, class Value>
Value & HMap<Key,Value>::GetValue(const Key & key)
// postcondition: returns value associated with key in map
// exception: if key not in map, error printed, program halted
{
    Node <Pair<Key,Value> >* index = Find(key);          // find
											  // location
    
    if (index != 0)
    {
	   return index->info.second;
    }
    cerr << "Error in GetValue, aborting execution" << endl;
    abort();
}

template <class Key, class Value>
const Value & HMap<Key,Value>::GetValue(const Key & key) const
// postcondition: returns value associated with key in map
// exception: if key not in map, error printed, program halted
{
    Node <Pair<Key,Value> >* index = Find(key);          // find
											  // location
    if (index != 0)
    {
	return index->info.second;
    }
    
    cerr << "Error in GetValue (const), aborting execution" << endl;
    abort();
}

template <class Key, class Value>
void HMap<Key,Value>::Apply(void (*Func) (Pair<Key,Value> & p))
// postcondition: Func() applied to all map elements     
{
    int k;
    for(k=0; k < myList.Length(); k++)
    {
	   Node <Pair <Key,Value> >* ptr = myList[k];
	   while (ptr)
	   {
		  (*Func)(ptr->info);
		  ptr = ptr->next;
	   }
    }
}

template <class Key, class Value>
void HMap<Key,Value>::Apply(MapBase<Key,Value> & obj)
// postcondition: obj.Function() applied to all map elements     
{
    int k;
    for(k=0; k < myList.Length(); k++)
    {
	   Node<Pair<Key,Value> >* ptr = myList[k];

	   while (ptr)
	   {
		  obj.Function(ptr->info.first,ptr->info.second);
		  ptr = ptr->next;
	   }

    }
}

template <class Key, class Value>
bool HMap<Key,Value>::IncludesKey(const Key & key) const
// postcondition: returns true if key in map, otherwise returns false
{
    return Find(key) != 0;
}

template <class Key, class Value>
Node<Pair <Key,Value> > * HMap<Key,Value>::Find(const Key & key) const
// postcondition: returns index of key in private vector (pointer)
//                returns 0 if key NOT in vector
{

    int loc = (*myFunction)(key) % myList.Length();
    Node<Pair<Key,Value> > * ptr = myList[loc];
    while (ptr)
    {
	   if (ptr->info.first == key) return ptr;
	   ptr = ptr->next;
    }
    return 0;

}


template <class Key, class Value>
void HMap<Key,Value>::GetValue(Pair<Key,Value> & pair)
// postcondition: pair = pair associated with key (pair.first) in map
//                if key NOT in map, no value assigned
{
    Node<Pair<Key,Value> > *  index = Find(pair.first);
    if (index != 0)
    {
	   pair = index->info;
    }
}

template <class Key, class Value>
void HMap<Key,Value>::Delete(const Key & key) 
// postcondition: returns index of key in private vector (pointer)
//                returns 0 if key NOT in vector
{

    int loc = (*myFunction)(key) % myList.Length();
    Node<Pair<Key,Value> > * ptr = myList[loc];
    Node<Pair<Key,Value> > * trail = 0;

    while (ptr && ptr->info.first!=key)
    {
	   trail = ptr;
	   ptr = ptr->next;
    }
    if (ptr)
    {
	   if (trail)
	   {
		  trail->next = ptr->next;
	   }
	   else  //Head of list
	   {
		  myList[loc] = ptr->next;
	   }
	   delete ptr;
    }
		  

}


template <class Key, class Value>
void HMap<Key,Value>::Insert(const Pair<Key,Value> & pair)
// precondition: pair.first key NOT stored in map
// postcondition: pair is added to map (maps pair.first -> pair.second)
{
    Node<Pair <Key,Value> > * index = Find(pair.first);
    if (index == 0)
    {
	   int loc = (*myFunction)(pair.first) % myList.Length();
	   index = new Node < Pair<Key,Value> >;
	   index->next = myList[loc];
	   index->info = pair;
	   myList[loc] = index;
	   myNumElts++;
    }
}

template <class Key, class Value>
void HMap<Key,Value>::Insert(const Key & key, const Value & val)
{
    Insert(Pair<Key,Value>(key,val));
}

template <class Key, class Value>
Iterator<Pair<Key,Value> > * HMap<Key,Value>::MakeIterator()
// postcondition: returns dynamically allocated iterator     
{
    Iterator<Pair<Key,Value> > * temp =
	   new HMapIterator<Pair <Key,Value> >(myList);
    return temp;
    
}