motion-yapper 0.0.1

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

@@ -0,0 +1,90 @@
+#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;
+
+//
+// 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

@@ -0,0 +1,453 @@
+#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;
+	}
+}
+
+- (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