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 29#ifndef _OS_OSORDEREDSET_H 30#define _OS_OSORDEREDSET_H 31 32#include <libkern/c++/OSCollection.h> 33#include <libkern/OSTypes.h> 34 35class OSOffset; 36 37/*! 38 * @header 39 * 40 * @abstract 41 * This header declares the OSOrderedSet collection class. 42 */ 43 44 45/*! 46 * @class OSOrderedSet 47 * 48 * @abstract 49 * OSOrderedSet provides an ordered set store of objects. 50 * 51 * @discussion 52 * OSOrderedSet is a container for Libkern C++ objects 53 * (those derived from 54 * @link //apple_ref/doc/class/OSMetaClassBase OSMetaClassBase@/link, 55 * in particular @link //apple_ref/doc/class/OSObject OSObject@/link). 56 * Storage and access follow ordered set logic. 57 * A given object is stored in the set only once, but you can: 58 * <ul> 59 * <li>Define a sorting function for automated ordering 60 * (upon addition only)</li> 61 * <li>Manually insert new objects in the set (overriding sorting)</li> 62 * <li>Add and remove objects in the set</li> 63 * <li>Test whether the set contains a particular object</li> 64 * <li>Get the object stored at a particular index.</li> 65 * </ol> 66 * 67 * Note that automated ordering is performed only upon addition of objects 68 * and depends on the existing objects being properly sorted. 69 * There is no function to re-sort the contents of an OSOrderedSet 70 * or to change the ordering function. 71 * In general, you should either use the one ordered-insertion function, 72 * or the indexed-insertion functions, and not mix the two. 73 * 74 * As with all Libkern collection classes, 75 * OSOrderedSet retains objects added to it, 76 * and releases objects removed from it. 77 * An OSOrderedSet also grows as necessary to accommodate new objects, 78 * <i>unlike</i> Core Foundation collections (it does not, however, shrink). 79 * 80 * <b>Use Restrictions</b> 81 * 82 * With very few exceptions in the I/O Kit, all Libkern-based C++ 83 * classes, functions, and macros are <b>unsafe</b> 84 * to use in a primary interrupt context. 85 * Consult the I/O Kit documentation related to primary interrupts 86 * for more information. 87 * 88 * OSOrderedSet provides no concurrency protection; 89 * it's up to the usage context to provide any protection necessary. 90 * Some portions of the I/O Kit, such as 91 * @link //apple_ref/doc/class/IORegistryEntry IORegistryEntry@/link, 92 * handle synchronization via defined member functions for setting 93 * properties. 94 */ 95class OSOrderedSet : public OSCollection 96{ 97 OSDeclareDefaultStructors(OSOrderedSet) 98 99public: 100 /*! 101 * @typedef OSOrderFunction 102 * 103 * @abstract 104 * The sorting function used by an OSOrderedSet to order objects. 105 * 106 * @param obj1 An object from the ordered set. May be <code>NULL</code>. 107 * @param obj2 The object being ordered within the ordered set. 108 * May be <code>NULL</code>. 109 * @param context A pointer to a user-provided context. May be <code>NULL</code>. 110 * 111 * @result 112 * A comparison result of the object: 113 * <ul> 114 * <li>a negative value if obj2 should precede obj1,</li> 115 * <li>a positive value if obj1 should precede obj2,</li> 116 * <li>and 0 if obj1 and obj2 have an equivalent ordering.</li> 117 * </ul> 118 */ 119 typedef SInt32 (*OSOrderFunction)(const OSMetaClassBase * obj1, 120 const OSMetaClassBase * obj2, 121 void * context); 122 123protected: 124 struct _Element * array; 125 OSOrderFunction ordering; 126 void * orderingRef; 127 unsigned int count; 128 unsigned int capacity; 129 unsigned int capacityIncrement; 130 131 struct ExpansionData { }; 132 133 /* Reserved for future use. (Internal use only) */ 134 ExpansionData *reserved; 135 136protected: 137 /* OSCollectionIterator interfaces. */ 138 virtual unsigned int iteratorSize() const; 139 virtual bool initIterator(void *iterator) const; 140 virtual bool getNextObjectForIterator(void *iterator, OSObject **ret) const; 141 142public: 143 144 /*! 145 * @function withCapacity 146 * 147 * @abstract 148 * Creates and initializes an empty OSOrderedSet. 149 * 150 * @param capacity The initial storage capacity 151 * of the new ordered set object. 152 * @param orderFunc A C function that implements the sorting algorithm 153 * for the set. 154 * @param orderingContext An ordering context, 155 * which is passed to <code>orderFunc</code>. 156 * @result 157 * An empty instance of OSOrderedSet 158 * with a retain count of 1; 159 * <code>NULL</code> on failure. 160 * 161 * @discussion 162 * <code>capacity</code> must be nonzero. 163 * The new OSOrderedSet will grow as needed 164 * to accommodate more key/object pairs 165 * (<i>unlike</i> Core Foundation collections, 166 * for which the initial capacity is a hard limit). 167 * 168 * If <code>orderFunc</code> is provided, it is used by 169 * <code>@link 170 * //apple_ref/cpp/instm/OSOrderedSet/setObject/virtualbool/(constOSMetaClassBase*) 171 * setObject(const OSMetaClassBase *)@/link</code> 172 * to determine where to insert a new object. 173 * Other object-setting functions ignore ordering. 174 * 175 * <code>orderingContext</code> is not retained or otherwise memory-managed 176 * by the ordered set. 177 * If it needs to be deallocated, 178 * you must track references to it and the ordered set 179 * in order to deallocate it appropriately. 180 * See 181 * <code>@link getOrderingRef getOrderingRef@/link</code>. 182 */ 183 static OSOrderedSet * withCapacity( 184 unsigned int capacity, 185 OSOrderFunction orderFunc = 0, 186 void * orderingContext = 0); 187 188 189 /*! 190 * @function initWithCapacity 191 * 192 * @abstract 193 * Initializes a new instance of OSOrderedSet. 194 * 195 * @param capacity The initial storage capacity 196 * of the new ordered set object. 197 * @param orderFunc A C function that implements the sorting algorithm 198 * for the set. 199 * @param orderingContext An ordering context, 200 * which is passed to <code>orderFunc</code>. 201 * 202 * @result 203 * <code>true</code> on success, <code>false</code> on failure. 204 * 205 * @discussion 206 * Not for general use. Use the static instance creation method 207 * <code>@link 208 * //apple_ref/cpp/clm/OSOrderedSet/withCapacity/staticOSOrderedSet*\/(unsignedint,OSOrderFunction,void*) 209 * withCapacity@/link</code> 210 * instead. 211 * 212 * <code>capacity</code> must be nonzero. 213 * The new set will grow as needed to accommodate more key/object pairs 214 * (<i>unlike</i> Core Foundation collections, 215 * for which the initial capacity is a hard limit). 216 * 217 * If <code>orderFunc</code> is provided, it is used by 218 * <code>@link 219 * //apple_ref/cpp/instm/OSOrderedSet/setObject/virtualbool/(constOSMetaClassBase*) 220 * setObject(const OSMetaClassBase *)@/link</code> 221 * to determine where to insert a new object. 222 * Other object-setting functions ignore ordering. 223 * 224 * <code>orderingContext</code> is not retained or otherwise memory-managed 225 * by the ordered set. 226 * If it needs to be deallocated, 227 * you must track references to it and the ordered set 228 * in order to deallocate it appropriately. 229 * See 230 * <code>@link getOrderingRef getOrderingRef@/link</code>. 231 */ 232 virtual bool initWithCapacity( 233 unsigned int capacity, 234 OSOrderFunction orderFunc = 0, 235 void * orderingContext = 0); 236 237 238 /*! 239 * @function free 240 * 241 * @abstract 242 * Deallocatesand releases any resources 243 * used by the OSOrderedSet instance. 244 * 245 * @discussion 246 * This function should not be called directly; 247 * use 248 * <code>@link 249 * //apple_ref/cpp/instm/OSObject/release/virtualvoid/() 250 * release@/link</code> 251 * instead. 252 */ 253 virtual void free(); 254 255 256 /*! 257 * @function getCount 258 * 259 * @abstract 260 * Returns the current number of objects within the ordered set. 261 * 262 * @result 263 * The current number of objects within the ordered set. 264 */ 265 virtual unsigned int getCount() const; 266 267 268 /*! 269 * @function getCapacity 270 * 271 * @abstract 272 * Returns the number of objects the ordered set 273 * can store without reallocating. 274 * 275 * @result 276 * The number objects the ordered set 277 * can store without reallocating. 278 * 279 * @discussion 280 * OSOrderedSet objects grow when full to accommodate additional objects. 281 * See 282 * <code>@link 283 * //apple_ref/cpp/instm/OSOrderedSet/getCapacityIncrement/virtualunsignedint/() 284 * getCapacityIncrement@/link</code> 285 * and 286 * <code>@link 287 * //apple_ref/cpp/instm/OSOrderedSet/ensureCapacity/virtualunsignedint/(unsignedint) 288 * ensureCapacity@/link</code>. 289 */ 290 virtual unsigned int getCapacity() const; 291 292 293 /*! 294 * @function getCapacityIncrement 295 * 296 * @abstract 297 * Returns the storage increment of the ordered set. 298 * 299 * @result 300 * The storage increment of the ordered set. 301 * 302 * @discussion 303 * An OSOrderedSet allocates storage for objects in multiples 304 * of the capacity increment. 305 */ 306 virtual unsigned int getCapacityIncrement() const; 307 308 309 /*! 310 * @function setCapacityIncrement 311 * 312 * @abstract 313 * Sets the storage increment of the ordered set. 314 * 315 * @result 316 * The new storage increment of the ordered set, 317 * which may be different from the number requested. 318 * 319 * @discussion 320 * An OSOrderedSet allocates storage for objects in multiples 321 * of the capacity increment. 322 * Calling this function does not immediately reallocate storage. 323 */ 324 virtual unsigned int setCapacityIncrement(unsigned increment); 325 326 327 /*! 328 * @function ensureCapacity 329 * 330 * @abstract 331 * Ensures the set has enough space 332 * to store the requested number of distinct objects. 333 * 334 * @param newCapacity The total number of distinct objects the ordered set 335 * should be able to store. 336 * 337 * @result 338 * The new capacity of the ordered set, 339 * which may be different from the number requested 340 * (if smaller, reallocation of storage failed). 341 * 342 * @discussion 343 * This function immediately resizes the ordered set, if necessary, 344 * to accommodate at least <code>newCapacity</code> distinct objects. 345 * If <code>newCapacity</code> is not greater than the current capacity, 346 * or if an allocation error occurs, the original capacity is returned. 347 * 348 * There is no way to reduce the capacity of an OSOrderedSet. 349 */ 350 virtual unsigned int ensureCapacity(unsigned int newCapacity); 351 352 353 /*! 354 * @function flushCollection 355 * 356 * @abstract 357 * Removes and releases all objects within the ordered set. 358 * 359 * @discussion 360 * The ordered set's capacity (and therefore direct memory consumption) 361 * is not reduced by this function. 362 */ 363 virtual void flushCollection(); 364 365 366 /*! 367 * @function setObject 368 * 369 * @abstract 370 * Adds an object to the OSOrderedSet if it is not already present, 371 * storing it in sorted order if there is an order function. 372 * 373 * @param anObject The OSMetaClassBase-derived object to be added 374 * to the ordered set. 375 * @result 376 * <code>true</code> if <code>anObject</code> was successfully 377 * added to the ordered set, <code>false</code> otherwise 378 * (including if it was already in the ordered set). 379 * 380 * @discussion 381 * The set adds storage to accomodate the new object, if necessary. 382 * If successfully added, the object is retained. 383 * 384 * If <code>anObject</code> is not already in the ordered set 385 * and there is an order function, 386 * this function loops through the existing objects, 387 * calling the @link OSOrderFunction order function@/link 388 * with arguments each existingObject, <code>anObject</code>, 389 * and the ordering context 390 * (or <code>NULL</code> if none was set), 391 * until the order function returns 392 * a value <i>greater than</i> or equal to 0. 393 * It then inserts <code>anObject</code> at the index of the existing object. 394 * 395 * If there is no order function, the object is inserted at index 0. 396 * 397 * A <code>false</code> return value can mean either 398 * that <code>anObject</code> is already present in the set, 399 * or that a memory allocation failure occurred. 400 * If you need to know whether the object 401 * is already present, use 402 * <code>@link 403 * //apple_ref/cpp/instm/OSOrderedSet/containsObject/virtualbool/(constOSMetaClassBase*) 404 * containsObject(const OSMetaClassBase *)@/link</code>. 405 */ 406 virtual bool setObject(const OSMetaClassBase * anObject); 407 408 409 /*! 410 * @function setFirstObject 411 * 412 * @abstract 413 * Adds an object to the OSOrderedSet at index 0 414 * if it is not already present. 415 * 416 * @param anObject The OSMetaClassBase-derived object 417 * to be added to the ordered set. 418 * @result 419 * <code>true</code> if <code>anObject</code> was successfully added 420 * to the ordered set, <code>false</code> otherwise 421 * (including if it was already in the ordered set at any index). 422 * 423 * @discussion 424 * The set adds storage to accomodate the new object, if necessary. 425 * If successfully added, the object is retained. 426 * 427 * This function ignores any ordering function of the ordered set, 428 * and can disrupt the automatic sorting mechanism. 429 * Only call this function if you are managing the ordered set directly. 430 * 431 * A <code>false</code> return value can mean either that <code>anObject</code> 432 * is already present in the set, 433 * or that a memory allocation failure occurred. 434 * If you need to know whether the object 435 * is already present, use 436 * <code>@link 437 * //apple_ref/cpp/instm/OSOrderedSet/containsObject/virtualbool/(constOSMetaClassBase*) 438 * containsObject(const OSMetaClassBase *)@/link</code>. 439 */ 440 virtual bool setFirstObject(const OSMetaClassBase * anObject); 441 442 443 /*! 444 * @function setLastObject 445 * 446 * @abstract 447 * Adds an object at the end of the OSOrderedSet 448 * if it is not already present. 449 * 450 * @param anObject The OSMetaClassBase-derived object to be added 451 * to the ordered set. 452 * @result 453 * <code>true</code> if <code>anObject</code> was successfully added 454 * to the ordered set, <code>false</code> otherwise 455 * (including if it was already in the ordered set at any index). 456 * 457 * @discussion 458 * The set adds storage to accomodate the new object, if necessary. 459 * If successfully added, the object is retained. 460 * 461 * This function ignores any ordering function of the ordered set, 462 * and can disrupt the automatic sorting mechanism. 463 * Only call this function if you are managing the ordered set directly. 464 * 465 * A <code>false</code> return value can mean either that <code>anObject</code> 466 * is already present in the set, 467 * or that a memory allocation failure occurred. 468 * If you need to know whether the object 469 * is already present, use 470 * <code>@link 471 * //apple_ref/cpp/instm/OSOrderedSet/containsObject/virtualbool/(constOSMetaClassBase*) 472 * containsObject(const OSMetaClassBase *)@/link</code>. 473 */ 474 virtual bool setLastObject(const OSMetaClassBase * anObject); 475 476 477 /*! 478 * @function removeObject 479 * 480 * @abstract 481 * Removes an object from the ordered set. 482 * 483 * @param anObject The OSMetaClassBase-derived object 484 * to be removed from the ordered set. 485 * 486 * @discussion 487 * The object removed from the ordered set is released. 488 */ 489 virtual void removeObject(const OSMetaClassBase * anObject); 490 491 492 /*! 493 * @function containsObject 494 * 495 * @abstract 496 * Checks the ordered set for the presence of an object. 497 * 498 * @param anObject The OSMetaClassBase-derived object to check for 499 * in the ordered set. 500 * 501 * @result 502 * <code>true</code> if <code>anObject</code> is present 503 * within the ordered set, <code>false</code> otherwise. 504 * 505 * @discussion 506 * Pointer equality is used. 507 * This function returns <code>false</code> if passed <code>NULL</code>. 508 */ 509 virtual bool containsObject(const OSMetaClassBase * anObject) const; 510 511 512 /*! 513 * @function member 514 * 515 * @abstract 516 * Checks the ordered set for the presence of an object. 517 * 518 * @param anObject The OSMetaClassBase-derived object to check for 519 * in the ordered set. 520 * 521 * @result 522 * <code>true</code> if <code>anObject</code> is present 523 * within the ordered set, <code>false</code> otherwise. 524 * 525 * @discussion 526 * Pointer equality is used. 527 * Returns <code>false</code> if passed <code>NULL</code>. 528 * 529 * <code>@link 530 * //apple_ref/cpp/instm/OSOrderedSet/containsObject/virtualbool/(constOSMetaClassBase*) 531 * containsObject(const OSMetaClassBase *)@/link</code> 532 * checks for <code>NULL</code> before scanning the contents, 533 * and is therefore more efficient than this function. 534 */ 535 virtual bool member(const OSMetaClassBase * anObject) const; 536 537 538 /*! 539 * @function getFirstObject 540 * 541 * @abstract 542 * Returns the object at index 0 in the ordered set if there is one. 543 * 544 * @abstract 545 * The object at index 0 in the ordered set if there is one, 546 * otherwise <code>NULL</code>. 547 * 548 * @discussion 549 * The returned object will be released if removed from the ordered set; 550 * if you plan to store the reference, you should call 551 * <code>@link 552 * //apple_ref/cpp/instm/OSObject/retain/virtualvoid/() 553 * retain@/link</code> 554 * on that object. 555 */ 556 virtual OSObject * getFirstObject() const; 557 558 559 /*! 560 * @function getLastObject 561 * 562 * @abstract 563 * Returns the last object in the ordered set if there is one. 564 * 565 * @abstract 566 * The last object in the ordered set if there is one, 567 * otherwise <code>NULL</code>. 568 * 569 * @discussion 570 * The returned object will be released if removed from the ordered set; 571 * if you plan to store the reference, you should call 572 * <code>@link 573 * //apple_ref/cpp/instm/OSObject/retain/virtualvoid/() 574 * retain@/link</code> 575 * on that object. 576 */ 577 virtual OSObject * getLastObject() const; 578 579 580 /*! 581 * @function orderObject 582 * 583 * @abstract 584 * Calls the ordered set's order function against a <code>NULL</code> object. 585 * 586 * @param anObject The object to be ordered. 587 * 588 * @result 589 * The ordering value for the object. 590 * 591 * @discussion 592 * This function calls the ordered set's 593 * @link OSOrderFunction order function@/link 594 * with <code>anObject</code>, <code>NULL</code>, and the ordering context 595 * (or <code>NULL</code> if none was set), 596 * and returns the result of that function. 597 */ 598 virtual SInt32 orderObject(const OSMetaClassBase * anObject); 599 600 601 /*! 602 * @function setObject 603 * 604 * @abstract 605 * Adds an object to an OSOrderedSet at a specified index 606 * if it is not already present. 607 * 608 * @param index The index at which to insert the new object. 609 * @param anObject The OSMetaClassBase-derived object to be added 610 * to the ordered set. 611 * 612 * @result 613 * <code>true</code> if the object was successfully added 614 * to the ordered set, <code>false</code> otherwise 615 * (including if it was already in the set). 616 * 617 * @discussion 618 * The set adds storage to accomodate the new object, if necessary. 619 * If successfully added, the object is retained. 620 * 621 * This function ignores any ordering function of the ordered set, 622 * and can disrupt the automatic sorting mechanism. 623 * Only call this function if you are managing the ordered set directly. 624 * 625 * A <code>false</code> return value can mean either that the object 626 * is already present in the set, 627 * or that a memory allocation failure occurred. 628 * If you need to know whether the object 629 * is already present, use 630 * <code>@link //apple_ref/cpp/instm/OSOrderedSet/containsObject/virtualbool/(constOSMetaClassBase*) 631 * containsObject containsObject@/link</code>. 632 */ 633 virtual bool setObject( 634 unsigned int index, 635 const OSMetaClassBase * anObject); 636 637 638 /*! 639 * @function getObject 640 * 641 * @abstract 642 * Gets the object at a particular index. 643 * 644 * @param index The index into the set. 645 * @result 646 * The object at the given index, 647 * or <code>NULL</code> if none exists at that location. 648 * 649 * @discussion 650 * The returned object will be released if removed from the set; 651 * if you plan to store the reference, you should call 652 * <code>@link 653 * //apple_ref/cpp/instm/OSObject/retain/virtualvoid/() 654 * retain@/link</code> 655 * on that object. 656 */ 657 virtual OSObject * getObject(unsigned int index) const; 658 659 660 /*! 661 * @function getOrderingRef 662 * 663 * @abstract 664 * Returns the ordering context the ordered set was created with. 665 * 666 * @result 667 * The ordered set's ordering context, 668 * or <code>NULL</code> if it doesn't have one. 669 */ 670 virtual void * getOrderingRef(); 671 672 673 /*! 674 * @function isEqualTo 675 * 676 * @abstract 677 * Tests the equality of two OSOrderedSet objects. 678 * 679 * @param anOrderedSet The ordered set object being compared 680 * against the receiver. 681 * @result 682 * <code>true</code> if the two sets are equivalent, 683 * <code>false</code> otherwise. 684 * 685 * @discussion 686 * Two OSOrderedSet objects are considered equal if they have same count 687 * and the same object pointer values in the same order. 688 */ 689 virtual bool isEqualTo(const OSOrderedSet * anOrderedSet) const; 690 691 692 /*! 693 * @function isEqualTo 694 * 695 * @abstract 696 * Tests the equality of an OSOrderedSet 697 * against an arbitrary object. 698 * 699 * @param anObject The object being compared against the receiver. 700 * @result 701 * <code>true</code> if the two objects are equivalent, 702 * <code>false</code> otherwise. 703 * 704 * @discussion 705 * An OSOrderedSet object is considered equal to another object 706 * if the other object is derived from OSOrderedSet 707 * and compares equal as an OSOrderedSet. 708 */ 709 virtual bool isEqualTo(const OSMetaClassBase * anObject) const; 710 711 712 /*! 713 * @function setOptions 714 * 715 * Recursively sets option bits in the ordered set 716 * and all child collections. 717 * 718 * @param options A bitfield whose values turn the options on (1) or off (0). 719 * @param mask A mask indicating which bits 720 * in <code>options</code> to change. 721 * Pass 0 to get the whole current options bitfield 722 * without changing any settings. 723 * @param context Unused. 724 * 725 * @result 726 * The options bitfield as it was before the set operation. 727 * 728 * @discussion 729 * Kernel extensions should not call this function. 730 * 731 * Child collections' options are changed only if the receiving ordered set's 732 * options actually change. 733 */ 734 virtual unsigned setOptions( 735 unsigned options, 736 unsigned mask, 737 void * context = 0); 738 739 740 /*! 741 * @function copyCollection 742 * 743 * @abstract 744 * Creates a deep copy of this ordered set and its child collections. 745 * 746 * @param cycleDict A dictionary of all of the collections 747 * that have been copied so far, 748 * which is used to track circular references. 749 * To start the copy at the top level, 750 * pass <code>NULL</code>. 751 * 752 * @result 753 * The newly copied ordered set, with a retain count of 1, 754 * or <code>NULL</code> if there is insufficient memory to do the copy. 755 * 756 * @discussion 757 * The receiving ordered set, and any collections it contains, 758 * recursively, are copied. 759 * Objects that are not derived from OSCollection are retained 760 * rather than copied. 761 */ 762 OSCollection *copyCollection(OSDictionary * cycleDict = 0); 763 764 OSMetaClassDeclareReservedUnused(OSOrderedSet, 0); 765 OSMetaClassDeclareReservedUnused(OSOrderedSet, 1); 766 OSMetaClassDeclareReservedUnused(OSOrderedSet, 2); 767 OSMetaClassDeclareReservedUnused(OSOrderedSet, 3); 768 OSMetaClassDeclareReservedUnused(OSOrderedSet, 4); 769 OSMetaClassDeclareReservedUnused(OSOrderedSet, 5); 770 OSMetaClassDeclareReservedUnused(OSOrderedSet, 6); 771 OSMetaClassDeclareReservedUnused(OSOrderedSet, 7); 772}; 773 774#endif /* ! _OS_OSORDEREDSET_H */ 775