// DICT.H - Dictionary Class Template

#include <iostream>
#include "range.h"

class DictionaryFull {
public:
  friend ostream & operator <<(ostream & os,
			       const DictionaryFull & F);
};

ostream & operator <<(ostream & os,
		      const DictionaryFull & F)
{
  os << "Dictionary is full.";
  return os;
}

template<class TKey>
class DuplicateKey {
public:
  DuplicateKey( TKey theKey )
  { m_key = theKey; }

  friend ostream & operator <<(ostream & os,
                               const DuplicateKey<TKey> & F)
    {
      os << "Attempt to add duplicate key.";
      return os;
    };
  
private:
  TKey m_key;
};

/*// If I define the function here, I get a warning. That is why
// I have defined this function within the class.
template<class TKey>
ostream & operator <<(ostream & os,
			     const DuplicateKey<TKey> & F)
{
  os << "Attempt to add duplicate key.";
  return os;
};
*/



template<class TKey, class TVal>
class Dictionary {
public:
  Dictionary( int initialSize );

  bool Add( const TKey & tk, const TVal & tv );
  // Add a new key and value to the dictionary.
  // Return true if successful, false otherwise.

  int Find( const TKey & tk );
  // If a key matching <tk> is found, return its index
  // position; if not found, return -1.
 
  TVal At(int index) const;
  // Retrieve a copy of the value at position index

  vector<TKey> FindVal( const TVal & searchFor );
  // Return a vector containing all keys that 
  // correspond to a particular value. If no
  // matches are found, return an empty vector.

  int size() const
  // Return the number of entries
  { return m_vKeys.size(); }
  
  friend ostream & operator <<( ostream & os,
				const Dictionary<TKey, TVal> & D )
    {
      for(unsigned i = 0; i < D.size(); i++)
        cout << D.m_vKeys[i] << " -> "
             << D.m_vValues[i] << '\n';
      
      return os;
    }
  
private:
  vector<TKey> m_vKeys;      // vector of dictionary m_vKeys
  vector<TVal> m_vValues;    // vector of dictionary m_vValues
};

/* // If I define the function here, I get a warning. That is why
// I have defined this function within the class.
template<class TKey,class TVal>
ostream & operator <<( ostream & os,
			      const Dictionary<TKey, TVal> & D )
{
  for(unsigned i = 0; i < D.size(); i++)
    cout << D.m_vKeys[i] << " -> "
	 << D.m_vValues[i] << '\n';
  
  return os;
}

*/
template<class TKey,class TVal>
Dictionary<TKey,TVal>::Dictionary( int initialSize )
{
  m_vKeys.reserve( initialSize );
  m_vValues.reserve( initialSize );
}

template<class TKey,class TVal>
bool Dictionary<TKey,TVal>::Add( const TKey & tk,
                                 const TVal & tv )
// Add a new key and associated value to the
// dictionary. Return true if successful. If an attempt
// is made to add a duplicate key, throw a DuplicateKey 
// exception. 
{
  if( Find(tk) == -1 )        // not already in dictionary?
  {
    m_vKeys.push_back(tk);    // add new key
    m_vValues.push_back(tv);  // add associated value
    return true;              // success!
  }
  // must have been a duplicate key
  throw DuplicateKey<TKey>(tk);		
  return false; 
}

template<class TKey,class TVal>
int Dictionary<TKey,TVal>::Find( const TKey & tk )
{
  for(int i = 0; i < m_vKeys.size(); i++)
  {
    if( tk == m_vKeys[i] )
      return i;
  }
  return -1;   // not found
}

template<class TKey,class TVal>
TVal Dictionary<TKey,TVal>::At(int index) const
{
  return m_vValues[index];
}
/*
template<class TKey, class TVal>
ostream & operator <<( ostream & os,
        const Dictionary<TKey, TVal> & D )
{
  for(unsigned i = 0; i < D.size(); i++)
    cout << D.m_vKeys[i] << " -> "
         << D.m_vValues[i] << '\n';

  return os;
}
*/