mirror of
https://git.code.sf.net/p/quake/quakeforge
synced 2024-11-14 17:01:22 +00:00
288 lines
6.7 KiB
Objective-C
288 lines
6.7 KiB
Objective-C
#ifndef __ruamoko_Array_h
|
|
#define __ruamoko_Array_h
|
|
|
|
#include <Object.h>
|
|
#include <runtime.h>
|
|
|
|
/**
|
|
The Array class is a general ordered collection class.
|
|
|
|
The %Array class manages an ordered collection of objects.
|
|
If you want to subclass Array, you need to override these methods:
|
|
|
|
\li #count()
|
|
\li #objectAtIndex:
|
|
\li #addObject:
|
|
\li #insertObject:atIndex:
|
|
\li #removeObjectAtIndex:
|
|
\li #removeLastObject
|
|
\li #replaceObjectAtIndex:withObject:
|
|
*/
|
|
@interface Array: Object //<Copying>
|
|
{
|
|
unsigned count; ///< The number of objects currently contained
|
|
unsigned capacity; ///< The number of objects that can be held right now
|
|
unsigned granularity; ///< The number of pointers allocated at a time (based on initial capacity)
|
|
id *_objs; ///< A primitive array of pointers to objects
|
|
}
|
|
|
|
///\name Creating arrays
|
|
//\{
|
|
/**
|
|
Create and return an empty array with the default initial capacity.
|
|
*/
|
|
+ (id) array;
|
|
|
|
/**
|
|
Creates and returns an empty array with initial capacity \a cap.
|
|
|
|
\param cap The initial capacity of the array.
|
|
*/
|
|
+ (id) arrayWithCapacity: (unsigned)cap;
|
|
|
|
/**
|
|
Returns a copy of \a array, retaining its contents.
|
|
*/
|
|
+ (id) arrayWithArray: (Array *)array;
|
|
|
|
/**
|
|
Create an array containing only \a anObject .
|
|
*/
|
|
+ (id) arrayWithObject: (id)anObject;
|
|
|
|
/**
|
|
Create an array from a list of objects.
|
|
|
|
\warning Due to the nature of the Ruamoko/QuakeC language, do not supply
|
|
more than 6 objects to this method.
|
|
*/
|
|
+ (id) arrayWithObjects: (id)firstObj, ...;
|
|
|
|
/**
|
|
Create and return an array containing the first \a count objects from
|
|
primitive array \a objs.
|
|
|
|
\warning Do not supply a primitive array containing fewer than \a count
|
|
objects.
|
|
*/
|
|
+ (id) arrayWithObjects: (id *)objs
|
|
count: (unsigned)cnt;
|
|
//\}
|
|
|
|
///\name Initializing arrays
|
|
//\{
|
|
/**
|
|
Initialize the receiver with capacity \a cap
|
|
*/
|
|
- (id) initWithCapacity: (unsigned)cap;
|
|
|
|
/**
|
|
Initialize the receiver with objects from \a array.
|
|
*/
|
|
- (id) initWithArray: (Array *)array;
|
|
|
|
/**
|
|
Initialize the receiver with objects from \a array.
|
|
|
|
\param array The array to duplicate
|
|
\param flag if #YES, copies the contents instead of retaining them.
|
|
*/
|
|
- (id) initWithArray: (Array *)array
|
|
copyItems: (BOOL)flag;
|
|
|
|
/**
|
|
Initialize the receiver with a list of objects.
|
|
|
|
\warning Due to the nature of the Ruamoko/QuakeC language, do not supply
|
|
more than 6 objects to this method.
|
|
*/
|
|
- (id) initWithObjects: (id)firstObj, ...;
|
|
|
|
/**
|
|
Initialize the receiver with a primitive array of objects.
|
|
*/
|
|
- (id) initWithObjects: (id *)objs
|
|
count: (unsigned)count;
|
|
//\}
|
|
|
|
///\name Querying an array
|
|
//\{
|
|
/**
|
|
Returns #YES if the receiver contains \a anObject.
|
|
|
|
The #isEqual: method is used to determine this, so that (for example) a
|
|
newly-created string object can be compared to one already in the array.
|
|
*/
|
|
- (BOOL) containsObject: (id)anObject;
|
|
|
|
/**
|
|
Returns the number of objects contained in the receiver.
|
|
*/
|
|
- (unsigned) count;
|
|
|
|
/**
|
|
Returns the object contained at index \a index.
|
|
*/
|
|
- (id) objectAtIndex: (unsigned)index;
|
|
|
|
/**
|
|
Returns the contained object with the highest index.
|
|
*/
|
|
- (id) lastObject;
|
|
//- (Enumerator) objectEnumerator;
|
|
//- (Enumerator) reverseObjectEnumerator;
|
|
|
|
#if 0
|
|
/**
|
|
Copies all object references in the range \a aRange to \a aBuffer.
|
|
|
|
\warning The destination buffer must be large enough to hold all contents.
|
|
*/
|
|
- (BOOL) getObjects: (id *)aBuffer
|
|
range: (Range)aRange;
|
|
#endif
|
|
//\}
|
|
|
|
///\name Finding objects
|
|
//\{
|
|
/**
|
|
Returns the lowest index of an object equal to \a anObject.
|
|
|
|
If no object is equal, returns #NotFound.
|
|
*/
|
|
- (unsigned) indexOfObject: (id)anObject;
|
|
|
|
#if 0
|
|
/**
|
|
Returns the lowest index, within the range \a aRange, of an object equal
|
|
to \a anObject.
|
|
|
|
If no object is equal, returns #NotFound.
|
|
*/
|
|
- (unsigned) indexOfObject: (id)anObject
|
|
inRange: (Range)aRange;
|
|
#endif
|
|
|
|
/**
|
|
Returns the lowest index of an object with the same address as \a anObject.
|
|
|
|
Returns #NotFound if \a anObject is not found within the array.
|
|
*/
|
|
- (unsigned) indexOfObjectIdenticalTo: (id)anObject;
|
|
|
|
#if 0
|
|
/**
|
|
Returns the lowest index, within the range \a aRange, of an object with
|
|
the same address as \a anObject.
|
|
|
|
Returns #NotFound if \a anObject is not found within the range.
|
|
*/
|
|
- (unsigned) indexOfObjectIdenticalTo: (id)anObject
|
|
inRange: (Range)aRange;
|
|
#endif
|
|
//\}
|
|
|
|
///\name Adding objects
|
|
//\{
|
|
|
|
/**
|
|
Adds a single object to an array
|
|
*/
|
|
- (void) addObject: (id)anObject;
|
|
|
|
/**
|
|
Adds each object in \a array to the receiver, retaining it.
|
|
*/
|
|
- (void) addObjectsFromArray: (Array *)array;
|
|
|
|
/**
|
|
Adds a single object to an array
|
|
|
|
Adds \a anObject to the receiver at index \a index, pushing any objects
|
|
with a higher index to the next higher slot.
|
|
*/
|
|
- (void) insertObject: (id)anObject
|
|
atIndex: (unsigned)index;
|
|
//\}
|
|
|
|
///\name Replacing Objects
|
|
//\{
|
|
/**
|
|
Removes object at \a index, replacing it with \a anObject.
|
|
*/
|
|
- (void) replaceObjectAtIndex: (unsigned)index
|
|
withObject: (id)anObject;
|
|
|
|
/**
|
|
Replaces the object currently in the receiver with those from \a array.
|
|
|
|
\note If \a array and self are the same object, this method has no effect.
|
|
*/
|
|
- (void) setArray: (Array *)array;
|
|
//\}
|
|
|
|
///\name Removing Objects
|
|
//\{
|
|
|
|
/**
|
|
Recursively removes all objects from the receiver by sending
|
|
#removeLastObject to \a self, until #count() returns zero.
|
|
*/
|
|
- (void) removeAllObjects;
|
|
|
|
/**
|
|
Removes from the receiver the contained object with the highest index.
|
|
*/
|
|
- (void) removeLastObject;
|
|
|
|
/**
|
|
Finds and removes all objects from the receiver that are equal to
|
|
\a anObject, by sending each #isEqual: with \a anObject as the argument.
|
|
*/
|
|
- (void) removeObject: (id)anObject;
|
|
|
|
/**
|
|
Finds and removes all objects from the receiver that are equal to any
|
|
objects in array \a anArray.
|
|
*/
|
|
- (void) removeObjectsInArray: (Array *)anArray;
|
|
|
|
/**
|
|
Finds and removes all objects from the receiver that are \b exactly equal
|
|
to \a anObject, using a direct address comparison.
|
|
*/
|
|
- (void) removeObjectIdenticalTo: (id)anObject;
|
|
|
|
/**
|
|
Removes the object located at index \a index, moving each object with a
|
|
higher index down one position.
|
|
*/
|
|
- (void) removeObjectAtIndex: (unsigned)index;
|
|
//\}
|
|
|
|
///\name Sending Messages to Elements
|
|
//\{
|
|
/**
|
|
Iteratively sends #performSelector: to each contained object.
|
|
*/
|
|
- (void) makeObjectsPerformSelector: (SEL)selector;
|
|
|
|
/**
|
|
Iteratively sends #performSelector:withObject: to each contained object.
|
|
*/
|
|
- (void) makeObjectsPerformSelector: (SEL)selector
|
|
withObject: (void *)arg;
|
|
//\}
|
|
|
|
/**
|
|
Iteratively sends #performSelector:withObject:withObject: to each
|
|
contained object.
|
|
*/
|
|
- (void) makeObjectsPerformSelector: (SEL)selector
|
|
withObject: (void *)arg
|
|
withObject: (void *)arg2;
|
|
//\}
|
|
|
|
@end
|
|
|
|
#endif//__ruamoko_Array_h
|