MutLockArray Class Reference

Similar to NSMutableArray, but thread-safe. Internally, uses an NSMutableArray and a rwlock. More...

#import <MutLockArray.h>

Inherits NSObject.

Inherited by MutNRLockArray.

Instance Methods
(id)	- initWithCapacity:
	Inits and returns a MutLockArray with a given capacity; the capacity may be 0.
(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 *)	- 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 *)	- lockCreateArrayCopy
	Returns an NSMutableArray which was created while a read-lock was established; this is threadsafe.
(void)	- addObject:
	Calls "addObject" on my array; not threadsafe.
(void)	- lockAddObject:
	Establishes a write-lock, then calls "addObject" on self; threadsafe.
(void)	- addObjectsFromArray:
	Calls "addObjectsFromArray" on my array; not threadsafe.
(void)	- lockAddObjectsFromArray:
	Establishes a write-lock, then calls "addObjectsFromArray" on self; threadsafe.
(void)	- replaceWithObjectsFromArray:
	Calls "addObjectsFromArray" on my array; not threadsafe.
(void)	- lockReplaceWithObjectsFromArray:
	Establishes a write-lock, then calls "replaceWithObjectsFromArray" on self; threadsafe.
(BOOL)	- insertObject:atIndex:
	Calls "insertObject:atIndex:" on my array; not threadsafe.
(BOOL)	- 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)	- lastObject
	Calls "lastObject" on my array; not 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)	- removeObject:
	Calls "removeObject:" on my array; not 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.
(id)	- valueForKey:
	Calls "valueForKey:" on my array; not threadsafe.
(id)	- lockValueForKey:
	Establishes a read-lock, then calls "valueForKey:" on self; threadsafe.
(BOOL)	- containsObject:
	Calls "containsObject:" on my array; not threadsafe.
(BOOL)	- lockContainsObject:
	Establishes a read-lock, then calls "containsObject:" on self; threadsafe.
(id)	- objectAtIndex:
	Calls "objectAtIndex:" on my array; not threadsafe.
(id)	- lockObjectAtIndex:
	Establishes a read-lock, then calls "objectAtIndex:" on self; threadsafe.
(NSArray *)	- objectsAtIndexes:
	Calls "objectsAtIndexes:" on my array; not threadsafe.
(NSArray *)	- lockObjectsAtIndexes:
	Establishes a read-lock, then calls "objectsAtIndexes:" on self; threadsafe.
(NSInteger)	- indexOfObject:
	Calls "indexOfObject:" on my array; not threadsafe.
(NSInteger)	- lockIndexOfObject:
	Establishes a read-lock, then calls "indexOfObject:" on self; 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.
(BOOL)	- lockContainsIdenticalPtr:
	Establishes a read-lock, then calls "containsIdenticalPtr:" on self; threadsafe.
(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.
(long)	- lockIndexOfIdenticalPtr:
	Establishes a read-lock, then calls "indexOfIdenticalPtr:" on self; threadsafe.
(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)	- lockRemoveIdenticalPtr:
	Establishes a write-lock, then calls "removeIdenticalPtr:" on self; threadsafe.
(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.

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

Detailed Description

Similar to NSMutableArray, but thread-safe. Internally, uses an NSMutableArray and a rwlock.

This class exists because NSMutableArray is not thread-safe by default: if you call methods on it from two different threads at the same time, it will try to execute both, often crashing in the process. I found myself writing a lot of lock/array pairs, so simplified everything by combining them into a single class. MutLockArray has methods which allow you to work with a mutable array in a transparent and thread-safe manner- it will automatically establish the read-/write-locks necessary to perform the relevant task. By avoiding the "lock" methods, you can also work with the array without performing any locking- so you can get a read-/write-lock, perform a number of actions, and then unlock.

It is important to remember, when working with it, that MutLockArray is NOT a subclass of NSMutableArray; rather, it is a subclass of NSObject with an instance of an NSMutableArray and a rwlock for working with it safely. This means that you can't pass an instance of MutLockArray to anything which is expecting to be passed an NSMutableArray- internally, apple's frameworks will probably be doing some dark voodoo bullshit which will result in a spectacular failure. If you want to work with an actual NSMutableArray, check out the "array", "createArrayCopy", and "lockCreateArrayCopy" methods below.

...and remember- when looking for stuff in an NSMutableArray, the array will use the "isEqualTo:" comparator method, which is slower than comparing the address of two pointers. if you know the pointer address hasn't changed (if you're not working with NSStrings), use the "indexOfIdenticalPtr", "removeIdenticalPtr", etc. methods to work with the array.

---

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

• VVBasics/src/MutLockArray.h
• VVBasics/src/MutLockArray.m