MutNRLockArray Class Reference

Subclass of MutLockArray; this class does NOT retain the objects in its array! More...

#include <MutNRLockArray.h>

Inheritance diagram for MutNRLockArray:

Collaboration diagram for MutNRLockArray:

Instance Methods
(NSMutableArray *)	- createArrayCopy
	Returns an NSMutableArray which was created by calling "mutableCopy" on my array. Again, it's possible to do something which ISN'T threadsafe by calling this...
(NSMutableArray *)	- createArrayCopyFromObjects
(void)	- addObject:
	Calls "addObject" on my array; not threadsafe.
(void)	- addObjectsFromArray:
	Calls "addObjectsFromArray" on my array; not threadsafe.
(void)	- replaceWithObjectsFromArray:
	Calls "addObjectsFromArray" on my array; not threadsafe.
(void)	- insertObject:atIndex:
	Calls "insertObject:atIndex:" on my array; not threadsafe.
(id)	- lastObject
	Calls "lastObject" on my array; not threadsafe.
(void)	- removeObject:
	Calls "removeObject:" on my array; not threadsafe.
(BOOL)	- containsObject:
	Calls "containsObject:" on my array; not threadsafe.
(id)	- objectAtIndex:
	Calls "objectAtIndex:" on my array; not threadsafe.
(NSArray *)	- objectsAtIndexes:
	Calls "objectsAtIndexes:" on my array; not threadsafe.
(NSUInteger)	- indexOfObject:
	Calls "indexOfObject:" on my array; not threadsafe.
(BOOL)	- containsIdenticalPtr:
	Enumerates through my array- compares the address of each item in the array to the passed pointer. Unlike NSMutableArray, this method does NOT call isEqualTo:, it's just a simple == operator.
(long)	- indexOfIdenticalPtr:
	Enumerates through my array- compares the address of each item in the array to the passed pointer. Unlike NSMutableArray, this method does NOT call isEqualTo:, it's just a simple == operator.
(void)	- removeIdenticalPtr:
	Locates an item in my array by enumerating through it and comparing the address of each item in the array to the passed ptr, and then deletes the matching item from the array; not threadsafe.
(void)	- bruteForceMakeObjectsPerformSelector:
(void)	- lockBruteForceMakeObjectsPerformSelector:
(void)	- bruteForceMakeObjectsPerformSelector:withObject:
(void)	- lockBruteForceMakeObjectsPerformSelector:withObject:
Instance Methods inherited from MutLockArray
(id)	- initWithCapacity:
	Inits and returns a MutLockArray with a given capacity; the capacity may be 0.
