motion-yapper 0.0.1

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

@@ -0,0 +1,17 @@
+#import <Foundation/Foundation.h>
+
+/**
+ * There are various situations in which we need to add a placeholder to signify a nil value.
+ * For example, we need to cache the fact that the metadata for a given key is nil.
+ *
+ * However, we cannot add a nil object to a dictionary.
+ * And we cannot use NSNull, or we prevent the user from using NSNull for their own purposes.
+ * 
+ * And thus, we replicate NSNull, and use it instead.
+ * And now the user is free to use NSNull if needed.
+**/
+@interface YapNull : NSObject
+
++ (id)null;
+
+@end

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

@@ -0,0 +1,31 @@
+#import "YapNull.h"
+
+
+@implementation YapNull
+
+static YapNull *singleton;
+
++ (void)initialize
+{
+	static BOOL initialized = NO;
+	if (!initialized)
+	{
+		initialized = YES;
+		singleton = [[YapNull alloc] init];
+	}
+}
+
++ (id)null
+{
+	return singleton;
+}
+
+- (id)init
+{
+	NSAssert(singleton == nil, @"Must use singleton via [YapNull null]");
+	
+	self = [super init];
+	return self;
+}
+
+@end

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

@@ -0,0 +1,15 @@
+#import <Foundation/Foundation.h>
+
+/**
+ * Singleton class to represent the "value" for a key that was touched. (i.e. value didn't change)
+ *
+ * YapDatabase stores changesets in dictionaries, where the object represents the updated value for a key.
+ * When an item is touched, we use this singleton as the value to signify internally that the item didn't change.
+ * This allows us to act as if the item did change in most all respects,
+ * but internally won't cause us to flush the item from the caches.
+**/
+@interface YapTouch : NSObject
+
++ (id)touch;
+
+@end

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

@@ -0,0 +1,31 @@
+#import "YapTouch.h"
+
+
+@implementation YapTouch
+
+static YapTouch *singleton;
+
++ (void)initialize
+{
+	static BOOL initialized = NO;
+	if (!initialized)
+	{
+		initialized = YES;
+		singleton = [[YapTouch alloc] init];
+	}
+}
+
++ (id)touch
+{
+	return singleton;
+}
+
+- (id)init
+{
+	NSAssert(singleton == nil, @"Must use singleton via [YapTouch touch]");
+	
+	self = [super init];
+	return self;
+}
+
+@end

data/vendor/Pods/YapDatabase/YapDatabase/Utilities/YapCollectionKey.h

@@ -0,0 +1,20 @@
+#import <Foundation/Foundation.h>
+
+
+/**
+ * An efficient collection/key tuple class.
+ *
+ * Combines collection & key into a single object,
+ * and provides the proper methods to use the object in various classes (such as NSDictionary, NSSet, etc).
+**/
+@interface YapCollectionKey : NSObject <NSCopying, NSCoding>
+
+- (id)initWithCollection:(NSString *)collection key:(NSString *)key;
+
+@property (nonatomic, strong, readonly) NSString *collection;
+@property (nonatomic, strong, readonly) NSString *key;
+
+- (BOOL)isEqual:(id)anObject;
+- (NSUInteger)hash;
+
+@end

data/vendor/Pods/YapDatabase/YapDatabase/Utilities/YapCollectionKey.m

