include/symbolMapper/dictIter.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2002 MAK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: dictIter.h,v $ $Revision: 1.5 $ $State: Exp $
*********************************************************************/



#ifndef DtDictIter_H_
#define DtDictIter_H_


#include <QHash>

template<typename Key, typename Type> 
class DtDictIterator : public QHash<Key, Type>::iterator
{
public:
   DtDictIterator(QHash<Key, Type> &d) : myPosition(0), myCurrentDict(NULL) { addDataDict(&d); toFirst(); };

   ~DtDictIterator() {};

   unsigned int count() { return myCurrentDict->count(); };

   bool  isEmpty() const { return myCurrentDict->count() == 0; };

   Type toFirst() { if (myPosition >= (unsigned int)myList.count()) myPosition = 0; return reset(myPosition); };

   bool  remove( const Key &k )  { return ((QHash<Key, Type>*)myCurrentDict)->remove(k); }

   Type operator++()
   {
      QHash<Key, Type>::iterator::operator++();

      if (*this == myCurrentDict->end())
      {
         return nextList();
      }
      else
      {
         return QHash<Key, Type>::iterator::operator*();
      }
   };

   Type operator+=(uint j)
   {
      Type result = NULL;

      while (j > 0)
      {
         result = ++(*this);

         if (!result && (myPosition == myList.count()))
         {
            return NULL;
         }

         j--;
      }

      return result;
   };

   void operator=(const typename QHash<Key, Type>::iterator& iter)
   {
      QHash<Key, Type>::iterator::operator=(iter);
   }

   Type current()
   {
      if ((myCurrentDict == NULL) ||
           (*this == myCurrentDict->end()))

      {
         return NULL;
      }

      return **this;
   }

   Type reset(int toPosition = 0, bool findFirstValid = true)
   {
      myPosition = toPosition;

      if ((myPosition >= (unsigned int)myList.count()) || (myPosition < 0))
      {
         return NULL;
      }

      myCurrentDict = myList.at(myPosition);

      if (!findFirstValid)
      {
         *this = myCurrentDict->begin();
         return *myCurrentDict->begin();
      }

      Type result = NULL;

      do
      {
         *this = myCurrentDict->begin();

         if (myCurrentDict->begin() == myCurrentDict->end())
         {
            result = NULL;
         }
         else
         {
            result = *myCurrentDict->begin();
         }

         if (!result)
         {
            if (myPosition == myList.count())
            {
               return NULL;
            }
            else
            {
               if (++myPosition == myList.count())
               {
                  return NULL;
               }
               else
               {
                  myCurrentDict = myList.at(myPosition);
               }
            }
         }
      }
      while (!result);

      return result;
   };

   void addDataDict(QHash<Key, Type> *dict)
   {
      if (!myCurrentDict)
      {
         myCurrentDict = dict;
      }

      myList.append(dict);
   };

   Type find(const Key &key)
   {
      Type result = NULL;
      int limit = myList.count();

      for (int i = 0; i < limit; i++)
      {
         if (result = myList.at(i)->value(key))
         {
            return result;
         }
      }

      return NULL;
   }

   Type nextList()
   {
      if (++myPosition == myList.count())
      {
         return NULL;
      }
      else
      {
         myCurrentDict = myList.at(myPosition);
         return toFirst();
      }
   };

protected:
   QHash<Key, Type>* myCurrentDict;
   QList<QHash<Key, Type>* > myList;
   unsigned int myPosition;
};

#endif