---

Map.h

// Copyright (C) 2001 Kevin Duffy <kevin@buhbird.com>
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA


#ifndef MAPCLASS_H
#define MAPCLASS_H

#include <vector>
#include <map>
#include <list>
using namespace std;


template <class Word, 
          class Definition,
          class WordList = vector<Word>,
          class DefList  = vector<Definition>
         >
class Map : virtual public map<Word, Definition>
{
   public:
      typedef map<Word, Definition>::value_type Pair;



      virtual Definition Get(const Word& word) const;
   
      virtual WordList GetWords() const;

      virtual DefList GetDefs() const;



      virtual void Add(const Word& word, const Definition& definition);

   /* I'm waiting for gcc to accept this
      virtual void Add(const WordList& wordList, const DefList& defList);
   */
      virtual void Add(const Pair& newPair);

      virtual void Set(const Word& word, const Definition& definition);

/* I'm waiting for gcc to accept this
      virtual void Set(const DefList& defList);
   */

      bool Find(const Word& word) const;

      virtual ~Map() {};
};

template <class Word, class Definition, class WordList, class DefList>
inline Definition 

Map<Word, Definition, WordList, DefList>::Get(const Word& word) const
{
   const_iterator p;
   return  ((p = find(word)) != end()) ? p->second : Definition();
}

template <class Word, class Definition, class WordList, class DefList>
inline void 

Map<Word, Definition, WordList, DefList>::Add(const Word& word, const Definition& definition)
{
   Find(word) ? Set(word, definition) : insert(end(), Pair(word, definition));
}

template <class Word, class Definition, class WordList, class DefList>
inline void 

Map<Word, Definition, WordList, DefList>::Add(const Pair& newPair)
{
   Add(newPair.first, newPair.second);
}

/*
template <class Word, class Definition, class WordList, class DefList>
inline void 
Map<Word, Definition, WordList, DefList>::
Add(const WordList& wordList, const DefList& defList)
{
   typename Map<Word, Definition, WordList, DefList>::WordList::const_iterator;
   WordList::const_iterator p = wordList.begin();
   DefList::const_iterator dp = defList.begin();
   for (p, dp; 
        p != wordList.end() && dp != defList.end(); 
        ++p, ++dp)
   {
      Add(*p, *dp);
   }
}
*/

template <class Word, class Definition, class WordList, class DefList>
inline void

Map<Word, Definition, WordList, DefList>::Set(const Word& word, const Definition& definition)
{
   (*this)[word] = definition;
}

/*
template <class Word, class Definition, class WordList,class DefList>
inline void
Map<Word, Definition, WordList, DefList>::
Set(const DefList& defList)
{
   Add(GetWords(), defList);
}
*/

template <class Word, class Definition,class WordList,class DefList>
inline bool

Map<Word, Definition, WordList, DefList>::Find(const Word& word) const
{
   return (find(word) != end());
}

template <class Word, class Definition,class WordList,class DefList>
inline WordList

Map<Word, Definition, WordList, DefList>::GetWords() const
{ 
   WordList wl;
   for (const_iterator p = begin(); p != end(); ++p)
      wl.push_back(p->first);
   return wl; 
}

template <class Word, class Definition,class WordList,class DefList>
inline DefList

Map<Word, Definition, WordList, DefList>::GetDefs() const
{
   DefList dl;
   for (const_iterator p = begin(); p != end(); ++p)
      dl.push_back(p->second);
   return dl; 
}     

#endif

---