---

FIFOMap.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 FIFOMAP_H
#define FIFOMAP_H

#include "Map.h"
#include "Writeable.h"


template <class Key>
class KeyPair : virtual public Writeable
{
   public:
      KeyPair(const size_t newOrder = 0, 
              const Key& newKey = NULL_STRING)
      {
         order = newOrder; key = newKey;
      };

      operator Key() const { return key; };
      bool operator< (const KeyPair& rhs) const 
      { 
         return (order < rhs.order);
      };

      string ToString() const { return (string)key; };

      void SetKey(const Key& newKey) { key = newKey; };
      Key GetKey() const { return key; };
      void SetOrder(const size_t newOrder) { order = newOrder;};
      size_t GetOrder() const { return order; };

      bool operator== (const KeyPair& rhs) const 
      { 
         return ((order == rhs.order) && (key == rhs.key)); 
      };

      bool operator!= (const KeyPair& rhs) const { return (*this != rhs); };

   private:
      size_t order;
      Key key;
};


template <class Key,
          class Value,
          class KeyList = vector<Key>,
          class ValueList  = vector<Value>
         >
class FIFOMap : virtual public Map<KeyPair<Key>, Value, KeyList, ValueList>
{
   public:
      typedef Map<KeyPair<Key>, Value, KeyList, ValueList> KeyMap;
      typedef vector<Key> KeyVector;


      //{@
      Value& FIFOMap::operator[] (const Key& k);
      pair<iterator, bool>  insert(const pair<Key, Value>& newPair); 
      size_t erase(const Key& k); 


      //{@   
      Value Get(const Key& key) const;
      KeyVector GetWordsAsKeys() const;
      void Add(const Key& k, const Value& v);  
      void Set(const Key& k, const Value& v);

      KeyPair<Key> FindKeyPair(const Key& k) const;
};

template <class Key, class Value, class KeyList, class ValueList>
Value& 

FIFOMap<Key, Value, KeyList, ValueList>::operator[] (const Key& k)
{
   return (*((KeyMap::insert(Pair(FindKeyPair(k), Value()))).first)).second;
}

template <class Key, class Value, class KeyList, class ValueList>
pair<FIFOMap<Key, Value, KeyList, ValueList>::iterator, bool>  
FIFOMap<Key, Value, KeyList, ValueList>::
insert(const pair<Key, Value>& newPair)
{
   KeyPair<Key> k(size(), newPair.first);
   
   return KeyMap::insert(Pair(k, newPair.second));
}

template <class Key, class Value, class KeyList, class ValueList>
Value 

FIFOMap<Key, Value, KeyList, ValueList>::Get(const Key& key) const
{
   return KeyMap::Get(FindKeyPair(key));
}
   
template <class Key, class Value, class KeyList, class ValueList>
FIFOMap<Key, Value, KeyList, ValueList>::KeyVector 
FIFOMap<Key, Value, KeyList, ValueList>::
GetWordsAsKeys() const
{
   KeyVector kv;
   for (const_iterator p = begin(); p != end(); ++p)
      kv.push_back(p->first.GetKey());
   
   return kv;
}

template <class Key, class Value, class KeyList, class ValueList>
void 

FIFOMap<Key, Value, KeyList, ValueList>::Add(const Key& k, const Value& v)
{
   KeyMap::Add(KeyPair<Key>(size(), k), v);
}

template <class Key, class Value, class KeyList, class ValueList>
void 

FIFOMap<Key, Value, KeyList, ValueList>::Set(const Key& k, const Value& v)
{
   KeyMap::Set(KeyPair<Key>(size(), k), v);
}

template <class Key, class Value, class KeyList, class ValueList>
KeyPair<Key> 

FIFOMap<Key, Value, KeyList, ValueList>::FindKeyPair(const Key& k) const
{
   for (const_iterator p = begin(); p != end(); ++p)
   {
      if (p->first.GetKey() == k)
         return p->first;
   }

   return KeyPair<Key>(size(), k);
};

template <class Key, class Value, class KeyList, class ValueList>
size_t 
FIFOMap<Key, Value, KeyList, ValueList>::
erase(const Key& k)
{
   return KeyMap::erase(FindKeyPair(k));
};

#endif

---