motion-yapper 0.0.3 → 0.1.0

data/vendor/Pods/YapDatabase/YapDatabase/Extensions/Views/YapDatabaseViewTypes.h

@@ -1,99 +0,0 @@
-#import <Foundation/Foundation.h>
-
-
-/**
- * The grouping block handles both filtering and grouping.
- * 
- * When you add or update rows in the databse the grouping block is invoked.
- * Your grouping block can inspect the row and determine if it should be a part of the view.
- * If not, your grouping block simply returns 'nil' and the object is excluded from the view (removing it if needed).
- * Otherwise your grouping block returns a group, which can be any string you want.
- * Once the view knows what group the row belongs to,
- * it will then determine the position of the row within the group (using the sorting block).
- * 
- * You should choose a block type that takes the minimum number of required parameters.
- * The view can make various optimizations based on required parameters of the block.
-**/
-typedef id YapDatabaseViewGroupingBlock; // One of the YapDatabaseViewGroupingX types below.
-
-typedef NSString* (^YapDatabaseViewGroupingWithKeyBlock)(NSString *collection, NSString *key);
-typedef NSString* (^YapDatabaseViewGroupingWithObjectBlock)(NSString *collection, NSString *key, id object);
-typedef NSString* (^YapDatabaseViewGroupingWithMetadataBlock)(NSString *collection, NSString *key, id metadata);
-typedef NSString* (^YapDatabaseViewGroupingWithRowBlock)(NSString *collection, NSString *key, id object, id metadata);
-
-
-/**
- * The sorting block handles sorting of objects within their group.
- *
- * After the view invokes the grouping block to determine what group a database row belongs to (if any),
- * the view then needs to determine what index within that group the row should be.
- * In order to do this, it needs to compare the new/updated row with existing rows in the same view group.
- * This is what the sorting block is used for.
- * So the sorting block will be invoked automatically during this process until the view has come to a conclusion.
- * 
- * You should choose a block type that takes the minimum number of required parameters.
- * The view can make various optimizations based on required parameters of the block.
- * 
- * For example, if sorting is based on the object, and the metadata of a row is updated,
- * then the view can deduce that the index hasn't changed (if the group hans't), and can skip this step.
- * 
- * Performance Note:
- * 
- * The view uses various optimizations (based on common patterns)
- * to reduce the number of times it needs to invoke the sorting block.
- *
- * - Pattern      : row is updated, but its index in the view doesn't change.
- *   Optimization : if an updated row doesn't change groups, the view will first compare it with
- *                  objects to the left and right.
- *
- * - Pattern      : rows are added to the beginning or end or a view
- *   Optimization : if the last change put an object at the beginning of the view, then it will test this quickly.
- *                  if the last change put an object at the end of the view, then it will test this quickly.
- * 
- * These optimizations offer huge performance benefits to many common cases.
- * For example, adding objects to a view that are sorted by timestamp of when they arrived.
- *
- * The optimizations are not always performed.
- * That is, if the row is added to a group it didn't previously belong,
- * or if the last change didn't place an item at the beginning or end of the view.
- *
- * If optimizations fail, or are skipped, then the view uses a binary search algorithm.
- * 
- * Although this may be considered "internal information",
- * I feel it is important to explain for the following reason:
- * 
- * Another common pattern is to fetch a number of objects in a batch, and then insert them into the database.
- * Now imagine a situation in which the view is sorting posts based on timestamp,
- * and you just fetched the most recent 10 posts. You can enumerate these 10 posts in forwards or backwards
- * while adding them to the database. One direction will hit the optimization every time. The other will cause
- * the view to perform a binary search every time. These little one-liner optimzations are easy.
-**/
-typedef id YapDatabaseViewSortingBlock; // One of the YapDatabaseViewSortingX types below.
-
-typedef NSComparisonResult (^YapDatabaseViewSortingWithKeyBlock) \
-                 (NSString *group, NSString *collection1, NSString *key1, \
-                                   NSString *collection2, NSString *key2);
-typedef NSComparisonResult (^YapDatabaseViewSortingWithObjectBlock) \
-                 (NSString *group, NSString *collection1, NSString *key1, id object1, \
-                                   NSString *collection2, NSString *key2, id object2);
-typedef NSComparisonResult (^YapDatabaseViewSortingWithMetadataBlock) \
-                 (NSString *group, NSString *collection1, NSString *key1, id metadata, \
-                                   NSString *collection2, NSString *key2, id metadata2);
-typedef NSComparisonResult (^YapDatabaseViewSortingWithRowBlock) \
-                 (NSString *group, NSString *collection1, NSString *key1, id object1, id metadata1, \
-                                   NSString *collection2, NSString *key2, id object2, id metadata2);
-
-
-/**
- * I wish there was a way to inspect a given block and see what kind of parameters it takes.
- * Sadly this does not appear to be possible (at least not in any kind of standard legal way).
- * 
- * Thus you will have to specify what kind of block you're passing.
-**/
-typedef enum {
-	YapDatabaseViewBlockTypeWithKey       = 1,
-	YapDatabaseViewBlockTypeWithObject    = 2,
-	YapDatabaseViewBlockTypeWithMetadata  = 3,
-	YapDatabaseViewBlockTypeWithRow       = 4
-} YapDatabaseViewBlockType;
-

