![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to OSArray.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / libkern / c++|
Return to OSArray.cpp CVS log | Up to [Apple XNU] / XNU / libkern / c++ |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /* IOArray.m created by rsulack on Fri 12-Sep-1997 */
23: /* IOArray.cpp converted to C++ by gvdl on Fri 1998-10-30 */
24:
25:
26: #include <libkern/c++/OSArray.h>
27: #include <libkern/c++/OSSerialize.h>
28: #include <libkern/c++/OSLib.h>
29:
30: #define super OSCollection
31:
32: OSDefineMetaClassAndStructors(OSArray, OSCollection)
33:
34:
35: #ifdef DEBUG
36: extern "C" {
37: extern int debug_container_malloc_size;
38: };
39: #define ACCUMSIZE(s) do { debug_container_malloc_size += (s); } while(0)
40: #else
41: #define ACCUMSIZE(s)
42: #endif
43:
44: bool OSArray::initWithCapacity(unsigned int inCapacity)
45: {
46: int size;
47:
48: if (!super::init())
49: return false;
50:
51: size = sizeof(OSObject *) * inCapacity;
52: array = (OSObject **) kalloc(size);
53: if (!array)
54: return false;
55:
56: count = 0;
57: capacity = inCapacity;
58: capacityIncrement = capacity;
59:
60: bzero(array, size);
61: ACCUMSIZE(size);
62:
63: return this;
64: }
65:
66: bool OSArray::initWithObjects(OSObject *objects[],
67: unsigned int theCount,
68: unsigned int theCapacity = 0)
69: {
70: unsigned int capacity = theCount;
71:
72: if ( theCapacity ) {
73: if ( theCount > theCapacity )
74: return false;
75:
76: capacity = theCapacity;
77: }
78:
79: if (!objects || !initWithCapacity(capacity))
80: return false;
81:
82: for ( unsigned int i = 0; i < theCount; i++ ) {
83: OSObject *newObject = *objects++;
84:
85: if (!newObject)
86: return false;
87:
88: array[count++] = newObject;
89: newObject->retain();
90: }
91:
92: return true;
93: }
94:
95: bool OSArray::initWithArray(const OSArray *anArray,
96: unsigned int theCapacity = 0)
97: {
98: if ( !anArray )
99: return false;
100:
101: return initWithObjects(anArray->array, anArray->count,
102: theCapacity);
103: }
104:
105: OSArray *OSArray::withCapacity(unsigned int capacity)
106: {
107: OSArray *me = new OSArray;
108:
109: if (me && !me->initWithCapacity(capacity)) {
110: me->free();
111: return 0;
112: }
113:
114: return me;
115: }
116:
117: OSArray *OSArray::withObjects(OSObject *objects[],
118: unsigned int count,
119: unsigned int capacity = 0)
120: {
121: OSArray *me = new OSArray;
122:
123: if (me && !me->initWithObjects(objects, count, capacity)) {
124: me->free();
125: return 0;
126: }
127:
128: return me;
129: }
130:
131: OSArray *OSArray::withArray(const OSArray *array,
132: unsigned int capacity = 0)
133: {
134: OSArray *me = new OSArray;
135:
136: if (me && !me->initWithArray(array, capacity)) {
137: me->free();
138: return 0;
139: }
140:
141: return me;
142: }
143:
144: void OSArray::free()
145: {
146: flushCollection();
147:
148: if (array) {
149: kfree((vm_offset_t)array, sizeof(OSObject *) * capacity);
150: ACCUMSIZE( -(sizeof(OSObject *) * capacity) );
151: }
152:
153: super::free();
154: }
155:
156:
157: unsigned int OSArray::getCount() const { return count; }
158: unsigned int OSArray::getCapacity() const { return capacity; }
159: unsigned int OSArray::getCapacityIncrement() const { return capacityIncrement; }
160: unsigned int OSArray::setCapacityIncrement(unsigned int increment)
161: {
162: return capacityIncrement = increment;
163: }
164:
165: unsigned int OSArray::ensureCapacity(unsigned int newCapacity)
166: {
167: OSObject **newArray;
168: int oldSize, newSize;
169:
170: if (!capacityIncrement || newCapacity <= capacity)
171: return capacity;
172:
173: // round up
174: newCapacity = (((newCapacity - 1) / capacityIncrement) + 1)
175: * capacityIncrement;
176: newSize = sizeof(OSObject *) * newCapacity;
177:
178: newArray = (OSObject **) kalloc(newSize);
179: if (newArray) {
180: oldSize = sizeof(OSObject *) * capacity;
181:
182: ACCUMSIZE(newSize - oldSize);
183:
184: bcopy(array, newArray, oldSize);
185: bzero(&newArray[capacity], newSize - oldSize);
186: kfree((vm_offset_t)array, oldSize);
187: array = newArray;
188: capacity = newCapacity;
189: }
190:
191: return capacity;
192: }
193:
194: void OSArray::flushCollection()
195: {
196: unsigned int i;
197:
198: haveUpdated();
199: for (i = 0; i < count; i++)
200: array[i]->release();
201: count = 0;
202: }
203:
204: bool OSArray::setObject(OSObject *anObject)
205: {
206: return setObject(count, anObject);
207: }
208:
209: bool OSArray::setObject(unsigned int index, OSObject *anObject)
210: {
211: unsigned int i;
212: unsigned int newCount = count + 1;
213:
214: if ((index > count) || !anObject)
215: return false;
216:
217: // do we need more space?
218: if (newCount > capacity && newCount > ensureCapacity(newCount))
219: return false;
220:
221: haveUpdated();
222: if (index != count) {
223: for (i = count; i > index; i--)
224: array[i] = array[i-1];
225: }
226: array[index] = anObject;
227: anObject->retain();
228: count++;
229:
230: return true;
231: }
232:
233: bool OSArray::merge(const OSArray * otherArray)
234: {
235: unsigned int otherCount = otherArray->getCount();
236: unsigned int newCount = count + otherCount;
237:
238: if (!otherCount)
239: return true;
240:
241: // do we need more space?
242: if (newCount > capacity && newCount > ensureCapacity(newCount))
243: return false;
244:
245: haveUpdated();
246: for (unsigned int i = 0; i < otherCount; i++) {
247: OSObject *newObject = otherArray->getObject(i);
248:
249: array[count++] = newObject;
250: newObject->retain();
251: }
252:
253: return true;
254: }
255:
256: void OSArray::replaceObject(unsigned int index, OSObject *anObject)
257:
258: {
259: OSObject *oldObject;
260:
261: if ((index >= count) || !anObject)
262: return;
263:
264: haveUpdated();
265: oldObject = array[index];
266: array[index] = anObject;
267: anObject->retain();
268:
269: oldObject->release();
270: }
271:
272: void OSArray::removeObject(unsigned int index)
273: {
274: unsigned int i;
275: OSObject *oldObject;
276:
277: if (index >= count)
278: return;
279:
280: haveUpdated();
281: oldObject = array[index];
282:
283: count--;
284: for (i = index; i < count; i++)
285: array[i] = array[i+1];
286:
287: oldObject->release();
288: }
289:
290: bool OSArray::isEqualTo(OSArray *anArray) const
291: {
292: unsigned int i;
293:
294: if ( this == anArray )
295: return true;
296:
297: if ( count != anArray->getCount() )
298: return false;
299:
300: for ( i = 0; i < count; i++ ) {
301: if ( !array[i]->isEqualTo(anArray->getObject(i)) )
302: return false;
303: }
304:
305: return true;
306: }
307:
308: bool OSArray::isEqualTo(const OSObject *anObject) const
309: {
310: OSArray *otherArray;
311:
312: otherArray = OSDynamicCast(OSArray, (OSObject *)anObject);
313: if ( otherArray )
314: return isEqualTo(otherArray);
315: else
316: return false;
317: }
318:
319: OSObject *OSArray::getObject(unsigned int index) const
320: {
321: if (index >= count)
322: return 0;
323: else
324: return array[index];
325: }
326:
327: OSObject *OSArray::lastObject() const
328: {
329: if (count == 0)
330: return 0;
331: else
332: return array[count - 1];
333: }
334:
335: unsigned int OSArray::getNextIndexOfObject(OSObject * anObject,
336: unsigned int index) const
337: {
338: while ((index < count) && (array[index] != anObject))
339: {}
340: if (index >= count)
341: index = (unsigned int)-1;
342: return index;
343: }
344:
345: unsigned int OSArray::iteratorSize() const
346: {
347: return sizeof(unsigned int);
348: }
349:
350: bool OSArray::initIterator(void *inIterator) const
351: {
352: unsigned int *iteratorP = (unsigned int *) inIterator;
353:
354: *iteratorP = 0;
355: return true;
356: }
357:
358: bool OSArray::getNextObjectForIterator(void *inIterator, OSObject **ret) const
359: {
360: unsigned int *iteratorP = (unsigned int *) inIterator;
361: unsigned int index = (*iteratorP)++;
362:
363: if (index < count) {
364: *ret = array[index];
365: return true;
366: }
367: else {
368: *ret = 0;
369: return false;
370: }
371: }
372:
373: bool OSArray::serialize(OSSerialize *s) const
374: {
375: if (s->previouslySerialized(this)) return true;
376:
377: if (!s->addXMLStartTag(this, "array")) return false;
378:
379: for (unsigned i = 0; i < count; i++) {
380: if (!array[i]->serialize(s)) return false;
381: }
382:
383: return s->addXMLEndTag("array");
384: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.