Up

NSArray class reference

Authors

Andrew Kachites McCallum (mccallum@gnu.ai.mit.edu)
Adam Fedor (fedor@boulder.colorado.edu)
Richard Frith-Macdonald (richard@brainstorm.co.uk)

Version: 35584

Date: 2012-09-21 11:27:05 +0100 (Fri, 21 Sep 2012)

Copyright: (C) 1995, 1996, 1998 Free Software Foundation, Inc.


Contents -

  1. Software documentation for the NSArray class
  2. Software documentation for the NSMutableArray class

Software documentation for the NSArray class

NSArray : NSObject

Declared in:
Foundation/NSArray.h
Conforms to:
NSCoding
NSCopying
NSMutableCopying
NSFastEnumeration
Availability: OpenStep

A simple, low overhead, ordered container for objects. All the objects in the container are retained by it. The container may not contain nil (though it may contain [NSNull +null] ).
Method summary

array 

+ (id) array;
Availability: OpenStep

Returns an empty autoreleased array.

arrayWithArray: 

+ (id) arrayWithArray: (NSArray*)array;
Availability: OpenStep

Returns a new autoreleased NSArray instance containing all the objects from array , in the same order as the original.

arrayWithContentsOfFile: 

+ (id) arrayWithContentsOfFile: (NSString*)file;
Availability: OpenStep

Returns an autoreleased array based upon the file. The new array is created using [NSObject +allocWithZone:] and initialised using the [NSArray -initWithContentsOfFile:] method. See the documentation for those methods for more detail.

arrayWithContentsOfURL: 

+ (id) arrayWithContentsOfURL: (NSURL*)aURL;
Availability: MacOS-X 10.0.0

Returns an autoreleased array from the contents of aURL. The new array is created using [NSObject +allocWithZone:] and initialised using the -initWithContentsOfURL: method. See the documentation for those methods for more detail.

arrayWithObject: 

+ (id) arrayWithObject: (id)anObject;
Availability: OpenStep

Returns an autoreleased array containing anObject.

arrayWithObjects: ,...

+ (id) arrayWithObjects: (id)firstObject,...;
Availability: OpenStep

Returns an autoreleased array containing the list of objects, preserving order.

arrayWithObjects: count: 

+ (id) arrayWithObjects: (const id[])objects count: (NSUInteger)count;
Availability: OpenStep

Returns an autoreleased array containing the specified objects, preserving order.

arrayByAddingObject: 

- (NSArray*) arrayByAddingObject: (id)anObject;
Availability: OpenStep

Returns an autoreleased array formed from the contents of the receiver and adding anObject as the last item.

arrayByAddingObjectsFromArray: 

- (NSArray*) arrayByAddingObjectsFromArray: (NSArray*)anotherArray;
Availability: OpenStep

Returns a new array which is the concatenation of self and otherArray (in this precise order).

componentsJoinedByString: 

- (NSString*) componentsJoinedByString: (NSString*)separator;
Availability: OpenStep

Returns a string formed by concatenating the objects in the receiver, with the specified separator string inserted between each part.

containsObject: 

- (BOOL) containsObject: (id)anObject;
Availability: OpenStep

Returns YES if anObject belongs to self. No otherwise.
The [NSObject -isEqual:] method of anObject is used to test for equality.

count 

- (NSUInteger) count;
Availability: OpenStep

Subclasses must override this method.
Returns the number of elements contained in the receiver.

description 

- (NSString*) description;
Availability: OpenStep

Returns the result of invoking -descriptionWithLocale:indent: with a nil locale and zero indent.

descriptionWithLocale: 

- (NSString*) descriptionWithLocale: (id)locale;
Availability: OpenStep

Returns the result of invoking -descriptionWithLocale:indent: with a zero indent.

descriptionWithLocale: indent: 

- (NSString*) descriptionWithLocale: (id)locale indent: (NSUInteger)level;
Availability: OpenStep

