]>
Commit | Line | Data |
---|---|---|
feb10c40 | 1 | #ifndef ALIHLTMUONCOUNTEDLIST_H |
2 | #define ALIHLTMUONCOUNTEDLIST_H | |
3 | /************************************************************************** | |
4 | * Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. * | |
5 | * * | |
6 | * Author: The ALICE Off-line Project. * | |
7 | * Contributors are mentioned in the code where appropriate. * | |
8 | * * | |
9 | * Permission to use, copy, modify and distribute this software and its * | |
10 | * documentation strictly for non-commercial purposes is hereby granted * | |
11 | * without fee, provided that the above copyright notice appears in all * | |
12 | * copies and that both the copyright notice and this permission notice * | |
13 | * appear in the supporting documentation. The authors make no claims * | |
14 | * about the suitability of this software for any purpose. It is * | |
15 | * provided "as is" without express or implied warranty. * | |
16 | **************************************************************************/ | |
17 | ||
18 | /* $Id$ */ | |
19 | ||
20 | /** | |
21 | * @file AliHLTMUONCountedList.h | |
22 | * @author Artur Szostak <artursz@iafrica.com> | |
23 | * @date | |
24 | * @brief Declaration of a linked-list class which counts the number of | |
25 | * elements it contains. | |
26 | */ | |
27 | ||
28 | #include "AliHLTMUONList.h" | |
29 | ||
30 | /** | |
31 | * The AliHLTMUONCountedList class behaves just like the AliHLTMUONList class | |
32 | * but uses an internal counter to count the number of elements in the list. | |
33 | * This means calls to Count() are much more efficient. | |
34 | */ | |
35 | template <typename DataType> | |
36 | class AliHLTMUONCountedList : public AliHLTMUONList<DataType> | |
37 | { | |
38 | public: | |
39 | ||
40 | typedef typename AliHLTMUONList<DataType>::Iterator Iterator; | |
41 | typedef typename AliHLTMUONList<DataType>::ConstIterator ConstIterator; | |
42 | ||
43 | AliHLTMUONCountedList(AliHLTUInt32_t maxentries = 1024*4) : | |
44 | AliHLTMUONList<DataType>(maxentries), fCount(0) | |
45 | {} | |
46 | ||
47 | // Perform a deep copy. | |
48 | AliHLTMUONCountedList(const AliHLTMUONCountedList& list) | |
49 | : AliHLTMUONList<DataType>(list), fCount(list.fCount) | |
50 | {} | |
51 | ||
52 | // Perform a deep copy. | |
53 | AliHLTMUONCountedList& operator = (const AliHLTMUONCountedList& list) | |
54 | { | |
55 | AliHLTMUONList<DataType>::operator = (list); | |
56 | fCount = list.fCount; | |
57 | return *this; | |
58 | } | |
59 | ||
60 | virtual ~AliHLTMUONCountedList() {} // Just to make gcc -Weffc++ option shutup. | |
61 | ||
62 | /** | |
63 | * Adds a new element to the start of the linked list. | |
64 | * @return The pointer to the new element to fill its fields. | |
65 | */ | |
66 | DataType* Add() | |
67 | { | |
68 | DataType* newdata = AliHLTMUONList<DataType>::Add(); | |
69 | fCount++; | |
70 | return newdata; | |
71 | } | |
72 | ||
73 | /** | |
74 | * Adds a new element to the start of the linked list and fills it with | |
75 | * the data specified in 'data'. | |
76 | * @param data The value to set the new element to. | |
77 | */ | |
78 | void Add(const DataType& data) | |
79 | { | |
80 | AliHLTMUONList<DataType>::Add(data); | |
81 | fCount++; | |
82 | } | |
83 | ||
84 | /** | |
85 | * Searches the list if the element 'data' is already in the list. If it | |
86 | * is then a pointer to the existing element is returned, otherwise a new | |
87 | * element is created and a pointer to it is returned. | |
88 | * @param data The value to search for or set the new element to. | |
89 | * @return A pointer to the existing or new element. | |
90 | */ | |
91 | DataType* AddUniquely(const DataType& data) | |
92 | { | |
93 | Iterator result = Find(data); | |
94 | if (result == ConstIterator(NULL)) | |
95 | { | |
96 | DataType* newdata = Add(); | |
97 | *newdata = data; | |
98 | return newdata; | |
99 | } | |
100 | else | |
101 | return result; | |
102 | } | |
103 | ||
104 | /** | |
105 | * Removes the index'th element from the list. | |
106 | * No error checking is done so there better be at least 'index' number | |
107 | * of entries in the list. You can use Count() to find out how many | |
108 | * entries there are. | |
109 | */ | |
110 | void Remove(const AliHLTUInt32_t index) | |
111 | { | |
112 | AliHLTMUONList<DataType>::Remove(index); | |
113 | fCount--; | |
114 | } | |
115 | ||
116 | /** | |
117 | * Looks for the entry with the same values as 'data' and removes it | |
118 | * from the list. If the entry could not be found then false is returned. | |
119 | * However if it is found then it is deleted and true is returned. | |
120 | */ | |
121 | bool Remove(const DataType& data) | |
122 | { | |
123 | Iterator current = Find(data); | |
124 | if ( current != ConstIterator(NULL) ) | |
125 | { | |
126 | Remove(current); | |
127 | return true; | |
128 | } | |
129 | else | |
130 | return false; | |
131 | } | |
132 | ||
133 | /** | |
134 | * Removes the entry pointed to by the iterator which must have been | |
135 | * extracted from the list with a call to First() and/or several calls | |
136 | * to the iterators increment operators. | |
137 | * @param iter The entry to remove from the list. | |
138 | */ | |
139 | void Remove(Iterator& iter) | |
140 | { | |
141 | AliHLTMUONList<DataType>::Remove(iter); | |
142 | fCount--; | |
143 | } | |
144 | ||
145 | /** | |
146 | * This deletes all elements from the list. | |
147 | */ | |
148 | void Clear() | |
149 | { | |
150 | AliHLTMUONList<DataType>::Clear(); | |
151 | fCount = 0; | |
152 | } | |
153 | ||
154 | /** | |
155 | * This deletes all elements from the list and resizes the buffer which | |
156 | * is used to store the entries for the list. | |
157 | */ | |
158 | void Clear(AliHLTUInt32_t maxentries) throw(std::bad_alloc) | |
159 | { | |
160 | AliHLTMUONList<DataType>::Clear(maxentries); | |
161 | fCount = 0; | |
162 | } | |
163 | ||
164 | /** | |
165 | * Counts and returns the number of elements in the list. | |
166 | */ | |
167 | AliHLTUInt32_t Count() const { return fCount; } | |
168 | ||
169 | protected: | |
170 | ||
171 | AliHLTUInt32_t fCount; | |
172 | }; | |
173 | ||
174 | ||
175 | #endif // ALIHLTMUONCOUNTEDLIST_H |