1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
|
/******************************************************************************
*
*
*
*
* Copyright (C) 1997-2001 by Dimitri van Heesch.
*
* Permission to use, copy, modify, and distribute this software and its
* documentation under the terms of the GNU General Public License is hereby
* granted. No representations are made about the suitability of this software
* for any purpose. It is provided "as is" without express or implied warranty.
* See the GNU General Public License for more details.
*
* Documents produced by Doxygen are derivative works derived from the
* input used in their production; they are not affected by this license.
*
*/
#ifndef _SORTDICT_H
#define _SORTDICT_H
#include "qtbc.h"
#include <qlist.h>
#include <qdict.h>
template<class T> class SDict;
/*! internal wrapper class that redirects compareItems() to the
* dictionary
*/
template<class T>
class SList : public QList<T>
{
public:
SList(SDict<T> *owner) : m_owner(owner) {}
~SList() {}
int compareItems(GCI item1,GCI item2)
{
return m_owner->compareItems(item1,item2);
}
private:
SDict<T> *m_owner;
};
/*! Ordered dictionary of elements of type T.
* Internally uses a QList<T> and a QDict<T>.
*/
template<class T>
class SDict
{
private:
SList<T> *m_list;
QDict<T> *m_dict;
public:
/*! Create an ordered dictionary.
* \param size The size of the dictionary. Should be a prime number for
* best distribution of elements.
*/
SDict(int size)
{
m_list = new SList<T>(this);
m_dict = new QDict<T>(size);
}
/*! Destroys the dictionary */
virtual ~SDict()
{
delete m_list;
delete m_dict;
}
/*! Appends a compound to the dictionary. The element is owned by the
* dictionary.
* \param key The unique key to use to quicky find the item later on.
* \param d The compound to add.
* \sa find()
*/
void append(const char *key,const T *d)
{
m_list->append(d);
m_dict->insert(key,d);
}
/*! Inserts a compound into the dictionary in a sorted way.
* \param key The unique key to use to quicky find the item later on.
* \param d The compound to add.
* \sa find()
*/
void inSort(const char *key,const T *d)
{
m_list->inSort(d);
m_dict->insert(key,d);
}
/*! Indicates whether or not the dictionary owns its elements */
void setAutoDelete(bool val)
{
m_list->setAutoDelete(val);
}
/*! Looks up a compound given its key.
* \param key The key to identify this element.
* \return The requested compound or zero if it cannot be found.
* \sa append()
*/
T *find(const char *key)
{
return m_dict->find(key);
}
/*! Function that is used to compare two items when sorting.
* Overload this to properly sort items.
* \sa inSort()
*/
virtual int compareItems(GCI item1,GCI item2)
{
return item1!=item2;
}
/*! Clears the dictionary. Will delete items if setAutoDelete() was
* set to \c TRUE.
* \sa setAutoDelete
*/
void clear()
{
m_list->clear();
m_dict->clear();
}
/*! Returns the number of items stored in the dictionary
*/
int count()
{
return m_list->count();
}
class Iterator; // first forward declare
friend class Iterator; // then make it a friend
/*! Simple iterator for SDict. It iterates in the order in which the
* elements are stored.
*/
class Iterator
{
public:
/*! Create an iterator given the dictionary. */
Iterator(const SDict<T> &dict)
{
m_li = new QListIterator<T>(*dict.m_list);
}
/*! Destroys the dictionary */
virtual ~Iterator()
{
delete m_li;
}
/*! Set the iterator to the first element in the list.
* \return The first compound, or zero if the list was empty.
*/
T *toFirst() const
{
return m_li->toFirst();
}
/*! Returns the current compound */
T *current() const
{
return m_li->current();
}
/*! Moves the iterator to the next element.
* \return the new "current" element, or zero if the iterator was
* already pointing at the last element.
*/
T *operator++()
{
return m_li->operator++();
}
private:
QListIterator<T> *m_li;
};
};
#endif
|
