include/ngutil/orderedKeyList.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2004 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: orderedKeyList.h,v $ $Revision: 1.3 $ $State: Exp $
*******************************************************************************/


#ifndef ORDEREDKEYLIST_H_
#define ORDEREDKEYLIST_H_


#include <QtCore/QList>
#include "ngutil/entityMapperKey.h"

template <typename T>
class DtOrderedKeyList : public QList<T>
{
public:
   DtOrderedKeyList();
   DtOrderedKeyList(const DtOrderedKeyList&);

   DtOrderedKeyList& operator=(const DtOrderedKeyList&);

   virtual ~DtOrderedKeyList();

   void clear();
   void copyList(const DtOrderedKeyList&);

   void addEntry(T, bool replace = false);
   T removeEntry(const DtEntityMapperKey& key);
   T find(const DtEntityMapperKey& key) const;
};

template <typename T>
DtOrderedKeyList<T>::DtOrderedKeyList()
{
}

template <typename T>
DtOrderedKeyList<T>::DtOrderedKeyList(const DtOrderedKeyList<T>& orig)
{
   clear();
   copyList(orig);
}

template <typename T>
DtOrderedKeyList<T>& DtOrderedKeyList<T>::operator=(const DtOrderedKeyList<T>& rhs)
{
   if (this != &rhs)
   {
      clear();
      copyList(rhs);
   }

   return *this;
}
 
template <typename T>
DtOrderedKeyList<T>::~DtOrderedKeyList()
{
   clear();
}

template <typename T>
void DtOrderedKeyList<T>::clear()
{
   typename QList<T>::iterator it = this->begin();

   while (it != this->end())
   {
      delete *it;
      ++it;
   }

   QList<T>::clear();
}

template <typename T>
void DtOrderedKeyList<T>::copyList(const DtOrderedKeyList<T>& rhs)
{
   typename QList<T>::const_iterator it = rhs.begin();

   while (it != rhs.end())
   {
      addEntry((*it)->clone());
      ++it;
   }
}

template <typename T>
void DtOrderedKeyList<T>::addEntry(T entry, bool replace)
{
   if (this->count() == 0)
   {
      append(entry);

      return;
   }

   T item = this->last();
   DtEntityMapperKey sdKey = *entry;

   if (*item < sdKey)
   {
      append(entry);
      return;
   }

   item = this->first();

   if (*item > sdKey)
   {
      insert(0, entry);
      return;
   }

   QString strKey = entry->string().c_str();

   unsigned int iLower = 0;
   unsigned int iUpper = this->count() - 1;

   while ((iUpper - iLower) != 1)
   {
      int iPos = (iUpper + iLower) / 2;

      if (sdKey < *this->at(iPos))
      {
         iUpper = iPos;
      }
      else if (sdKey > *this->at(iPos))
      {
         iLower = iPos;
      }
      else if ((sdKey == *this->at(iPos)) && replace)
      {
         *this->at(iPos) = *entry;

         return;
      }
   }

   insert(iLower + 1, entry);
}

template <typename T>
T DtOrderedKeyList<T>::find(const DtEntityMapperKey& key) const
{
   typename QList<T>::const_iterator iter = this->begin();

   while (iter != this->end())
   {
      if (**iter == key)
      {
         return *iter;
      }

      ++iter;
   }

   return T();
}

template <typename T>
T DtOrderedKeyList<T>::removeEntry(const DtEntityMapperKey& key)
{
   typename QList<T>::iterator iter = this->begin();

   while (iter != this->end())
   {
      if (**iter == key)
      {
         T item = *iter;

         erase(iter);

         return item;
      }

      ++iter;
   }

   return NULL;
}

#endif //ORDEREDKEYLIST_H_