SDict< T > Class Template Reference

#include <sortdict.h>

Classes
class	Iterator
class	IteratorDict

Public Member Functions
	SDict (int size=17, bool caseSensitive=TRUE)
virtual	~SDict ()
void	append (const char *key, const T *d)
void	prepend (const char *key, const T *d)
bool	remove (const char *key)
T *	take (const char *key)
void	sort ()
void	inSort (const char *key, const T *d)
void	insertAt (int i, const char *key, const T *d)
void	setAutoDelete (bool val)
T *	find (const char *key)
T *	find (const QCString &key)
T *	find (const QString &key)
int	findAt (const QCString &key)
T *	operator[] (const char *key) const
T *	at (uint i)
virtual int	compareValues (const T *item1, const T *item2) const
void	clear ()
int	count () const

Private Attributes
SList< T > *	m_list
QDict< T > *	m_dict
int	m_sizeIndex

Friends
class	Iterator
class	IteratorDict

Detailed Description

template<class T>
class SDict< T >

Ordered dictionary of elements of type T. Internally uses a QList<T> and a QDict<T>.

Definition at line 73 of file sortdict.h.

Constructor & Destructor Documentation

template<class T>

SDict< T >::SDict ( int  size = 17, bool  caseSensitive = TRUE  )

inline

Create an ordered dictionary.

Parameters

size	The size of the dictionary. Should be a prime number for best distribution of elements.
caseSensitive	indicated whether the keys should be sorted in a case sensitive way.

Definition at line 111 of file sortdict.h.

                                               : m_sizeIndex(0)
    {
      m_list = new SList<T>(this);
#if AUTORESIZE
      while ((uint)size>SDict_primes[m_sizeIndex]) m_sizeIndex++;
      m_dict = new QDict<T>(SDict_primes[m_sizeIndex],caseSensitive);
#else
      m_dict = new QDict<T>(size,caseSensitive);
#endif
    }

template<class T>

virtual SDict< T >::~SDict ( )

inlinevirtual

Destroys the dictionary

Definition at line 123 of file sortdict.h.

    {
      delete m_list;
      delete m_dict;
    }

Member Function Documentation

template<class T>

void SDict< T >::append ( const char *  key, const T *  d  )

inline

Appends an element to the dictionary. The element is owned by the dictionary.

Parameters

key	The unique key to use to quicky find the item later on.
d	The compound to add.

See also

find()

Definition at line 135 of file sortdict.h.

    {
      m_list->append(d);
      m_dict->insert(key,d);
#if AUTORESIZE
      if (m_dict->size()>SDict_primes[m_sizeIndex])
      {
        m_dict->resize(SDict_primes[++m_sizeIndex]);
      }
#endif
    }

template<class T>

T* SDict< T >::at ( uint  i )

inline

Returns the item at position i in the sorted dictionary

Definition at line 258 of file sortdict.h.

    {
      return m_list->at(i);
    }

template<class T>

void SDict< T >::clear ( )

inline

Clears the dictionary. Will delete items if setAutoDelete() was set to TRUE.

See also

setAutoDelete

Definition at line 276 of file sortdict.h.

    {
      m_list->clear();
      m_dict->clear();
    }

template<class T>

virtual int SDict< T >::compareValues ( const T *  item1, const T *  item2  ) const

inlinevirtual

Function that is used to compare two items when sorting. Overload this to properly sort items.

See also

inSort()

Reimplemented in NamespaceSDict, DirSDict, GroupSDict, SearchIndexList, FilePairDict, MemberSDict, MemberNameInfoSDict, PageSDict, ClassSDict, IndexFieldSDict, MemberNameSDict, SortedRefItems, and ExampleSDict.

Definition at line 267 of file sortdict.h.

    {
      return item1!=item2;
    }

template<class T>

int SDict< T >::count ( ) const

inline

Returns the number of items stored in the dictionary

Definition at line 284 of file sortdict.h.

    {
      return m_list->count();
    }

template<class T>

T* SDict< T >::find ( const char *  key )

inline

Looks up a compound given its key.

Parameters

key	The key to identify this element.

Returns

The requested compound or zero if it cannot be found.

See also