data/vendor/Pods/YapDatabase/YapDatabase/Internal/NSDictionary+YapDatabase.h

@@ -1,8 +0,0 @@
-#import <Foundation/Foundation.h>
-
-
-@interface NSDictionary (YapDatabase)
-
-- (BOOL)ydb_containsKey:(id)key;
-
-@end

data/vendor/Pods/YapDatabase/YapDatabase/Internal/NSDictionary+YapDatabase.m

@@ -1,19 +0,0 @@
-#import "NSDictionary+YapDatabase.h"
-
-
-@implementation NSDictionary (YapDatabase)
-
-/**
- * Originally I named this method simply 'containsKey:'.
- * But then immediately got a stack overflow when using the category.
- * 
- * Apparently Apple's code actually registers the 'containsKey:' method in the objective-c space.
- * And invoking CFDictionaryContainsKey results in a method call back to our 'containsKey:' method,
- * and thus we get an infinite loop.
-**/
-- (BOOL)ydb_containsKey:(id)key
-{
-	return CFDictionaryContainsKey((CFDictionaryRef)self, (const void *)key);
-}
-
-@end

data/vendor/Pods/YapDatabase/YapDatabase/Internal/YapCache.h

@@ -1,91 +0,0 @@
-#import <Foundation/Foundation.h>
-
-#define YAP_CACHE_STATISTICS 0
-
-/**
- * YapCache implements a simple strict cache.
- *
- * It is very similar to NSCache and shares a similar API.
- * However, YapCache implements a strict countLimit and monitors usage so eviction is properly ordered.
- *
- * For example:
- * If you set a countLimit of 4, then when you add the 5th item to the cache, another item is automatically evicted.
- * It doesn't happen at a later time as with NSCache. It happens atomically during the addition of the 5th item.
- 
- * Which item gets evicted? That depends entirely on usage.
- * YapCache maintains a doubly linked-list of keys ordered by access.
- * The most recently accessed key is at the front of the linked-list,
- * and the least recently accessed key is at the back.
- * So it's very quick and efficient to evict items based on recent usage.
- *
- * YapCache is NOT thread-safe.
- * It is designed to be used by the various YapDatabase classes, which inherently serialize access to the cache.
-**/
-
-@interface YapCache : NSObject
-
-/**
- * Initializes a cache.
- *
- * Since the countLimit is a common configuration, it may optionally be passed during initialization.
- * This is also used as a hint internally when initializing components (i.e. [NSMutableDictionary initWithCapacity:]).
-**/
-- (id)initWithKeyClass:(Class)keyClass;
-- (id)initWithKeyClass:(Class)keyClass countLimit:(NSUInteger)countLimit;
-
-/**
- * The countLimit specifies the maximum number of items to keep in the cache.
- * This limit is strictly enforced.
- *
- * The default countLimit is 40.
- *
- * You may optionally disable the countLimit by setting it to zero.
- *
- * You may change the countLimit at any time.
- * Changes to the countLimit take immediate effect on the cache (before the set method returns).
- * Thus, if needed, you can temporarily increase the cache size for certain operations.
-**/
-@property (nonatomic, assign, readwrite) NSUInteger countLimit;
-
-//
-// The normal cache stuff...
-//
-
-- (void)setObject:(id)object forKey:(id)key;
-
-- (id)objectForKey:(id)key;
-- (BOOL)containsKey:(id)key;
-
-- (NSUInteger)count;
-
-- (void)removeAllObjects;
-- (void)removeObjectForKey:(id)key;
-- (void)removeObjectsForKeys:(NSArray *)keys;
-
-- (void)enumerateKeysWithBlock:(void (^)(id key, BOOL *stop))block;
-- (void)enumerateKeysAndObjectsWithBlock:(void (^)(id key, id obj, BOOL *stop))block;
-
-//
-// Some debugging stuff that gets compiled out
-//
-
-#if YAP_CACHE_STATISTICS
-
-/**
- * When querying the cache for an object via objectForKey,
- * the hitCount is incremented if the object is in the cache,
- * and the missCount is incremented if the object is not in the cache.
-**/
-@property (nonatomic, readonly) NSUInteger hitCount;
-@property (nonatomic, readonly) NSUInteger missCount;
-
-/**
- * When adding objects to the cache via setObject:forKey:,
- * the evictionCount is incremented if the cache is full,
- * and the added object causes another object (the least recently used object) to be evicted.
-**/
-@property (nonatomic, readonly) NSUInteger evictionCount;
-
-#endif
-
-@end

