1 mike 1.2 //%2006////////////////////////////////////////////////////////////////////////
2 //
3 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
4 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
5 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
6 // IBM Corp.; EMC Corporation, The Open Group.
7 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
8 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
9 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
10 // EMC Corporation; VERITAS Software Corporation; The Open Group.
11 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
12 // EMC Corporation; Symantec Corporation; The Open Group.
13 //
14 // Permission is hereby granted, free of charge, to any person obtaining a copy
15 // of this software and associated documentation files (the "Software"), to
16 // deal in the Software without restriction, including without limitation the
17 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
18 // sell copies of the Software, and to permit persons to whom the Software is
19 // furnished to do so, subject to the following conditions:
20 //
21 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
22 mike 1.2 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
23 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
24 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
25 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
26 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
27 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 //
30 //==============================================================================
31 //
32 //%/////////////////////////////////////////////////////////////////////////////
33
34 #include "List.h"
35 #include "PegasusAssert.h"
36
37 PEGASUS_NAMESPACE_BEGIN
38
|
39 kumpf 1.3 ListRep::ListRep(void (*destructor)(Linkable*))
40 : _front(0), _back(0), _size(0)
|
41 mike 1.2 {
42 if (destructor)
|
43 kumpf 1.3 _destructor = destructor;
|
44 mike 1.2 else
|
45 kumpf 1.3 _destructor = 0;
|
46 mike 1.2 }
47
48 ListRep::~ListRep()
49 {
50 PEGASUS_DEBUG_ASSERT(_magic);
51
52 clear();
53 #ifdef PEGASUS_DEBUG
54 memset(this, 0xDD, sizeof(ListRep));
55 #endif
56 }
57
58 void ListRep::clear()
59 {
60 PEGASUS_DEBUG_ASSERT(_magic);
61
62 if (_destructor)
63 {
|
64 kumpf 1.3 // Reset _front, _back, and _size in case the destructor calls
65 // a method of List.
|
66 mike 1.2
|
67 kumpf 1.3 Linkable* front = _front;
68 Linkable* back = _back;
|
69 kumpf 1.4 Uint32 size = _size;
|
70 kumpf 1.3
71 _front = 0;
72 _back = 0;
73 _size = 0;
74
75 for (Linkable* p = front; p; )
76 {
77 PEGASUS_DEBUG_ASSERT(p->magic);
78 Linkable* next = p->next;
79 p->list = 0;
80 _destructor(p);
81 p = next;
82 }
|
83 mike 1.2 }
84 }
85
86 void ListRep::insert_front(Linkable* elem)
87 {
88 PEGASUS_DEBUG_ASSERT(_magic);
89 PEGASUS_DEBUG_ASSERT(elem != 0);
90 PEGASUS_DEBUG_ASSERT(elem->magic);
91 PEGASUS_DEBUG_ASSERT(elem->list == 0);
92
93 elem->list = this;
94 elem->next = _front;
95 elem->prev = 0;
96
97 if (_front)
|
98 kumpf 1.3 _front->prev = elem;
|
99 mike 1.2 else
|
100 kumpf 1.3 _back = elem;
|
101 mike 1.2
102 _front = elem;
103 _size++;
104 }
105
106 void ListRep::insert_back(Linkable* elem)
107 {
108 PEGASUS_DEBUG_ASSERT(_magic);
109 PEGASUS_DEBUG_ASSERT(elem != 0);
110 PEGASUS_DEBUG_ASSERT(elem->magic);
111 PEGASUS_DEBUG_ASSERT(elem->list == 0);
112
113 elem->list = this;
114 elem->prev = _back;
115 elem->next = 0;
116
117 if (_back)
|
118 kumpf 1.3 _back->next = elem;
|
119 mike 1.2 else
|
120 kumpf 1.3 _front = elem;
|
121 mike 1.2
122 _back = elem;
123 _size++;
124 }
125
126 void ListRep::insert_after(
|
127 kumpf 1.3 Linkable* pos,
|
128 mike 1.2 Linkable* elem)
129 {
130 PEGASUS_DEBUG_ASSERT(_magic);
131 PEGASUS_DEBUG_ASSERT(pos != 0);
132 PEGASUS_DEBUG_ASSERT(elem != 0);
133 PEGASUS_DEBUG_ASSERT(elem->magic);
134 PEGASUS_DEBUG_ASSERT(pos->magic);
135 PEGASUS_DEBUG_ASSERT(elem->list == 0);
136
137 elem->list = this;
138 elem->prev = pos;
139 elem->next = pos->next;
140
141 if (pos->next)
|
142 kumpf 1.3 pos->next->prev = elem;
|
143 mike 1.2
144 pos->next = elem;
145
146 if (pos == _back)
|
147 kumpf 1.3 _back = elem;
|
148 mike 1.2
149 _size++;
150 }
151
152 void ListRep::insert_before(
|
153 kumpf 1.3 Linkable* pos,
|
154 mike 1.2 Linkable* elem)
155 {
156 PEGASUS_DEBUG_ASSERT(_magic);
157 PEGASUS_DEBUG_ASSERT(pos != 0);
158 PEGASUS_DEBUG_ASSERT(elem != 0);
159 PEGASUS_DEBUG_ASSERT(pos->magic);
160 PEGASUS_DEBUG_ASSERT(elem->magic);
161 PEGASUS_DEBUG_ASSERT(elem->list == 0);
162
163 elem->list = this;
164 elem->next = pos;
165 elem->prev = pos->prev;
166
167 if (pos->prev)
|
168 kumpf 1.3 pos->prev->next = elem;
|
169 mike 1.2
170 pos->prev = elem;
171
172 if (pos == _front)
|
173 kumpf 1.3 _front = elem;
|
174 mike 1.2
175 _size++;
176 }
177
178 void ListRep::remove(Linkable* pos)
179 {
180 PEGASUS_DEBUG_ASSERT(_magic);
181 PEGASUS_DEBUG_ASSERT(pos != 0);
182 PEGASUS_DEBUG_ASSERT(pos->magic);
183 PEGASUS_DEBUG_ASSERT(pos->list == this);
184 PEGASUS_DEBUG_ASSERT(_size != 0);
185
186 if (_size == 0)
|
187 kumpf 1.3 return;
|
188 mike 1.2
189 if (pos->prev)
|
190 kumpf 1.3 pos->prev->next = pos->next;
|
191 mike 1.2
192 if (pos->next)
|
193 kumpf 1.3 pos->next->prev = pos->prev;
|
194 mike 1.2
195 if (pos == _front)
|
196 kumpf 1.3 _front = pos->next;
|
197 mike 1.2
198 if (pos == _back)
|
199 kumpf 1.3 _back = pos->prev;
|
200 mike 1.2
201 pos->list = 0;
202
203 _size--;
204 }
205
206 bool ListRep::contains(const Linkable* elem)
207 {
208 PEGASUS_DEBUG_ASSERT(_magic);
209 PEGASUS_DEBUG_ASSERT(elem != 0);
210 PEGASUS_DEBUG_ASSERT(elem->magic);
211
212 for (const Linkable* p = _front; p; p = p->next)
213 {
|
214 kumpf 1.3 if (p == elem)
215 return true;
|
216 mike 1.2 }
217
218 // Not found!
219 return false;
220 }
221
222 Linkable* ListRep::remove_front()
223 {
224 PEGASUS_DEBUG_ASSERT(_magic);
225
226 if (_size == 0)
|
227 kumpf 1.3 return 0;
|
228 mike 1.2
229 Linkable* elem = _front;
230 remove(elem);
231
232 return elem;
233 }
234
235 Linkable* ListRep::remove_back()
236 {
237 PEGASUS_DEBUG_ASSERT(_magic);
238 PEGASUS_DEBUG_ASSERT(_size > 0);
239
240 Linkable* elem = _back;
241 remove(elem);
242
243 return elem;
244 }
245
246 Linkable* ListRep::find(ListRep::Equal equal, const void* client_data)
247 {
248 PEGASUS_DEBUG_ASSERT(_magic);
249 mike 1.2 PEGASUS_DEBUG_ASSERT(equal != 0);
250
251 for (Linkable* p = _front; p; p = p->next)
252 {
|
253 kumpf 1.3 if ((*equal)(p, client_data))
254 {
255 PEGASUS_DEBUG_ASSERT(p->magic);
256 return p;
257 }
|
258 mike 1.2 }
259
260 // Not found!
261 return 0;
262 }
263
264 Linkable* ListRep::remove(ListRep::Equal equal, const void* client_data)
265 {
266 PEGASUS_DEBUG_ASSERT(_magic);
267 PEGASUS_DEBUG_ASSERT(equal != 0);
268
269 Linkable* p = find(equal, client_data);
270
271 if (p)
272 {
|
273 kumpf 1.3 PEGASUS_DEBUG_ASSERT(p->magic);
274 remove(p);
|
275 mike 1.2 }
276
277 return p;
278 }
279
280 void ListRep::apply(ListRep::Apply apply, const void* client_data)
281 {
282 PEGASUS_DEBUG_ASSERT(_magic);
283 PEGASUS_DEBUG_ASSERT(apply != 0);
284
285 for (Linkable* p = _front; p; p = p->next)
|
286 kumpf 1.3 (*apply)(p, client_data);
|
287 mike 1.2 }
288
289 PEGASUS_NAMESPACE_END
|
Return to
List.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common