@@ -0,0 +1,194 @@
+#import "YapCollectionKey.h"
+
+
+/**
+ * MurmurHash2 was written by Austin Appleby, and is placed in the public domain.
+ * http://code.google.com/p/smhasher
+**/
+static NSUInteger YDB_MurmurHash(NSUInteger hash1, NSUInteger hash2)
+{
+	if (NSUIntegerMax == UINT32_MAX) // Should be optimized out via compiler since these are constants
+	{
+		// MurmurHash2 (32-bit)
+		//
+		// uint32_t MurmurHash2 ( const void * key, int len, uint32_t seed )
+		//
+		// Normally one would pass a chunk of data ('key') and associated data chunk length ('len').
+		// Instead we're going to use our 2 hashes.
+		// And we're going to randomly make up a 'seed'.
+		
+		const uint32_t seed = 0xa2f1b6f; // Some random value I made up
+		const uint32_t len = 8;          // 2 hashes, each 4 bytes = 8 bytes
+		
+		// 'm' and 'r' are mixing constants generated offline.
+		// They're not really 'magic', they just happen to work well.
+		
+		const uint32_t m = 0x5bd1e995;
+		const int r = 24;
+		
+		// Initialize the hash to a 'random' value
+		
+		uint32_t h = seed ^ len;
+		uint32_t k;
+		
+		// Mix hash1
+		
+		k = hash1;
+		
+		k *= m;
+		k ^= k >> r;
+		k *= m;
+		
+		h *= m;
+		h ^= k;
+		
+		// Mix khash
+		
+		k = hash2;
+		
+		k *= m;
+		k ^= k >> r;
+		k *= m;
+		
+		h *= m;
+		h ^= k;
+		
+		// Do a few final mixes of the hash to ensure the last few
+		// bytes are well-incorporated.
+		
+		h ^= h >> 13;
+		h *= m;
+		h ^= h >> 15;
+		
+		return (NSUInteger)h;
+	}
+	else
+	{
+		// MurmurHash2 (64-bit)
+		//
+		// uint64_t MurmurHash64A ( const void * key, int len, uint64_t seed )
+		//
+		// Normally one would pass a chunk of data ('key') and associated data chunk length ('len').
+		// Instead we're going to use our 3 hashes.
+		// And we're going to randomly make up a 'seed'.
+		
+		const uint32_t seed = 0xa2f1b6f; // Some random value I made up
+		const uint32_t len = 16;         // 2 hashes, each 8 bytes = 16 bytes
+		
+		// 'm' and 'r' are mixing constants generated offline.
+		// They're not really 'magic', they just happen to work well.
+		
+		const uint64_t m = 0xc6a4a7935bd1e995LLU;
+		const int r = 47;
+		
+		// Initialize the hash to a 'random' value
+		
+		uint64_t h = seed ^ (len * m);
+		uint64_t k;
+		
+		// Mix hash1
+		
+		k = hash1;
+		
+		k *= m;
+		k ^= k >> r;
+		k *= m;
+		
+		h ^= k;
+		h *= m;
+		
+		// Mix hash2
+		
+		k = hash2;
+		
+		k *= m;
+		k ^= k >> r;
+		k *= m;
+		
+		h ^= k;
+		h *= m;
+		
+		// Do a few final mixes of the hash to ensure the last few
+		// bytes are well-incorporated.
+		
+		h ^= h >> r;
+		h *= m;
+		h ^= h >> r;
+		
+		return (NSUInteger)h;
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+#pragma mark -
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+@implementation YapCollectionKey
+
+@synthesize collection = collection;
+@synthesize key = key;
+
+- (id)initWithCollection:(NSString *)aCollection key:(NSString *)aKey
+{
+	if ((self = [super init]))
+	{
+		if (aCollection == nil)
+			collection = @"";
+		else
+			collection = [aCollection copy]; // copy == retain if aCollection is immutable
+		
+		if (aKey == nil)
+			return nil;
+		else
+			key = [aKey copy];               // copy == retain if aKey is immutable
+	}
+	return self;
+}
+
+- (id)initWithCoder:(NSCoder *)decoder
+{
+	if ((self = [super init]))
+	{
+		collection = [decoder decodeObjectForKey:@"collection"];
+		key        = [decoder decodeObjectForKey:@"key"];
+	}
+	return self;
+}
+
+- (void)encodeWithCoder:(NSCoder *)coder
+{
+	[coder encodeObject:collection forKey:@"collection"];
+	[coder encodeObject:key        forKey:@"key"];
+}
+
+- (id)copyWithZone:(NSZone *)zone
+{
+	return self; // Immutable
+}
+
+- (BOOL)isEqual:(id)obj
+{
+	if ([obj isMemberOfClass:[YapCollectionKey class]])
+	{
+		YapCollectionKey *ck = (YapCollectionKey *)obj;
+		
+		return [key isEqualToString:ck->key] && [collection isEqualToString:ck->collection];
+	}
+	
+	return NO;
+}
+
+- (NSUInteger)hash
+{
+	// We need a fast way to combine 2 hashes without creating a new string (which is slow).
+	// To accomplish this we use the murmur hashing algorithm.
+
+	return YDB_MurmurHash([collection hash], [key hash]);
+}
+
+- (NSString *)description
+{
+	return [NSString stringWithFormat:@"<YapCollectionKey[%p] collection(%@) key(%@)>", self, collection, key];
+}
+
+@end

data/vendor/Pods/YapDatabase/YapDatabase/Utilities/YapDatabaseQuery.h

@@ -0,0 +1,42 @@
+#import <Foundation/Foundation.h>
+
+
+/**
+ * A YapDatabaseQuery is used to pass SQL style queries into various extension classes.
+ * The query that you pass represents everything after the SELECT clause of a query.
+**/
+@interface YapDatabaseQuery : NSObject
+
+/**
+ * A YapDatabaseQuery is everything after the SELECT clause of a query.
+ * Methods that take YapDatabaseQuery parameters will prefix your query string similarly to:
+ * 
+ * fullQuery = @"SELECT rowid FROM 'database' " + [yapDatabaseQuery queryString];
+ * 
+ * Example 1:
+ * 
+ * query = [YapDatabaseQuery queryWithFormat:@"WHERE jid = ?", message.jid];
+ * [secondaryIndex enumerateKeysAndObjectsMatchingQuery:query
+ *                                           usingBlock:^(NSString *key, id object, BOOL *stop){
+ *     ...
+ * }];
+ * 
+ * Please note that you can ONLY pass objective-c objects as parameters.
+ * Primitive types such as int, float, double, etc are NOT supported.
+ * You MUST wrap these using NSNumber.
+ * 
+ * Example 2:
+ *
+ * query = [YapDatabaseQuery queryWithFormat:@"WHERE department = ? AND salary >= ?", dept, @(minSalary)];
+ * [secondaryIndex enumerateKeysAndObjectsMatchingQuery:query
+ *                                           usingBlock:^(NSString *key, id object, BOOL *stop){
+ *     ...
+ * }];
+**/
++ (instancetype)queryWithFormat:(NSString *)format, ...;
+
+
+@property (nonatomic, strong, readonly) NSString *queryString;
+@property (nonatomic, strong, readonly) NSArray *queryParameters;
+
+@end

data/vendor/Pods/YapDatabase/YapDatabase/Utilities/YapDatabaseQuery.m

@@ -0,0 +1,96 @@
+#import "YapDatabaseQuery.h"
+#import "YapDatabaseLogging.h"
+
+#if ! __has_feature(objc_arc)
+#warning This file must be compiled with ARC. Use -fobjc-arc flag (or convert project to ARC).
+#endif
+
+/**
+ * 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_WARN;
+#else
+  static const int ydbLogLevel = YDB_LOG_LEVEL_WARN;
+#endif
+
+
+@implementation YapDatabaseQuery
+{
+	NSString *queryString;
+	NSArray *queryParameters;
+}
+
++ (instancetype)queryWithFormat:(NSString *)format, ...
+{
+	if (format == nil) return nil;
+	
+	NSUInteger paramCount = 0;
+	NSUInteger formatLength = [format length];
+	
+	NSRange searchRange = NSMakeRange(0, formatLength);
+	NSRange paramRange = [format rangeOfString:@"?" options:0 range:searchRange];
+	
+	while (paramRange.location != NSNotFound)
+	{
+		paramCount++;
+		
+		searchRange.location = paramRange.location + 1;
+		searchRange.length = formatLength - searchRange.location;
+		
+		paramRange = [format rangeOfString:@"?" options:0 range:searchRange];
+	}
+	
+	// Please note that you can ONLY pass objective-c objects as parameters.
+	// Primitive types such as int, float, double, etc are NOT supported.
+	// You MUST wrap these using NSNumber.
+	
+	NSMutableArray *queryParameters = [NSMutableArray arrayWithCapacity:paramCount];
+	
+	va_list args;
+	va_start(args, format);
+	
+	@try
+	{
+		for (NSUInteger i = 0; i < paramCount; i++)
+		{
+			id param = va_arg(args, id);
+			
+			[queryParameters addObject:param];
+		}
+	}
+	@catch (NSException *exception)
+	{
+		YDBLogError(@"Error processing query. Expected %lu parameters. All parameters must be objects. %@",
+		            (unsigned long)paramCount, exception);
+		
+		queryParameters = nil;
+	}
+	
+	va_end(args);
+	
+	if (queryParameters)
+	{
+		return [[YapDatabaseQuery alloc] initWithQueryString:format queryParameters:queryParameters];
+	}
+	else
+	{
+		return nil;
+	}
+}
+
+- (id)initWithQueryString:(NSString *)inQueryString queryParameters:(NSArray *)inQueryParameters
+{
+	if ((self = [super init]))
+	{
+		queryString = [inQueryString copy];
+		queryParameters = [inQueryParameters copy];
+	}
+	return self;
+}
+
+@synthesize queryString;
+@synthesize queryParameters;
+
+@end