data/vendor/Pods/YapDatabase/YapDatabase/Internal/YapCache.m

@@ -1,465 +0,0 @@
-#import "YapCache.h"
-#import "YapDatabaseLogging.h"
-
-
-/**
- * Define log level for this file: OFF, ERROR, WARN, INFO, VERBOSE
- * See YapDatabaseLogging.h for more information.
-**/
-#if DEBUG
-  static const int ydbLogLevel = YDB_LOG_LEVEL_OFF;
-#else
-  static const int ydbLogLevel = YDB_LOG_LEVEL_OFF;
-#endif
-
-/**
- * Default countLimit, as specified in header file.
-**/
-#define YAP_CACHE_DEFAULT_COUNT_LIMIT 40
-
-
-@interface YapCacheItem : NSObject {
-@public
-	__unsafe_unretained YapCacheItem *prev; // retained by cfdict
-	__unsafe_unretained YapCacheItem *next; // retained by cfdict
-
-	__unsafe_unretained id key; // retained by cfdict as key
-	__strong id value;          // retained only by us
-}
-
-- (id)initWithKey:(id)key value:(id)value;
-
-@end
-
-@implementation YapCacheItem
-
-- (id)initWithKey:(id <NSCopying>)aKey value:(id)aValue
-{
-	if ((self = [super init]))
-	{
-		key = aKey;
-		value = aValue;
-	}
-	return self;
-}
-
-- (NSString *)description
-{
-	return [NSString stringWithFormat:@"<YapCacheItem[%p] key(%@)>", self, key];
-}
-
-@end
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark -
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-@implementation YapCache
-{
-	Class keyClass;
-	CFMutableDictionaryRef cfdict;
-	
-	NSUInteger countLimit;
-	
-	__unsafe_unretained YapCacheItem *mostRecentCacheItem;
-	__unsafe_unretained YapCacheItem *leastRecentCacheItem;
-	
-	__strong YapCacheItem *evictedCacheItem;
-	
-#if YAP_CACHE_STATISTICS
-	NSUInteger hitCount;
-	NSUInteger missCount;
-	NSUInteger evictionCount;
-#endif
-}
-
-#if YAP_CACHE_STATISTICS
-@synthesize hitCount = hitCount;
-@synthesize missCount = missCount;
-@synthesize evictionCount = evictionCount;
-#endif
-
-- (id)init
-{
-	return [self initWithKeyClass:NULL countLimit:0];
-}
-
-- (id)initWithKeyClass:(Class)inKeyClass
-{
-	return [self initWithKeyClass:inKeyClass countLimit:0];
-}
-
-- (id)initWithKeyClass:(Class)inKeyClass countLimit:(NSUInteger)inCountLimit
-{
-	if ((self = [super init]))
-	{
-		if (inKeyClass == NULL)
-			keyClass = [NSString class];
-		else
-			keyClass = inKeyClass;
-		
-		if (inCountLimit == 0)
-			countLimit = YAP_CACHE_DEFAULT_COUNT_LIMIT;
-		else
-			countLimit = inCountLimit;
-		
-		// We actually use countLimit plus one.
-		// This is because we evict items after the count surpasses the countLimit.
-		// In other words, we evict items when the count reaches countLimit plus one.
-		
-		cfdict = CFDictionaryCreateMutable(kCFAllocatorDefault,
-		                                   0,
-		                                   &kCFTypeDictionaryKeyCallBacks,
-		                                   &kCFTypeDictionaryValueCallBacks);
-	}
-	return self;
-}
-
-- (void)dealloc
-{
-	if (cfdict) CFRelease(cfdict);
-}
-
-- (NSUInteger)countLimit
-{
-	return countLimit;
-}
-
-- (void)setCountLimit:(NSUInteger)newCountLimit
-{
-	if (countLimit != newCountLimit)
-	{
-		countLimit = newCountLimit;
-		
-		if (countLimit != 0) {
-			while (CFDictionaryGetCount(cfdict) > countLimit)
-			{
-				leastRecentCacheItem->prev->next = nil;
-				
-				evictedCacheItem = leastRecentCacheItem;
-				leastRecentCacheItem = leastRecentCacheItem->prev;
-				
-				CFDictionaryRemoveValue(cfdict, (const void *)(evictedCacheItem->key));
-				
-				evictedCacheItem->prev = nil;
-				evictedCacheItem->next = nil;
-				evictedCacheItem->key = nil;
-				evictedCacheItem->value = nil;
-				
-				#if YAP_CACHE_STATISTICS
-				evictionCount++;
-				#endif
-			}
-		}
-	}
-}
-
-- (id)objectForKey:(id)key
-{
-	NSAssert([key isKindOfClass:keyClass], @"Unexpected key class. Expected %@, passed %@", keyClass, [key class]);
-	
-	YapCacheItem *item = CFDictionaryGetValue(cfdict, (const void *)key);
-	if (item)
-	{
-		if (item != mostRecentCacheItem)
-		{
-			// Remove item from current position in linked-list.
-			//
-			// Notes:
-			// We fetched the item from the list,
-			// so we know there's a valid mostRecentCacheItem & leastRecentCacheItem.
-			// Furthermore, we know the item isn't the mostRecentCacheItem.
-			
-			item->prev->next = item->next;
-			
-			if (item == leastRecentCacheItem)
-				leastRecentCacheItem = item->prev;
-			else
-				item->next->prev = item->prev;
-			
-			// Move item to beginning of linked-list
-			
-			item->prev = nil;
-			item->next = mostRecentCacheItem;
-			
-			mostRecentCacheItem->prev = item;
-			mostRecentCacheItem = item;
-		}
-		
-		#if YAP_CACHE_STATISTICS
-		hitCount++;
-		#endif
-		return item->value;
-	}
-	else
-	{
-		#if YAP_CACHE_STATISTICS
-		missCount++;
-		#endif
-		return nil;
-	}
-}
-
-- (BOOL)containsKey:(id)key
-{
-	NSAssert([key isKindOfClass:keyClass], @"Unexpected key class. Expected %@, passed %@", keyClass, [key class]);
-	
-	return CFDictionaryContainsKey(cfdict, (const void *)key);
-}
-
-- (void)setObject:(id)object forKey:(id)key
-{
-	NSAssert([key isKindOfClass:keyClass], @"Unexpected key class. Expected %@, passed %@", keyClass, [key class]);
-	
-	YapCacheItem *item = CFDictionaryGetValue(cfdict, (const void *)key);
-	if (item)
-	{
-		// Update item value
-		item->value = object;
-		
-		if (item != mostRecentCacheItem)
-		{
-			// Remove item from current position in linked-list
-			//
-			// Notes:
-			// We fetched the item from the list,
-			// so we know there's a valid mostRecentCacheItem & leastRecentCacheItem.
-			// Furthermore, we know the item isn't the mostRecentCacheItem.
-			
-			item->prev->next = item->next;
-			
-			if (item == leastRecentCacheItem)
-				leastRecentCacheItem = item->prev;
-			else
-				item->next->prev = item->prev;
-			
-			// Move item to beginning of linked-list
-			
-			item->prev = nil;
-			item->next = mostRecentCacheItem;
-			
-			mostRecentCacheItem->prev = item;
-			mostRecentCacheItem = item;
-			
-			YDBLogVerbose(@"key(%@) <- existing, new mostRecent", key);
-		}
-		else
-		{
-			YDBLogVerbose(@"key(%@) <- existing, already mostRecent", key);
-		}
-	}
-	else
-	{
-		// Create new item (or recycle old evicted item)
-		
-		if (evictedCacheItem)
-		{
-			item = evictedCacheItem;
-			item->key = key;
-			item->value = object;
-			
-			evictedCacheItem = nil;
-		}
-		else
-		{
-			item = [[YapCacheItem alloc] initWithKey:key value:object];
-		}
-		
-		// Add item to set
-		CFDictionarySetValue(cfdict, (const void *)key, (const void *)item);
-		
-		// Add item to beginning of linked-list
-		
-		item->next = mostRecentCacheItem;
-		
-		if (mostRecentCacheItem)
-			mostRecentCacheItem->prev = item;
-		
-		mostRecentCacheItem = item;
-		
-		// Evict leastRecentCacheItem if needed
-		
-		if ((countLimit != 0) && (CFDictionaryGetCount(cfdict) > countLimit))
-		{
-			YDBLogVerbose(@"key(%@), out(%@)", key, leastRecentCacheItem->key);
-			
-			leastRecentCacheItem->prev->next = nil;
-			
-			evictedCacheItem = leastRecentCacheItem;
-			leastRecentCacheItem = leastRecentCacheItem->prev;
-
-			CFDictionaryRemoveValue(cfdict, (const void *)(evictedCacheItem->key));
-			
-			evictedCacheItem->prev = nil;
-			evictedCacheItem->next = nil;
-			evictedCacheItem->key = nil;
-			evictedCacheItem->value = nil;
-			
-			#if YAP_CACHE_STATISTICS
-			evictionCount++;
-			#endif
-		}
-		else
-		{
-			if (leastRecentCacheItem == nil)
-				leastRecentCacheItem = item;
-			
-			YDBLogVerbose(@"key(%@) <- new, new mostRecent [%ld of %lu]",
-			              key, CFDictionaryGetCount(cfdict), (unsigned long)countLimit);
-		}
-	}
-	
-	if (ydbLogLevel & YDB_LOG_FLAG_VERBOSE)
-	{
-		YDBLogVerbose(@"cfdict: %@", cfdict);
-		
-		YapCacheItem *loopItem = mostRecentCacheItem;
-		NSUInteger i = 0;
-		
-		while (loopItem != nil)
-		{
-			YDBLogVerbose(@"%lu: %@", (unsigned long)i, loopItem);
-			
-			loopItem = loopItem->next;
-			i++;
-		}
-	}
-}
-
-- (NSUInteger)count
-{
-	return CFDictionaryGetCount(cfdict);
-}
-
-- (void)removeAllObjects
-{
-	mostRecentCacheItem = nil;
-	leastRecentCacheItem = nil;
-	evictedCacheItem = nil;
-	
-	CFDictionaryRemoveAllValues(cfdict);
-}
-
-- (void)removeObjectForKey:(id)key
-{
-	NSAssert([key isKindOfClass:keyClass], @"Unexpected key class. Expected %@, passed %@", keyClass, [key class]);
-	
-	YapCacheItem *item = CFDictionaryGetValue(cfdict, (const void *)key);
-	if (item)
-	{
-		if (item->prev)
-			item->prev->next = item->next;
-		
-		if (item->next)
-			item->next->prev = item->prev;
-		
-		if (mostRecentCacheItem == item)
-			mostRecentCacheItem = item->next;
-		
-		if (leastRecentCacheItem == item)
-			leastRecentCacheItem = item->prev;
-		
-		CFDictionaryRemoveValue(cfdict, (const void *)key);
-	}
-}
-
-- (void)removeObjectsForKeys:(NSArray *)keys
-{
-	for (id key in keys)
-	{
-		NSAssert([key isKindOfClass:keyClass], @"Unexpected key class. Expected %@, passed %@", keyClass, [key class]);
-		
-		YapCacheItem *item = CFDictionaryGetValue(cfdict, (const void *)key);
-		if (item)
-		{
-			if (item->prev)
-				item->prev->next = item->next;
-			
-			if (item->next)
-				item->next->prev = item->prev;
-			
-			if (mostRecentCacheItem == item)
-				mostRecentCacheItem = item->next;
-			
-			if (leastRecentCacheItem == item)
-				leastRecentCacheItem = item->prev;
-			
-			CFDictionaryRemoveValue(cfdict, (const void *)key);
-		}
-	}
-}
-
-- (void)enumerateKeysWithBlock:(void (^)(id key, BOOL *stop))block
-{
-	NSDictionary *nsdict = (__bridge NSDictionary *)cfdict;
-	BOOL stop = NO;
-	
-	for (id key in [nsdict keyEnumerator])
-	{
-		block(key, &stop);
-		
-		if (stop) break;
-	}
-}
-
-- (void)enumerateKeysAndObjectsWithBlock:(void (^)(id key, id obj, BOOL *stop))block
-{
-	NSDictionary *nsdict = (__bridge NSDictionary *)cfdict;
-	
-	[nsdict enumerateKeysAndObjectsUsingBlock:^(id key, id obj, BOOL *stop) {
-		
-		__unsafe_unretained YapCacheItem *cacheItem = (YapCacheItem *)obj;
-		
-		block(key, cacheItem->value, stop);
-	}];
-}
-
-- (NSString *)description
-{
-	NSMutableString *description = [NSMutableString string];
-	[description appendFormat:@"%@, count=%ld, keys=\n", NSStringFromClass([self class]), CFDictionaryGetCount(cfdict)];
-	
-	YapCacheItem *item = mostRecentCacheItem;
-	NSUInteger itemIndex = 0;
-	
-	while (item != nil)
-	{
-		[description appendFormat:@"  %lu: %@\n", (unsigned long)itemIndex, item->key];
-		
-		item = item->next;
-		itemIndex++;
-	}
-	
-	return description;
-}
-
-/*
-- (void)debug
-{
-	CFIndex count = CFDictionaryGetCount(cfdict);
-	NSAssert(count <= countLimit, @"Invalid count");
-	
-	NSMutableArray *forwardsKeys = [NSMutableArray arrayWithCapacity:count];
-	NSMutableArray *backwardsKeys = [NSMutableArray arrayWithCapacity:count];
-	
-	__unsafe_unretained YapCacheItem *loopItem;
-	
-	loopItem = mostRecentCacheItem;
-	while (loopItem != nil)
-	{
-		[forwardsKeys addObject:loopItem->key];
-		loopItem = loopItem->next;
-	}
-	
-	loopItem = leastRecentCacheItem;
-	while (loopItem != nil)
-	{
-		[backwardsKeys insertObject:loopItem->key atIndex:0];
-		loopItem = loopItem->prev;
-	}
-	
-	NSAssert([forwardsKeys isEqual:backwardsKeys], @"Invalid order");
-}
-*/
-
-@end