adding external frameworks

Author: mrRay

external_frameworks/.DS_Store

@@ -0,0 +1 @@
+Versions/Current/Headers

external_frameworks/VVBasics.framework/Headers

@@ -0,0 +1 @@
+Versions/Current/Resources

external_frameworks/VVBasics.framework/Resources

@@ -0,0 +1 @@
+Versions/Current/VVBasics

external_frameworks/VVBasics.framework/VVBasics

@@ -0,0 +1,189 @@
+#import <TargetConditionals.h>
+#if TARGET_OS_IPHONE
+#import <UIKit/UIKit.h>
+#else
+#import <Cocoa/Cocoa.h>
+#endif
+#import <pthread.h>
+
+
+
+///	Similar to NSMutableArray, but thread-safe.  Internally, uses an NSMutableArray and a rwlock.
+/**
+\ingroup VVBasics
+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.
+*/
+
+@interface MutLockArray : NSObject <NSCopying> {
+	NSMutableArray			*array;
+	pthread_rwlock_t		arrayLock;
+}
+
+///	Creates and returns an auto-released MutLockArray with a given capacity.  The capacity may be 0.
++ (id) arrayWithCapacity:(NSInteger)c;
+///	Inits and returns a MutLockArray with a given capacity; the capacity may be 0.
+- (id) initWithCapacity:(NSInteger)c;
+- (id) init;
+
+///	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) rdlock;
+- (BOOL) tryRdLock;	//	returns YES if i got a read-lock successfully!
+///	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) wrlock;
+///	Unlocks the array.
+- (void) unlock;
+
+///	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 *) array;
+///	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 *) createArrayCopy;
+///	Returns an NSMutableArray which was created while a read-lock was established; this is threadsafe.
+- (NSMutableArray *) lockCreateArrayCopy;
+
+///	Calls "addObject" on my array; not threadsafe.
+- (void) addObject:(id)o;
+///	Establishes a write-lock, then calls "addObject" on self; threadsafe.
+- (void) lockAddObject:(id)o;
+///	Calls "addObjectsFromArray" on my array; not threadsafe.
+- (void) addObjectsFromArray:(id)a;
+///	Establishes a write-lock, then calls "addObjectsFromArray" on self; threadsafe.
+- (void) lockAddObjectsFromArray:(id)a;
+///	Calls "addObjectsFromArray" on my array; not threadsafe.
+- (void) replaceWithObjectsFromArray:(id)a;
+///	Establishes a write-lock, then calls "replaceWithObjectsFromArray" on self; threadsafe.
+- (void) lockReplaceWithObjectsFromArray:(id)a;
+///	Calls "insertObject:atIndex:" on my array; not threadsafe.
+- (BOOL) insertObject:(id)o atIndex:(NSInteger)i;
+///	Establishes a write-lock, then calls "insertObject:atIndex:" on self; threadsafe.
+- (BOOL) lockInsertObject:(id)o atIndex:(NSInteger)i;
+///	Calls "removeAllObjects" on my array; not threadsafe.
+- (void) removeAllObjects;
+///	Establishes a write-lock, then calls "removeAllObjects" on self; threadsafe.
+- (void) lockRemoveAllObjects;
+///	Calls "objectAtIndex:0" on my array; not threadsafe.
+- (id) firstObject;
+///	Establishes a read-lock, then calls "firstObject" on self; threadsafe
+- (id) lockFirstObject;
+///	Calls "removeObjectAtIndex:0" on my array; not threadsafe
+- (void) removeFirstObject;
+///	Establishes a write-lock, then calls "removeFirstObject" on self; threadsafe.
+- (void) lockRemoveFirstObject;
+///	Calls "lastObject" on my array; not threadsafe.
+- (id) lastObject;
+///	Establishes a read-lock, then calls "lastObject" on self; threadsafe.
+- (id) lockLastObject;
+///	Calls "removeLastObject" on my array; not threadsafe.
+- (void) removeLastObject;
+///	Establishes a write-lock, then calls "removeLastObject" on self; threadsafe.
+- (void) lockRemoveLastObject;
+///	Calls "removeObject:" on my array; not threadsafe.
+- (void) removeObject:(id)o;
+///	Establishes a write-lock, then calls "removeObject:" on self; threadsafe.
+- (void) lockRemoveObject:(id)o;
+///	Calls "removeObjectAtIndex:" on my array; not threadsafe.
+- (void) removeObjectAtIndex:(NSInteger)i;
+///	Establishes a write-lock, then calls "removeObjectAtIndex:" on self; threadsafe.
+- (void) lockRemoveObjectAtIndex:(NSInteger)i;
+///	Calls "removeObjectsAtIndexes:" on my array; not threadsafe.
+- (void) removeObjectsAtIndexes:(NSIndexSet *)i;
+///	Establishes a write-lock, then calls "removeObjectsAtIndexes:" on self; threadsafe.
+- (void) lockRemoveObjectsAtIndexes:(NSIndexSet *)i;
+///	Calls "removeObjectsInArray:" on my array; not threadsafe.
+- (void) removeObjectsInArray:(NSArray *)otherArray;
+///	Establishes a write-lock, then calls "removeObjectsInArray:" on self; threadsafe.
+- (void) lockRemoveObjectsInArray:(NSArray *)otherArray;
+///	Calls "removeIdenticalPtrsInArray:" on my array; not threadsafe
+- (void) removeIdenticalPtrsInArray:(NSArray *)a;
+///	Establishes a write-lock, then calls "removeIdenticalPtrsInArray:" on self; threadsafe.
+- (void) lockRemoveIdenticalPtrsInArray:(NSArray *)a;
+
+///	Calls "replaceObjectsAtIndexes:withObjects" on my array; not threadsafe.
+- (void) replaceObjectsAtIndexes:(NSIndexSet *)indexes withObjects:(NSArray *)objects;
+//	Establishes a write-lock, then calls "replaceObjectsAtIndexes:withObjects on self; threadsafe
+- (void) lockReplaceObjectsAtIndexes:(NSIndexSet *)indexes withObjects:(NSArray *)objects;
+
+///	Calls "valueForKey:" on my array; not threadsafe.
+- (id) valueForKey:(NSString *)key;
+///	Establishes a read-lock, then calls "valueForKey:" on self; threadsafe.
+- (id) lockValueForKey:(NSString *)key;
+
+
+///	Calls "containsObject:" on my array; not threadsafe.
+- (BOOL) containsObject:(id)o;
+///	Establishes a read-lock, then calls "containsObject:" on self; threadsafe.
+- (BOOL) lockContainsObject:(id)o;
+///	Calls "objectAtIndex:" on my array; not threadsafe.
+- (id) objectAtIndex:(NSInteger)i;
+///	Establishes a read-lock, then calls "objectAtIndex:" on self; threadsafe.
+- (id) lockObjectAtIndex:(NSInteger)i;
+///	Calls "objectsAtIndexes:" on my array; not threadsafe.
+- (NSArray *) objectsAtIndexes:(NSIndexSet *)indexes;
+///	Establishes a read-lock, then calls "objectsAtIndexes:" on self; threadsafe.
+- (NSArray *) lockObjectsAtIndexes:(NSIndexSet *)indexes;
+///	Calls "indexOfObject:" on my array; not threadsafe.
+- (NSInteger) indexOfObject:(id)o;
+///	Establishes a read-lock, then calls "indexOfObject:" on self; threadsafe.
+- (NSInteger) lockIndexOfObject:(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.
+- (BOOL) containsIdenticalPtr:(id)o;
+///	Establishes a read-lock, then calls "containsIdenticalPtr:" on self; threadsafe.
+- (BOOL) lockContainsIdenticalPtr:(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.
+- (long) indexOfIdenticalPtr:(id)o;
+///	Establishes a read-lock, then calls "indexOfIdenticalPtr:" on self; threadsafe.
+- (long) lockIndexOfIdenticalPtr:(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.
+- (void) removeIdenticalPtr:(id)o;
+///	Establishes a write-lock, then calls "removeIdenticalPtr:" on self; threadsafe.
+- (void) lockRemoveIdenticalPtr:(id)o;
+
+//	Calls "filteredArrayUsingPredicate:" on my array; not threadsafe
+- (NSArray *)filteredArrayUsingPredicate:(NSPredicate *)predicate;
+//	Establishes a read-lock, then calls "filteredArrayUsingPredicate:" on self; threadsafe
+- (NSArray *) lockFilteredArrayUsingPredicate:(NSPredicate *)predicate;
+
+///	Calls "makeObjectsPerformSelector:" on my array; not threadsafe.
+- (void) makeObjectsPerformSelector:(SEL)s;
+///	Establishes a read-lock, then calls "makeObjectsPerformSelector:" on self; threadsafe.
+- (void) lockMakeObjectsPerformSelector:(SEL)s;
+///	Calls "makeObjectsPerformSelector:withObject:" on my array; not threadsafe.
+- (void) makeObjectsPerformSelector:(SEL)s withObject:(id)o;
+///	Establishes a read-lock, then calls "makeObjectsPerformSelector:withObject:" on self; threadsafe.
+- (void) lockMakeObjectsPerformSelector:(SEL)s withObject:(id)o;
+
+
+
+/*
+- (void) makeCopyPerformSelector:(SEL)s;
+- (void) lockMakeCopyPerformSelector:(SEL)s;
+- (void) makeCopyPerformSelector:(SEL)s withObject:(id)o;
+- (void) lockMakeCopyPerformSelector:(SEL)s withObject:(id)o;
+*/
+
+
+
+///	Calls "sortUsingSelector:" on my array; not threadsafe.
+- (void) sortUsingSelector:(SEL)s;
+///	Establishes a write-lock, then calls "sortUsingSelector:" on self; threadsafe.
+- (void) lockSortUsingSelector:(SEL)s;
+
+///	Calls "sortUsingDescriptors:" on my array; not threadsafe.
+- (void) sortUsingDescriptors:(NSArray *)descriptors;
+///	Establishes a write-lock, then calls "sortUsingDescriptors:" on self; threadsafe.
+- (void) lockSortUsingDescriptors:(NSArray *)descriptors;
+
+- (void) sortUsingComparator:(NSComparator)c;
+- (void) lockSortUsingComparator:(NSComparator)c;
+
+- (NSEnumerator *) objectEnumerator;
+- (NSEnumerator *) reverseObjectEnumerator;
+- (long) count;
+- (long) lockCount;
+
+@end

external_frameworks/VVBasics.framework/Versions/A/Headers/MutLockArray.h

@@ -0,0 +1,86 @@
+#import <TargetConditionals.h>
+#if TARGET_OS_IPHONE
+#import <UIKit/UIKit.h>
+#else
+#import <Cocoa/Cocoa.h>
+#endif
+#import <pthread.h>
+
+
+
+///	MutLockDict is a thread-safe version of NSMutableDictionary.
+/*!
+\ingroup VVBasics
+This class exists because NSMutableDictionary 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.  This class has methods which allow you to work with a mutable dictionary in a transparent and thread-safe manner.
+*/
+
+@interface MutLockDict : NSObject {
+	NSMutableDictionary		*dict;
+	pthread_rwlock_t		dictLock;
+}
+
+///	functions similarly to the NSDictionary method
++ (id) dictionaryWithCapacity:(NSInteger)c;
+///	functions similarly to the NSDictionary method- creates and returns an auto-released instance of MutLockDict populated with the contents of the passed dictionary
++ (id) dictionaryWithDict:(NSDictionary *)d;
+///	functions similarly to the NSDictionary method- inits a MutLockDict with the supplied capacity
+- (id) initWithCapacity:(NSInteger)c;
+
+///	blocks until it can establish a read-lock on the array, and then returns.  try to avoid calling this- using the built-in methods (which unlock before they return) is generally preferable/safer!
+- (void) rdlock;
+///	blocks until it can establish a write-lock on the array, and then returns.  try to avoid calling this- using the built-in methods (which unlock before they return) is generally preferable/safer!
+- (void) wrlock;
+///	unlocks and returns immediately
+- (void) unlock;
+
+///	returns the NSMutableDictionary used as the basis for this class- useful if you want to use fast iteration/that sort of thing
+- (NSMutableDictionary *) dict;
+///	creates a mutable, autoreleased copy of the dict and returns it.  be careful, this method isn't threadsafe!
+- (NSMutableDictionary *) createDictCopy;
+///	creates a mutable, autoreleased copy of the dict and returns it.  this method is threadsafe.
+- (NSMutableDictionary *) lockCreateDictCopy;
+
+///	functions similar to the NSDictionary method, but checks to make sure you aren't trying to insert a nil value or use a nil key.  not threadsafe!
+- (void) setObject:(id)o forKey:(NSString *)s;
+///	establishes a write-lock, then calls setObject:forKey:.  threadsafe.
+- (void) lockSetObject:(id)o forKey:(NSString *)s;
+///	functions similar to the NSDictionary method- not threadsafe
+- (void) setValue:(id)v forKey:(NSString *)s;
+///	establishes a write-lock, then calls setValue:forKey:.  threadsafe.
+- (void) lockSetValue:(id)v forKey:(NSString *)s;
+///	removes all objects from the underlying dict- not threadsafe
+- (void) removeAllObjects;
+///	establishes a write-lock, then removes all objects from the underlying dict.  threadsafe.
+- (void) lockRemoveAllObjects;
+///	returns the object stored in the underlying dict at the passed key- not threadsafe
+- (id) objectForKey:(NSString *)k;
+///	establihes a read-lock, then returns the object stored in the underlying dict at the passed key.  threadsafe.
+- (id) lockObjectForKey:(NSString *)k;
+///	attempts to remove any object stored in the underlying dict at the passed key- not threadsafe.
+- (void) removeObjectForKey:(NSString *)k;
+///	establishes a write-lock, then removes any object stored in the underlying dict at the passed key.  threadsafe.
+- (void) lockRemoveObjectForKey:(NSString *)k;
+///	adds all entries from the passed dict to the receiver's underlying dictionary- not threadsafe.
+- (void) addEntriesFromDictionary:(NSDictionary *)otherDictionary;
+///	establishes a write-lock, then calls "addEntriesFromDictionary:".  threadsafe.
+- (void) lockAddEntriesFromDictionary:(NSDictionary *)otherDictionary;
+///	returns an array with all the keys from the underlying dictionary- not threadsafe
+- (NSArray *) allKeys;
+///	establishes a read-lock, then calls "allKeys".  threadsafe.
+- (NSArray *) lockAllKeys;
+///	returns an array with all the values from the underlying dictionary- not threadsafe.
+- (NSArray *) allValues;
+///	establishes a read-lock, then calls "allValues".  threadsafe.
+- (NSArray *) lockAllValues;
+
+///	calls "makeObjectsPerformSelector" on the array of values returned by the underlying dictionary- not threadsafe.
+- (void) makeObjectsPerformSelector:(SEL)s;
+///	establishes a read-lock, then calls "makeObjectsPerformSelector:".  threadsafe.
+- (void) lockMakeObjectsPerformSelector:(SEL)s;
+
+///	returns the number of objects in the underlying dictionary- not threadsafe.
+- (NSInteger) count;
+///	establishes a read-lock, then returns the number of objects in the underlying dictionary.  threadsafe.
+- (NSInteger) lockCount;
+
+@end

external_frameworks/VVBasics.framework/Versions/A/Headers/MutLockDict.h

@@ -0,0 +1,53 @@
+#import <TargetConditionals.h>
+#if TARGET_OS_IPHONE
+#import <UIKit/UIKit.h>
+#else
+#import <Cocoa/Cocoa.h>
+#endif
+
+#import "MutLockArray.h"
+#import "ObjectHolder.h"
+
+
+
+///	Subclass of MutLockArray; this class does NOT retain the objects in its array!
+/**
+\ingroup VVBasics
+this class exists because i frequently find myself in situations where i want to add an instance of an object to an array/dict/[any class which retains the passed instance], but i don't actually want the item to be retained.
+
+Instead of adding (and therefore retaining) objects to an array like my superclass, this class makes an ObjectHolder for objects which are added to it (so they don't get retained), and adds the ObjectHolder to me.  when other classes ask me for the index of an object, or ask for the object at a particular index, i'll find the relevant ObjectHolder and then return the object it's storing.
+*/
+
+@interface MutNRLockArray : MutLockArray {
+}
+
++ (id) arrayWithCapacity:(NSInteger)c;
+
+- (NSMutableArray *) createArrayCopy;
+- (NSMutableArray *) lockCreateArrayCopyFromObjects;
+- (NSMutableArray *) createArrayCopyFromObjects;
+- (void) addObject:(id)o;
+- (void) addObjectsFromArray:(id)a;
+- (void) replaceWithObjectsFromArray:(id)a;
+- (BOOL) insertObject:(id)o atIndex:(NSInteger)i;
+- (id) lastObject;
+- (void) removeObject:(id)o;
+- (BOOL) containsObject:(id)o;
+- (id) objectAtIndex:(NSInteger)i;
+- (NSArray *) objectsAtIndexes:(NSIndexSet *)indexes;
+- (NSInteger) indexOfObject:(id)o;
+- (BOOL) containsIdenticalPtr:(id)o;
+- (long) indexOfIdenticalPtr:(id)o;
+- (void) removeIdenticalPtr:(id)o;
+
+//	these methods exist because the lookup cost for an ObjectHolder can be significant for high-performance applications- these methods get the object from the ObjectHolder and call the method directly on it!
+- (void) bruteForceMakeObjectsPerformSelector:(SEL)s;
+- (void) lockBruteForceMakeObjectsPerformSelector:(SEL)s;
+- (void) bruteForceMakeObjectsPerformSelector:(SEL)s withObject:(id)o;
+- (void) lockBruteForceMakeObjectsPerformSelector:(SEL)s withObject:(id)o;
+
+- (void) lockPurgeEmptyHolders;
+- (void) purgeEmptyHolders;
+
+
+@end

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

@@ -0,0 +1,33 @@
+#import <TargetConditionals.h>
+#if TARGET_OS_IPHONE
+#import <UIKit/UIKit.h>
+#else
+#import <Cocoa/Cocoa.h>
+#endif
+
+#import "MutLockDict.h"
+#import "ObjectHolder.h"
+
+
+
+///	Subclass of MutLockDict; this class does NOT retain the objects in its array!
+/**
+\ingroup VVBasics
+this class exists because i frequently find myself in situations where i want to add an instance of an object to an array/dict/[any class which retains the passed instance], but i don't actually want the item to be retained.
+
+Instead of adding (and therefore retaining) objects to an array like my superclass, this class makes an ObjectHolder for objects which are added to it (so they don't get retained), and adds the ObjectHolder to me.  when other classes ask me for the index of an object, or ask for the object at a particular index, i'll find the relevant ObjectHolder and then return the object it's storing.
+*/
+
+
+@interface MutNRLockDict : MutLockDict {
+
+}
+
+
+- (void) setObject:(id)o forKey:(NSString *)s;
+- (void) setValue:(id)v forKey:(NSString *)s;
+- (id) objectForKey:(NSString *)k;
+- (void) addEntriesFromDictionary:(id)otherDictionary;
+- (NSArray *) allValues;
+
+@end