(id)	- init
(void)	- rdlock
	Establishes a read-lock for the array; multiple read locks may exist simultaneously (if it's not changing, anything can look at the contents of the array). This method does not return until it has been able to get the lock.
(void)	- wrlock
	Establishes a write-lock for the array. Only one write-lock may exist at any given time, and all read-locks must be relinquished before the write-lock may be established (if you're going to change the array, nothing else can be changing or observing it).
(void)	- unlock
	Unlocks the array.
(NSMutableArray *)	- array
	Returns the NSMutableArray with everything in it. This returns the actual array, so be careful- it's possible to do something which ISN'T threadsafe with this...
(NSMutableArray *)	- lockCreateArrayCopy
	Returns an NSMutableArray which was created while a read-lock was established; this is threadsafe.
(void)	- lockAddObject:
	Establishes a write-lock, then calls "addObject" on self; threadsafe.
(void)	- lockAddObjectsFromArray:
	Establishes a write-lock, then calls "addObjectsFromArray" on self; threadsafe.
(void)	- lockReplaceWithObjectsFromArray:
	Establishes a write-lock, then calls "replaceWithObjectsFromArray" on self; threadsafe.
(void)	- lockInsertObject:atIndex:
	Establishes a write-lock, then calls "insertObject:atIndex:" on self; threadsafe.
(void)	- removeAllObjects
	Calls "removeAllObjects" on my array; not threadsafe.
(void)	- lockRemoveAllObjects
	Establishes a write-lock, then calls "removeAllObjects" on self; threadsafe.
(id)	- firstObject
	Calls "objectAtIndex:0" on my array; not threadsafe.
(id)	- lockFirstObject
	Establishes a read-lock, then calls "firstObject" on self; threadsafe.
(void)	- removeFirstObject
	Calls "removeObjectAtIndex:0" on my array; not threadsafe.
(void)	- lockRemoveFirstObject
	Establishes a write-lock, then calls "removeFirstObject" on self; threadsafe.
(id)	- lockLastObject
	Establishes a read-lock, then calls "lastObject" on self; threadsafe.
(void)	- removeLastObject
	Calls "removeLastObject" on my array; not threadsafe.
(void)	- lockRemoveLastObject
	Establishes a write-lock, then calls "removeLastObject" on self; threadsafe.
(void)	- lockRemoveObject:
	Establishes a write-lock, then calls "removeObject:" on self; threadsafe.
(void)	- removeObjectAtIndex:
	Calls "removeObjectAtIndex:" on my array; not threadsafe.
(void)	- lockRemoveObjectAtIndex:
	Establishes a write-lock, then calls "removeObjectAtIndex:" on self; threadsafe.
(void)	- removeObjectsAtIndexes:
	Calls "removeObjectsAtIndexes:" on my array; not threadsafe.
(void)	- lockRemoveObjectsAtIndexes:
	Establishes a write-lock, then calls "removeObjectsAtIndexes:" on self; threadsafe.
(void)	- removeObjectsInArray:
	Calls "removeObjectsInArray:" on my array; not threadsafe.
(void)	- lockRemoveObjectsInArray:
	Establishes a write-lock, then calls "removeObjectsInArray:" on self; threadsafe.
(void)	- removeIdenticalPtrsInArray:
	Calls "removeIdenticalPtrsInArray:" on my array; not threadsafe.
(void)	- lockRemoveIdenticalPtrsInArray:
	Establishes a write-lock, then calls "removeIdenticalPtrsInArray:" on self; threadsafe.
(void)	- replaceObjectsAtIndexes:withObjects:
	Calls "replaceObjectsAtIndexes:withObjects" on my array; not threadsafe.
(void)	- lockReplaceObjectsAtIndexes:withObjects:
(id)	- valueForKey:
	Calls "valueForKey:" on my array; not threadsafe.
(id)	- lockValueForKey:
	Establishes a read-lock, then calls "valueForKey:" on self; threadsafe.
(BOOL)	- lockContainsObject:
	Establishes a read-lock, then calls "containsObject:" on self; threadsafe.
(id)	- lockObjectAtIndex:
	Establishes a read-lock, then calls "objectAtIndex:" on self; threadsafe.
(NSArray *)	- lockObjectsAtIndexes:
	Establishes a read-lock, then calls "objectsAtIndexes:" on self; threadsafe.
(NSUInteger)	- lockIndexOfObject:
	Establishes a read-lock, then calls "indexOfObject:" on self; threadsafe.
(BOOL)	- lockContainsIdenticalPtr:
	Establishes a read-lock, then calls "containsIdenticalPtr:" on self; threadsafe.
(int)	- lockIndexOfIdenticalPtr:
	Establishes a read-lock, then calls "indexOfIdenticalPtr:" on self; threadsafe.
(void)	- lockRemoveIdenticalPtr:
	Establishes a write-lock, then calls "removeIdenticalPtr:" on self; threadsafe.
(NSArray *)	- filteredArrayUsingPredicate:
(NSArray *)	- lockFilteredArrayUsingPredicate:
(void)	- makeObjectsPerformSelector:
	Calls "makeObjectsPerformSelector:" on my array; not threadsafe.
(void)	- lockMakeObjectsPerformSelector:
	Establishes a read-lock, then calls "makeObjectsPerformSelector:" on self; threadsafe.
(void)	- makeObjectsPerformSelector:withObject:
	Calls "makeObjectsPerformSelector:withObject:" on my array; not threadsafe.
(void)	- lockMakeObjectsPerformSelector:withObject:
	Establishes a read-lock, then calls "makeObjectsPerformSelector:withObject:" on self; threadsafe.
(void)	- sortUsingSelector:
	Calls "sortUsingSelector:" on my array; not threadsafe.
(void)	- lockSortUsingSelector:
	Establishes a write-lock, then calls "sortUsingSelector:" on self; threadsafe.
(void)	- sortUsingDescriptors:
	Calls "sortUsingDescriptors:" on my array; not threadsafe.
(void)	- lockSortUsingDescriptors:
	Establishes a write-lock, then calls "sortUsingDescriptors:" on self; threadsafe.
(NSEnumerator *)	- objectEnumerator
(NSEnumerator *)	- reverseObjectEnumerator
(NSUInteger)	- count
(NSUInteger)	- lockCount

Class Methods
(id)	+ arrayWithCapacity:
	Creates and returns an auto-released MutLockArray with a given capacity. The capacity may be 0.

Additional Inherited Members
Protected Attributes inherited from MutLockArray
NSMutableArray *	array
pthread_rwlock_t	arrayLock

Detailed Description

Subclass of MutLockArray; this class does NOT retain the objects in its array!

Definition at line 20 of file MutNRLockArray.h.

Method Documentation

addObject:

- (void) addObject:

(id)

o

Calls "addObject" on my array; not threadsafe.

Implements MutLockArray.

addObjectsFromArray:

- (void) addObjectsFromArray:

(id)

a

Calls "addObjectsFromArray" on my array; not threadsafe.

Implements MutLockArray.

arrayWithCapacity:

+ (id) arrayWithCapacity:

(NSUInteger)

c

Creates and returns an auto-released MutLockArray with a given capacity. The capacity may be 0.

Implements MutLockArray.

bruteForceMakeObjectsPerformSelector:

- (void) bruteForceMakeObjectsPerformSelector:

(SEL)

s

bruteForceMakeObjectsPerformSelector:withObject:

- (void) bruteForceMakeObjectsPerformSelector:		(SEL)	s
withObject:		(id)	o

containsIdenticalPtr:

- (BOOL) containsIdenticalPtr:

(id)

o

Enumerates through my array- compares the address of each item in the array to the passed pointer. Unlike NSMutableArray, this method does NOT call isEqualTo:, it's just a simple == operator.

Implements MutLockArray.

containsObject:

- (BOOL) containsObject:

(id)

o

Calls "containsObject:" on my array; not threadsafe.

Implements MutLockArray.

createArrayCopy

- (NSMutableArray *) createArrayCopy

Returns an NSMutableArray which was created by calling "mutableCopy" on my array. Again, it's possible to do something which ISN'T threadsafe by calling this...

Implements MutLockArray.

Here is the call graph for this function:

Here is the caller graph for this function:

createArrayCopyFromObjects

- (NSMutableArray *) createArrayCopyFromObjects

Here is the call graph for this function:

Here is the caller graph for this function:

indexOfIdenticalPtr:

- (long) indexOfIdenticalPtr:

(id)

o

Enumerates through my array- compares the address of each item in the array to the passed pointer. Unlike NSMutableArray, this method does NOT call isEqualTo:, it's just a simple == operator.

Implements MutLockArray.

indexOfObject:

- (NSUInteger) indexOfObject:

(id)

o

Calls "indexOfObject:" on my array; not threadsafe.

Implements MutLockArray.

insertObject:atIndex:

- (void) insertObject:		(id)	o
atIndex:		(NSUInteger)	i

Calls "insertObject:atIndex:" on my array; not threadsafe.

Implements MutLockArray.

lastObject

- (id) lastObject

Calls "lastObject" on my array; not threadsafe.

Implements MutLockArray.

Here is the call graph for this function:

Here is the caller graph for this function:

lockBruteForceMakeObjectsPerformSelector:

- (void) lockBruteForceMakeObjectsPerformSelector:

(SEL)

s

lockBruteForceMakeObjectsPerformSelector:withObject:

- (void) lockBruteForceMakeObjectsPerformSelector:		(SEL)	s
withObject:		(id)	o

objectAtIndex:

- (id) objectAtIndex:

(NSUInteger)

i

Calls "objectAtIndex:" on my array; not threadsafe.

Implements MutLockArray.

objectsAtIndexes:

- (NSArray *) objectsAtIndexes:

(NSIndexSet *)

indexes

Calls "objectsAtIndexes:" on my array; not threadsafe.

Implements MutLockArray.

removeIdenticalPtr:

- (void) removeIdenticalPtr:

(id)

o

Locates an item in my array by enumerating through it and comparing the address of each item in the array to the passed ptr, and then deletes the matching item from the array; not threadsafe.

Implements MutLockArray.

removeObject:

- (void) removeObject:

(id)

o

Calls "removeObject:" on my array; not threadsafe.

Implements MutLockArray.

replaceWithObjectsFromArray:

- (void) replaceWithObjectsFromArray:

(id)

a

Calls "addObjectsFromArray" on my array; not threadsafe.

Implements MutLockArray.

---

The documentation for this class was generated from the following file:

• VVBasics.framework/Versions/A/Headers/MutNRLockArray.h