Returns the receiver as a text property list in the traditional format.
See [NSString -propertyList] for details.
If locale is nil, no formatting is done, otherwise entries are formatted according to the locale, and indented according to level.
Unless locale is nil, a level of zero indents items by four spaces, while a level of one indents them by a tab.
The items in the property list string appear in the same order as they appear in the receiver.

enumerateObjectsAtIndexes: options: usingBlock: 

- (void) enumerateObjectsAtIndexes: (NSIndexSet*)indexSet options: (NSEnumerationOptions)opts usingBlock: (GSEnumeratorBlock)block;
Availability: MacOS-X 10.6.0

Enumerate over the specified indexes in the collection using the given block. The first argument is the object and the second is the index in the array. The final argument is a pointer to a BOOL indicating whether the enumeration should stop. Setting this to YES will interrupt the enumeration. The opts argument is a bitfield. Setting the NSNSEnumerationConcurrent flag specifies that it is thread-safe. The NSEnumerationReverse bit specifies that it should be enumerated in reverse order.

enumerateObjectsUsingBlock: 

- (void) enumerateObjectsUsingBlock: (GSEnumeratorBlock)aBlock;
Availability: MacOS-X 10.6.0

Enumerate over the collection using the given block. The first argument is the object and the second is the index in the array. The final argument is a pointer to a BOOL indicating whether the enumeration should stop. Setting this to YES will interrupt the enumeration.

enumerateObjectsWithOptions: usingBlock: 

- (void) enumerateObjectsWithOptions: (NSEnumerationOptions)opts usingBlock: (GSEnumeratorBlock)aBlock;
Availability: MacOS-X 10.6.0

Enumerate over the collection using the given block. The first argument is the object and the second is the index in the array. The final argument is a pointer to a BOOL indicating whether the enumeration should stop. Setting this to YES will interrupt the enumeration. The opts argument is a bitfield. Setting the NSNSEnumerationConcurrent flag specifies that it is thread-safe. The NSEnumerationReverse bit specifies that it should be enumerated in reverse order.

firstObjectCommonWithArray: 

- (id) firstObjectCommonWithArray: (NSArray*)otherArray;
Availability: OpenStep

Returns the first object found in the receiver (starting at index 0) which is present in the otherArray as determined by using the -containsObject: method.

getObjects: 

- (void) getObjects: (__unsafe_unretained id[])aBuffer;
Availability: OpenStep

Copies the objects from the receiver to aBuffer, which must be an area of memory large enough to hold them.

getObjects: range: 

- (void) getObjects: (__unsafe_unretained id[])aBuffer range: (NSRange)aRange;
Availability: OpenStep

Copies the objects from the range aRange of the receiver to aBuffer, which must be an area of memory large enough to hold them.

indexOfObject: 

- (NSUInteger) indexOfObject: (id)anObject;
Availability: OpenStep

