libkern/c++/OSSet.cpp

   1 /*
   2  * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28 /* IOSet.m created by rsulack on Thu 11-Jun-1998 */
  29
  30 #include <libkern/c++/OSDictionary.h>
  31 #include <libkern/c++/OSArray.h>
  32 #include <libkern/c++/OSSerialize.h>
  33 #include <libkern/c++/OSSet.h>
  34
  35 #define super OSCollection
  36
  37 OSDefineMetaClassAndStructors(OSSet, OSCollection)
  38 OSMetaClassDefineReservedUnused(OSSet, 0);
  39 OSMetaClassDefineReservedUnused(OSSet, 1);
  40 OSMetaClassDefineReservedUnused(OSSet, 2);
  41 OSMetaClassDefineReservedUnused(OSSet, 3);
  42 OSMetaClassDefineReservedUnused(OSSet, 4);
  43 OSMetaClassDefineReservedUnused(OSSet, 5);
  44 OSMetaClassDefineReservedUnused(OSSet, 6);
  45 OSMetaClassDefineReservedUnused(OSSet, 7);
  46
  47 #define EXT_CAST(obj) \
  48     reinterpret_cast<OSObject *>(const_cast<OSMetaClassBase *>(obj))
  49
  50 bool OSSet::initWithCapacity(unsigned int inCapacity)
  51 {
  52     if ( !super::init() )
  53         return false;
  54
  55     members = OSArray::withCapacity(inCapacity);
  56     if (!members)
  57         return false;
  58
  59     return true;
  60 }
  61
  62 bool OSSet::initWithObjects(const OSObject *inObjects[],
  63                               unsigned int inCount,
  64                               unsigned int inCapacity)
  65 {
  66     unsigned int capacity = inCount;
  67
  68     if ( inCapacity ) {
  69         if ( inCount > inCapacity )
  70             return false;
  71
  72         capacity = inCapacity;
  73     }
  74
  75     if (!inObjects || !initWithCapacity(capacity))
  76         return false;
  77
  78     for ( unsigned int i = 0; i < inCount; i++ ) {
  79 // xx-review: no test here for failure of setObject()
  80         if (members->getCount() < inCapacity)
  81             setObject(inObjects[i]);
  82         else
  83             return false;
  84     }
  85
  86     return true;
  87 }
  88
  89 bool OSSet::initWithArray(const OSArray *inArray,
  90                           unsigned int inCapacity)
  91 {
  92     if ( !inArray )
  93         return false;
  94
  95     return initWithObjects((const OSObject **) inArray->array,
  96                            inArray->count, inCapacity);
  97 }
  98
  99 bool OSSet::initWithSet(const OSSet *inSet,
 100                         unsigned int inCapacity)
 101 {
 102     return initWithArray(inSet->members, inCapacity);
 103 }
 104
 105 OSSet *OSSet::withCapacity(unsigned int capacity)
 106 {
 107     OSSet *me = new OSSet;
 108
 109     if (me && !me->initWithCapacity(capacity)) {
 110         me->release();
 111         return 0;
 112     }
 113
 114     return me;
 115 }
 116
 117 OSSet *OSSet::withObjects(const OSObject *objects[],
 118                           unsigned int count,
 119                           unsigned int capacity)
 120 {
 121     OSSet *me = new OSSet;
 122
 123     if (me && !me->initWithObjects(objects, count, capacity)) {
 124         me->release();
 125         return 0;
 126     }
 127
 128     return me;
 129 }
 130
 131 OSSet *OSSet::withArray(const OSArray *array,
 132                         unsigned int capacity)
 133 {
 134     OSSet *me = new OSSet;
 135
 136     if (me && !me->initWithArray(array, capacity)) {
 137         me->release();
 138         return 0;
 139     }
 140
 141     return me;
 142 }
 143
 144 OSSet *OSSet::withSet(const OSSet *set,
 145                       unsigned int capacity)
 146 {
 147     OSSet *me = new OSSet;
 148
 149     if (me && !me->initWithSet(set, capacity)) {
 150         me->release();
 151         return 0;
 152     }
 153
 154     return me;
 155 }
 156
 157 void OSSet::free()
 158 {
 159     (void) members->super::setOptions(0, kImmutable);
 160     if (members)
 161         members->release();
 162
 163     super::free();
 164 }
 165
 166 unsigned int OSSet::getCount() const
 167 {
 168     return members->count;
 169 }
 170
 171 unsigned int OSSet::getCapacity() const
 172 {
 173     return members->capacity;
 174 }
 175
 176 unsigned int OSSet::getCapacityIncrement() const
 177 {
 178     return members->capacityIncrement;
 179 }
 180
 181 unsigned int OSSet::setCapacityIncrement(unsigned int increment)
 182 {
 183     return members->setCapacityIncrement(increment);
 184 }
 185
 186 unsigned int OSSet::ensureCapacity(unsigned int newCapacity)
 187 {
 188     return members->ensureCapacity(newCapacity);
 189 }
 190
 191 void OSSet::flushCollection()
 192 {
 193     haveUpdated();
 194     members->flushCollection();
 195 }
 196
 197 bool OSSet::setObject(const OSMetaClassBase *anObject)
 198 {
 199     if (containsObject(anObject))
 200         return false;
 201     else {
 202         haveUpdated();
 203         return members->setObject(anObject);
 204     }
 205 }
 206
 207 bool OSSet::merge(const OSArray *array)
 208 {
 209     const OSMetaClassBase *anObject;
 210     bool retVal = false;
 211
 212 // xx-review: if any setObject fails due to memory allocation failure,
 213 // xx-review: this function should return false
 214     for (int i = 0; (anObject = array->getObject(i)); i++)
 215         if (setObject(anObject))
 216             retVal = true;
 217
 218     return retVal;
 219 }
 220
 221 bool OSSet::merge(const OSSet *set)
 222 {
 223     return merge(set->members);
 224 }
 225
 226 void OSSet::removeObject(const OSMetaClassBase *anObject)
 227 {
 228     const OSMetaClassBase *probeObject;
 229
 230     for (int i = 0; (probeObject = members->getObject(i)); i++)
 231         if (probeObject == anObject) {
 232             haveUpdated();
 233             members->removeObject(i);
 234             return;
 235         }
 236 }
 237
 238
 239 bool OSSet::containsObject(const OSMetaClassBase *anObject) const
 240 {
 241     return anObject && member(anObject);
 242 }
 243
 244 bool OSSet::member(const OSMetaClassBase *anObject) const
 245 {
 246     OSMetaClassBase *probeObject;
 247
 248     for (int i = 0; (probeObject = members->getObject(i)); i++)
 249         if (probeObject == anObject)
 250             return true;
 251
 252     return false;
 253 }
 254
 255 OSObject *OSSet::getAnyObject() const
 256 {
 257     return members->getObject(0);
 258 }
 259
 260 bool OSSet::isEqualTo(const OSSet *aSet) const
 261 {
 262     unsigned int count;
 263     unsigned int i;
 264     const OSMetaClassBase *obj1;
 265     const OSMetaClassBase *obj2;
 266
 267     if ( this == aSet )
 268         return true;
 269
 270     count = members->count;
 271     if ( count != aSet->getCount() )
 272         return false;
 273
 274     for ( i = 0; i < count; i++ ) {
 275         obj1 = aSet->members->getObject(i);
 276         obj2 = members->getObject(i);
 277         if ( !obj1 || !obj2 )
 278                 return false;
 279
 280         if ( !obj1->isEqualTo(obj2) )
 281             return false;
 282     }
 283
 284     return true;
 285 }
 286
 287 bool OSSet::isEqualTo(const OSMetaClassBase *anObject) const
 288 {
 289     OSSet *otherSet;
 290
 291     otherSet = OSDynamicCast(OSSet, anObject);
 292     if ( otherSet )
 293         return isEqualTo(otherSet);
 294     else
 295         return false;
 296 }
 297
 298 unsigned int OSSet::iteratorSize() const
 299 {
 300     return sizeof(unsigned int);
 301 }
 302
 303 bool OSSet::initIterator(void *inIterator) const
 304 {
 305     unsigned int *iteratorP = (unsigned int *) inIterator;
 306
 307     *iteratorP = 0;
 308     return true;
 309 }
 310
 311 bool OSSet::getNextObjectForIterator(void *inIterator, OSObject **ret) const
 312 {
 313     unsigned int *iteratorP = (unsigned int *) inIterator;
 314     unsigned int index = (*iteratorP)++;
 315
 316     if (index < members->count)
 317         *ret = members->getObject(index);
 318     else
 319         *ret = 0;
 320
 321     return (*ret != 0);
 322 }
 323
 324 bool OSSet::serialize(OSSerialize *s) const
 325 {
 326     const OSMetaClassBase *o;
 327
 328     if (s->previouslySerialized(this)) return true;
 329
 330     if (!s->addXMLStartTag(this, "set")) return false;
 331
 332     for (int i = 0; (o = members->getObject(i)); i++) {
 333         if (!o->serialize(s)) return false;
 334     }
 335
 336     return s->addXMLEndTag("set");
 337 }
 338
 339 unsigned OSSet::setOptions(unsigned options, unsigned mask, void *)
 340 {
 341     unsigned old = super::setOptions(options, mask);
 342     if ((old ^ options) & mask)
 343         members->setOptions(options, mask);
 344
 345     return old;
 346 }
 347
 348 OSCollection * OSSet::copyCollection(OSDictionary *cycleDict)
 349 {
 350     bool allocDict = !cycleDict;
 351     OSCollection *ret = 0;
 352     OSSet *newSet = 0;
 353
 354     if (allocDict) {
 355         cycleDict = OSDictionary::withCapacity(16);
 356         if (!cycleDict)
 357             return 0;
 358     }
 359
 360     do {
 361         // Check for a cycle
 362         ret = super::copyCollection(cycleDict);
 363         if (ret)
 364             continue;   // Found it
 365
 366         newSet = OSSet::withCapacity(members->capacity);
 367         if (!newSet)
 368             continue;   // Couldn't create new set abort
 369
 370         // Insert object into cycle Dictionary
 371         cycleDict->setObject((const OSSymbol *) this, newSet);
 372
 373         OSArray *newMembers = newSet->members;
 374         newMembers->capacityIncrement = members->capacityIncrement;
 375
 376         // Now copy over the contents into the new duplicate
 377         for (unsigned int i = 0; i < members->count; i++) {
 378             OSObject *obj = EXT_CAST(members->array[i]);
 379             OSCollection *coll = OSDynamicCast(OSCollection, obj);
 380             if (coll) {
 381                 OSCollection *newColl = coll->copyCollection(cycleDict);
 382                 if (newColl) {
 383                     obj = newColl;      // Rely on cycleDict ref for a bit
 384                     newColl->release();
 385                 }
 386                 else
 387                     goto abortCopy;
 388             };
 389             newMembers->setObject(obj);
 390         };
 391
 392         ret = newSet;
 393         newSet = 0;
 394
 395     } while(false);
 396
 397 abortCopy:
 398     if (newSet)
 399         newSet->release();
 400
 401     if (allocDict)
 402         cycleDict->release();
 403
 404     return ret;
 405 }