Line data Source code
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 0 : AliHLTMUONList<DataType>(maxentries), fCount(0)
45 0 : {}
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 0 : 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 0 : DataType* newdata = AliHLTMUONList<DataType>::Add();
69 0 : fCount++;
70 0 : 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 0 : AliHLTMUONList<DataType>::Clear();
151 0 : fCount = 0;
152 0 : }
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 0 : AliHLTUInt32_t Count() const { return fCount; }
168 :
169 : protected:
170 :
171 : AliHLTUInt32_t fCount;
172 : };
173 :
174 :
175 : #endif // ALIHLTMUONCOUNTEDLIST_H
|