Returns the index of the first object found in the receiver which is equal to anObject (using anObject's [NSObject -isEqual:] method). Returns NSNotFound on failure.

indexOfObject: inRange: 

- (NSUInteger) indexOfObject: (id)anObject inRange: (NSRange)aRange;
Availability: OpenStep

Returns the index of the first object found in aRange of receiver which is equal to anObject (using anObject's [NSObject -isEqual:] method). Returns NSNotFound on failure.

indexOfObject: inSortedRange: options: usingComparator: 

- (NSUInteger) indexOfObject: (id)key inSortedRange: (NSRange)range options: (NSBinarySearchingOptions)options usingComparator: (NSComparator)comparator;
Availability: MacOS-X 10.6.0

Performs a binary search of the array within the specified range for the index of an object equal to obj according to cmp. If NSBinarySearchingInsertionIndex is specified, searches for the index at which such an object should be inserted.

indexOfObjectAtIndexes: options: passingTest: 

- (NSUInteger) indexOfObjectAtIndexes: (NSIndexSet*)indexSet options: (NSEnumerationOptions)opts passingTest: (GSPredicateBlock)predicate;
Availability: MacOS-X 10.6.0

Returns the index of the first object in the specified range in a collection that matches the condition specified by the block. The opts argument is a bitfield. Setting the NSNSEnumerationConcurrent flag specifies that it is thread-safe. The NSEnumerationReverse bit specifies that it should be enumerated in reverse order.

indexOfObjectIdenticalTo: 

- (NSUInteger) indexOfObjectIdenticalTo: (id)anObject;
Availability: OpenStep

Returns the index of the specified object in the receiver, or NSNotFound if the object is not present.

indexOfObjectIdenticalTo: inRange: 

- (NSUInteger) indexOfObjectIdenticalTo: (id)anObject inRange: (NSRange)aRange;
Availability: OpenStep

Returns the index of the specified object in the range of the receiver, or NSNotFound if the object is not present.

indexOfObjectPassingTest: 

- (NSUInteger) indexOfObjectPassingTest: (GSPredicateBlock)predicate;
Availability: MacOS-X 10.6.0

Returns the index of the first object in the array that matches the condition specified by the block.

indexOfObjectWithOptions: passingTest: 

- (NSUInteger) indexOfObjectWithOptions: (NSEnumerationOptions)opts passingTest: (GSPredicateBlock)predicate;
Availability: MacOS-X 10.6.0

Returns the index of the first object in the array that matches the condition specified by the block. The opts argument is a bitfield. Setting the NSNSEnumerationConcurrent flag specifies that it is thread-safe. The NSEnumerationReverse bit specifies that it should be enumerated in reverse order.

indexesOfObjectsAtIndexes: options: passingTest: 

- (NSIndexSet*) indexesOfObjectsAtIndexes: (NSIndexSet*)indexSet options: (NSEnumerationOptions)opts passingTest: (GSPredicateBlock)predicate;
Availability: MacOS-X 10.6.0

Returns the indexes of the objects in a collection that match the condition specified by the block and are in the range specified by the index set. The opts argument is a bitfield. Setting the NSNSEnumerationConcurrent flag specifies that it is thread-safe. The NSEnumerationReverse bit specifies that it should be enumerated in reverse order.

indexesOfObjectsPassingTest: 

- (NSIndexSet*) indexesOfObjectsPassingTest: (GSPredicateBlock)predicate;
Availability: MacOS-X 10.6.0

Returns the indexes of the objects in a collection that match the condition specified by the block.

indexesOfObjectsWithOptions: passingTest: 

- (NSIndexSet*) indexesOfObjectsWithOptions: (NSEnumerationOptions)opts passingTest: (GSPredicateBlock)predicate;
Availability: MacOS-X 10.6.0

Returns the indexes of the objects in a collection that match the condition specified by the block. The opts argument is a bitfield. Setting the NSNSEnumerationConcurrent flag specifies that it is thread-safe. The NSEnumerationReverse bit specifies that it should be enumerated in reverse order.

init 

- (id) init;
Availability: OpenStep

In MacOS-X class clusters do not have designated initialisers, and there is a general rule that -init is treated as the designated initialiser of the class cluster, but that other intitialisers may not work s expected an would need to be individually overridden in any subclass.

GNUstep tries to make it easier to subclass a class cluster, by making class clusters follow the same convention as normal classes, so the designated initialiser is the richest initialiser. This means that all other initialisers call the documented designated initialiser (which calls -init only for MacOS-X compatibility), and anyone writing a subclass only needs to override that one initialiser in order to have all the other ones work.

For MacOS-X compatibility, you may also need to override various other initialisers. Exactly which ones, you will need to determine by trial on a MacOS-X system... and may vary between releases of MacOS-X. So to be safe, on MacOS-X you probably need to re-implement all the class cluster initialisers you might use in conjunction with your subclass.


initWithArray: 

- (id) initWithArray: (NSArray*)array;
Availability: OpenStep

Initialize the receiver with the contents of array. The order of array is preserved.
Invokes -initWithObjects:count:

initWithArray: copyItems: 

- (id) initWithArray: (NSArray*)array copyItems: (BOOL)shouldCopy;
Availability: MacOS-X 10.0.0

Initialize the receiver with the contents of array. The order of array is preserved.
If shouldCopy is YES then the objects are copied rather than simply retained.
Invokes -initWithObjects:count:

initWithContentsOfFile: 

- (id) initWithContentsOfFile: (NSString*)file;
Availability: OpenStep

Initialises the array with the contents of the specified file, which must contain an array in property-list format.

In GNUstep, the property-list format may be either the OpenStep format (ASCII data), or the MacOS-X format (UTF-8 XML data)... this method will recognise which it is.

If there is a failure to load the file for any reason, the receiver will be released, the method will return nil, and a warning may be logged.

Works by invoking [NSString -initWithContentsOfFile:] and [NSString -propertyList] then checking that the result is an array.


initWithContentsOfURL: 

- (id) initWithContentsOfURL: (NSURL*)aURL;
Availability: MacOS-X 10.0.0

Initialises the array with the contents of the specified URL, which must contain an array in property-list format.

In GNUstep, the property-list format may be either the OpenStep format (ASCII data), or the MacOS-X format (UTF8 XML data)... this method will recognise which it is.

If there is a failure to load the URL for any reason, the receiver will be released, the method will return nil, and a warning may be logged.

Works by invoking [NSString -initWithContentsOfURL:] and [NSString -propertyList] then checking that the result is an array.


initWithObjects: ,...

- (id) initWithObjects: (id)firstObject,...;
Availability: OpenStep

Initialize the array the list of objects.
May change the value of self before returning it.

initWithObjects: count: 

- (id) initWithObjects: (const id[])objects count: (NSUInteger)count;
Availability: OpenStep

This is a designated initialiser for the class.
Subclasses must override this method.
This should initialize the array with count (may be zero) objects.
Retains each object placed in the array.
Calls -init (which does nothing but maintain MacOS-X compatibility), and needs to be re-implemented in subclasses in order to have all other initialisers work.

isEqualToArray: 

- (BOOL) isEqualToArray: (NSArray*)otherArray;
Availability: OpenStep

Returns YES if the receiver is equal to otherArray, NO otherwise.

lastObject 

- (id) lastObject;
Availability: OpenStep

Returns the last object in the receiver, or nil if the receiver is empty.

makeObjectsPerform: 

- (void) makeObjectsPerform: (SEL)aSelector;
Availability: OPENSTEP 4.0.0 removed at MacOS-X 10.0.0

Obsolete version of -makeObjectsPerformSelector:

makeObjectsPerform: withObject: 

- (void) makeObjectsPerform: (SEL)aSelector withObject: (id)argument;
Availability: OPENSTEP 4.0.0 removed at MacOS-X 10.0.0


makeObjectsPerformSelector: 

- (void) makeObjectsPerformSelector: (SEL)aSelector;
Availability: MacOS-X 10.0.0

Makes each object in the array perform aSelector.
This is done sequentially from the first to the last object.

makeObjectsPerformSelector: withObject: 

- (void) makeObjectsPerformSelector: (SEL)aSelector withObject: (id)arg;
Availability: MacOS-X 10.0.0

Makes each object in the array perform aSelector with arg.
This is done sequentially from the first to the last object.

objectAtIndex: 

- (id) objectAtIndex: (NSUInteger)index;
Availability: OpenStep

Subclasses must override this method.
Returns the object at the specified index. Raises an exception of the index is beyond the array.

objectAtIndexedSubscript: 

- (id) objectAtIndexedSubscript: (size_t)anIndex;
Availability: OpenStep

Accessor for subscripting. This is called by the compiler when you write code like anArray[12]. It should not be called directly.

objectEnumerator 

- (NSEnumerator*) objectEnumerator;
Availability: OpenStep

Returns an enumerator describing the array sequentially from the first to the last element.
If you use a mutable subclass of NSArray, you should not modify the array during enumeration.

objectsAtIndexes: 

- (NSArray*) objectsAtIndexes: (NSIndexSet*)indexes;
Availability: MacOS-X 10.4.0

Description forthcoming.

pathsMatchingExtensions: 

- (NSArray*) pathsMatchingExtensions: (NSArray*)extensions;
Availability: OpenStep

Assumes that the receiver is an array of paths, and returns an array formed by selecting the subset of those patch matching the specified array of extensions.

reverseObjectEnumerator 

- (NSEnumerator*) reverseObjectEnumerator;
Availability: OpenStep

Returns an enumerator describing the array sequentially from the last to the first element.
If you use a mutable subclass of NSArray, you should not modify the array during enumeration.

sortedArrayHint 

- (NSData*) sortedArrayHint;
Availability: OpenStep

Subclasses may provide a hint for sorting... The default GNUstep implementation just returns nil.

sortedArrayUsingComparator: 

- (NSArray*) sortedArrayUsingComparator: (NSComparator)comparator;
Availability: MacOS-X 10.6.0

Returns a sorted array using the comparator to determine the order of objects.

sortedArrayUsingFunction: context: 

- (NSArray*) sortedArrayUsingFunction: (NSComparisonResult(*)(id,id,void*))comparator context: (void*)context;
Availability: OpenStep

Returns an autoreleased array in which the objects are ordered according to a sort with comparator. This invokes -sortedArrayUsingFunction:context:hint: with a nil hint.

sortedArrayUsingFunction: context: hint: 

- (NSArray*) sortedArrayUsingFunction: (NSComparisonResult(*)(id,id,void*))comparator context: (void*)context hint: (NSData*)hint;
Availability: OpenStep

Returns an autoreleased array in which the objects are ordered according to a sort with comparator, where the comparator function is passed two objects to compare, and the context as the third argument. The hint argument is currently ignored, and may be nil.

sortedArrayUsingSelector: 

- (NSArray*) sortedArrayUsingSelector: (SEL)comparator;
Availability: OpenStep

Returns an autoreleased array in which the objects are ordered according to a sort with comparator.

sortedArrayWithOptions: usingComparator: 

- (NSArray*) sortedArrayWithOptions: (NSSortOptions)options usingComparator: (NSComparator)comparator;
Availability: MacOS-X 10.6.0

Returns a sorted array using the block to determine the order of objects. The opts argument is a bitfield. Setting the NSSortConcurrent flag specifies that it is thread-safe. The NSSortStable bit specifies that it should keep equal objects in the same order.

subarrayWithRange: 

- (NSArray*) subarrayWithRange: (NSRange)aRange;
Availability: OpenStep

Returns a subarray of the receiver containing the objects found in the specified range aRange.

valueForKey: 

- (id) valueForKey: (NSString*)key;
Availability: MacOS-X 10.0.0

This overrides NSObjects implementation of this method. This method returns an array of objects returned by invoking -valueForKey: for each item in the receiver, substituting NSNull for nil. A special case: the key "count" is not forwarded to each object of the receiver but returns the number of objects of the receiver.

writeToFile: atomically: 

- (BOOL) writeToFile: (NSString*)path atomically: (BOOL)useAuxiliaryFile;
Availability: OpenStep

Writes the contents of the array to the file specified by path. The file contents will be in property-list format... under GNUstep this is either OpenStep style (ASCII characters using \U hexadecimal escape sequences for unicode), or MacOS-X style (XML in the UTF8 character set).

If the useAuxiliaryFile flag is YES, the file write operation is atomic... the data is written to a temporary file, which is then renamed to the actual file name.

If the conversion of data into the correct property-list format fails or the write operation fails, the method returns NO, otherwise it returns YES.

NB. The fact that the file is in property-list format does not necessarily mean that it can be used to reconstruct the array using the -initWithContentsOfFile: method. If the original array contains non-property-list objects, the descriptions of those objects will have been written, and reading in the file as a property-list will result in a new array containing the string descriptions.


writeToURL: atomically: 

- (BOOL) writeToURL: (NSURL*)url atomically: (BOOL)useAuxiliaryFile;
Availability: MacOS-X 10.0.0

Writes the contents of the array to the specified url. This functions just like -writeToFile:atomically: except that the output may be written to any URL, not just a local file.


Software documentation for the NSMutableArray class

NSMutableArray : NSArray

Declared in:
Foundation/NSArray.h
Availability: OpenStep

NSMutableArray is the mutable version of NSArray . It provides methods for altering the contents of the array.
Method summary

arrayWithCapacity: 

+ (id) arrayWithCapacity: (NSUInteger)numItems;
Availability: OpenStep

Creates an autoreleased mutable array able to store at least numItems. See the -initWithCapacity: method.

addObject: 

- (void) addObject: (id)anObject;
Availability: OpenStep

Subclasses must override this method.
Adds anObject at the end of the array, thus increasing the size of the array. The object is retained upon addition.

addObjectsFromArray: 

- (void) addObjectsFromArray: (NSArray*)otherArray;
Availability: OpenStep

Adds each object from otherArray to the receiver, in first to last order.

exchangeObjectAtIndex: withObjectAtIndex: 

- (void) exchangeObjectAtIndex: (NSUInteger)i1 withObjectAtIndex: (NSUInteger)i2;
Availability: MacOS-X 10.0.0

Swaps the positions of two objects in the array. Raises an exception if either array index is out of bounds.

initWithCapacity: 

- (id) initWithCapacity: (NSUInteger)numItems;
Availability: OpenStep

This is a designated initialiser for the class.
Subclasses must override this method.
Initialise the array with the specified capacity ... this should ensure that the array can have numItems added efficiently.
Calls -init (which does nothing but maintain MacOS-X compatibility), and needs to be re-implemented in subclasses in order to have all other initialisers work.

insertObject: atIndex: 

- (void) insertObject: (id)anObject atIndex: (NSUInteger)index;
Availability: OpenStep

Subclasses must override this method.
Inserts an object into the receiver at the specified location.
Raises an exception if given an array index which is too large.
The size of the array increases by one.
The object is retained by the array.

insertObjects: atIndexes: 

- (void) insertObjects: (NSArray*)objects atIndexes: (NSIndexSet*)indexes;
Availability: MacOS-X 10.4.0

Inserts the values from the objects array into the receiver at the locations given by the indexes set.
The values are inserted in the same order that they appear in the array.

removeAllObjects 

- (void) removeAllObjects;
Availability: OpenStep

Removes all objects from the receiver, leaving an empty array.

removeLastObject 

- (void) removeLastObject;
Availability: OpenStep

Removes the last object in the array. Raises an exception if the array is already empty.

removeObject: 

- (void) removeObject: (id)anObject;
Availability: OpenStep

Removes all occurrences of anObject (found by anObject's [NSObject -isEqual:] method) from the receiver.

removeObject: inRange: 

- (void) removeObject: (id)anObject inRange: (NSRange)aRange;
Availability: OpenStep

Removes all occurrences of anObject (found by the [NSObject -isEqual:] method of anObject) aRange in the receiver.

removeObjectAtIndex: 

- (void) removeObjectAtIndex: (NSUInteger)index;
Availability: OpenStep

Subclasses must override this method.
Removes an object from the receiver at the specified location.
The size of the array decreases by one.
Raises an exception if given an array index which is too large.

removeObjectIdenticalTo: 

- (void) removeObjectIdenticalTo: (id)anObject;
Availability: OpenStep

Removes all occurrences of anObject (found by pointer equality) from the receiver.

removeObjectIdenticalTo: inRange: 

- (void) removeObjectIdenticalTo: (id)anObject inRange: (NSRange)aRange;
Availability: OpenStep

Removes all occurrences of anObject (found by pointer equality) from aRange in the receiver.

removeObjectsAtIndexes: 

- (void) removeObjectsAtIndexes: (NSIndexSet*)indexes;
Availability: OpenStep

Removes objects from the receiver at the indices supplied by an NSIndexSet

removeObjectsFromIndices: numIndices: 

- (void) removeObjectsFromIndices: (NSUInteger*)indices numIndices: (NSUInteger)count;
Availability: OpenStep

Supplied with a C array of indices containing count values, this method removes all corresponding objects from the receiver. The objects are removed in such a way that the removal is safe irrespective of the order in which they are specified in the indices array.

removeObjectsInArray: 

- (void) removeObjectsInArray: (NSArray*)otherArray;
Availability: OpenStep

Removes from the receiver, all the objects present in otherArray, as determined by using the [NSObject -isEqual:] method.

removeObjectsInRange: 

- (void) removeObjectsInRange: (NSRange)aRange;
Availability: OpenStep

Removes all the objects in aRange from the receiver.

replaceObjectAtIndex: withObject: 

- (void) replaceObjectAtIndex: (NSUInteger)index withObject: (id)anObject;
Availability: OpenStep

Subclasses must override this method.
Places an object into the receiver at the specified location.
Raises an exception if given an array index which is too large.
The object is retained by the array.

replaceObjectsAtIndexes: withObjects: 

- (void) replaceObjectsAtIndexes: (NSIndexSet*)indexes withObjects: (NSArray*)objects;
Availability: MacOS-X 10.4.0

Replaces the values in the receiver at the locations given by the indexes set with values from the objects array.

replaceObjectsInRange: withObjectsFromArray: 

- (void) replaceObjectsInRange: (NSRange)aRange withObjectsFromArray: (NSArray*)anArray;
Availability: OpenStep

Replaces objects in the receiver with those from anArray.
Raises an exception if given a range extending beyond the array.

replaceObjectsInRange: withObjectsFromArray: range: 

- (void) replaceObjectsInRange: (NSRange)aRange withObjectsFromArray: (NSArray*)anArray range: (NSRange)anotherRange;
Availability: OpenStep

Replaces objects in the receiver with some of those from anArray.
Raises an exception if given a range extending beyond the array.

setArray: 

- (void) setArray: (NSArray*)otherArray;
Availability: OpenStep

Sets the contents of the receiver to be identical to the contents of otherArray.

setObject: atIndexedSubscript: 

- (void) setObject: (id)anObject atIndexedSubscript: (size_t)anIndex;
Availability: OpenStep

Set method called by the compiler with array subscripting.

setValue: forKey: 

- (void) setValue: (id)value forKey: (NSString*)key;
Availability: MacOS-X 10.0.0

Call setValue:forKey: on each of the receiver's items with the value and key.

sortUsingComparator: 

- (void) sortUsingComparator: (NSComparator)comparator;
Availability: MacOS-X 10.6.0

Sorts the array using the specified comparator block.

sortUsingFunction: context: 

- (void) sortUsingFunction: (NSComparisonResult(*)(id,id,void*))compare context: (void*)context;
Availability: OpenStep

Sorts the array according to the supplied compare function with the context information.

sortUsingSelector: 

- (void) sortUsingSelector: (SEL)comparator;
Availability: OpenStep

Sorts the array according to the supplied comparator.

sortWithOptions: usingComparator: 

- (void) sortWithOptions: (NSSortOptions)options usingComparator: (NSComparator)comparator;
Availability: MacOS-X 10.6.0

Sorts the array using the specified comparator block and options.


Up