append()

Definition at line 232 of file sortdict.h.

    {
      return m_dict->find(key);
    }

template<class T>

T* SDict< T >::find ( const QCString &  key )

inline

Definition at line 236 of file sortdict.h.

    {
      return m_dict->find(key);
    }

template<class T>

T* SDict< T >::find ( const QString &  key )

inline

Definition at line 240 of file sortdict.h.

    {
      return m_dict->find(key);
    }

template<class T>

int SDict< T >::findAt ( const QCString &  key )

inline

Definition at line 244 of file sortdict.h.

    {
      T *item = find(key);
      if (item==0) return -1;
      return m_list->find(item);
    }

template<class T>

void SDict< T >::insertAt ( int  i, const char *  key, const T *  d  )

inline

Definition at line 209 of file sortdict.h.

    {
      m_list->insert(i,d);
      m_dict->insert(key,d);
#if AUTORESIZE
      if (m_dict->size()>SDict_primes[m_sizeIndex])
      {
        m_dict->resize(SDict_primes[++m_sizeIndex]);
      }
#endif
    }

template<class T>

void SDict< T >::inSort ( const char *  key, const T *  d  )

inline

Inserts a compound into the dictionary in a sorted way.

Parameters

key	The unique key to use to quicky find the item later on.
d	The compound to add.

See also

find()

Definition at line 197 of file sortdict.h.

    {
      m_list->inSort(d);
      m_dict->insert(key,d);
#if AUTORESIZE
      if (m_dict->size()>SDict_primes[m_sizeIndex])
      {
        m_dict->resize(SDict_primes[++m_sizeIndex]);
      }
#endif
    }

template<class T>

T* SDict< T >::operator[] ( const char *  key ) const

inline

Equavalent to find().

Definition at line 252 of file sortdict.h.

    {
      return m_dict->find(key);
    }

template<class T>

void SDict< T >::prepend ( const char *  key, const T *  d  )

inline

Prepends an element to the dictionary. The element is owned by the dictionary.

Parameters

key	The unique key to use to quicky find the item later on.
d	The compound to add.

See also

find()

Definition at line 153 of file sortdict.h.

    {
      m_list->prepend(d);
      m_dict->insert(key,d);
#if AUTORESIZE
      if (m_dict->size()>SDict_primes[m_sizeIndex])
      {
        m_dict->resize(SDict_primes[++m_sizeIndex]);
      }
#endif
    }

template<class T>

bool SDict< T >::remove ( const char *  key )

inline

Remove an item from the dictionary

Definition at line 166 of file sortdict.h.

    {
      T *item = m_dict->take(key);
      return item ? m_list->remove(item) : FALSE;
    }

template<class T>

void SDict< T >::setAutoDelete ( bool  val )

inline

Indicates whether or not the dictionary owns its elements

Definition at line 222 of file sortdict.h.

    {
      m_list->setAutoDelete(val);
    }

template<class T>

void SDict< T >::sort ( )

inline

Sorts the members of the dictionary. First appending a number of members and then sorting them is faster (O(NlogN) than using inSort() for each member (O(N^2)).

Definition at line 188 of file sortdict.h.

    {
      m_list->sort();
    }

template<class T>

T* SDict< T >::take ( const char *  key )

inline

Take an item out of the dictionary without deleting it

Definition at line 173 of file sortdict.h.

    {
      T *item = m_dict->take(key);
      if (item)
      {
        int i = m_list->find(item);
        m_list->take(i);
      }
      return item;
    }

Friends And Related Function Documentation

template<class T>

friend class Iterator

friend

Definition at line 289 of file sortdict.h.

template<class T>

friend class IteratorDict

friend

Definition at line 353 of file sortdict.h.

Member Data Documentation

template<class T>

QDict<T>* SDict< T >::m_dict

private

Definition at line 101 of file sortdict.h.

template<class T>

SList<T>* SDict< T >::m_list

private

Definition at line 100 of file sortdict.h.

template<class T>

int SDict< T >::m_sizeIndex

private

Definition at line 102 of file sortdict.h.

---

The documentation for this class was generated from the following file:

• doxygen-1.8.11/src/sortdict.h