motion-yapper 0.0.1

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

@@ -0,0 +1,29 @@
+#import <Foundation/Foundation.h>
+#import "YapDatabaseConnection.h"
+
+
+@interface YapDatabaseConnectionState : NSObject {
+@private
+	dispatch_semaphore_t writeSemaphore;
+
+@public
+	__weak YapDatabaseConnection *connection;
+	
+	BOOL yapLevelSharedReadLock;
+	BOOL sqlLevelSharedReadLock;
+	BOOL longLivedReadTransaction;
+	
+	BOOL yapLevelExclusiveWriteLock;
+	BOOL waitingForWriteLock;
+	
+	uint64_t lastKnownSnapshot;
+}
+
+- (id)initWithConnection:(YapDatabaseConnection *)connection;
+
+- (void)prepareWriteLock;
+
+- (void)waitForWriteLock;
+- (void)signalWriteLock;
+
+@end

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

@@ -0,0 +1,48 @@
+#import "YapDatabaseConnectionState.h"
+
+#if ! __has_feature(objc_arc)
+#warning This file must be compiled with ARC. Use -fobjc-arc flag (or convert project to ARC).
+#endif
+
+
+@implementation YapDatabaseConnectionState
+
+- (id)initWithConnection:(YapDatabaseConnection *)inConnection
+{
+	if ((self = [super init]))
+	{
+		connection = inConnection;
+	}
+	return self;
+}
+
+- (void)dealloc
+{
+#if !OS_OBJECT_USE_OBJC
+	if (writeSemaphore)
+		dispatch_release(writeSemaphore);
+#endif
+}
+
+- (void)prepareWriteLock;
+{
+	if (writeSemaphore == NULL) {
+		writeSemaphore = dispatch_semaphore_create(0);
+	}
+}
+
+- (void)waitForWriteLock
+{
+	if (writeSemaphore) {
+		dispatch_semaphore_wait(writeSemaphore, DISPATCH_TIME_FOREVER);
+	}
+}
+
+- (void)signalWriteLock
+{
+	if (writeSemaphore) {
+		dispatch_semaphore_signal(writeSemaphore);
+	}
+}
+
+@end

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

@@ -0,0 +1,37 @@
+#import <Foundation/Foundation.h>
+
+#import "YapDatabaseConnection.h"
+
+/**
+ * When a connection is created via [database newConnection] is will be handed one of these objects.
+ * Thus the connection will inherit its initial configuration via the defaults configured for the parent database.
+ *
+ * Of course, the connection may then override these default configuration values, and configure itself as needed.
+ *
+ * @see YapDatabase defaultObjectCacheEnabled
+ * @see YapDatabase defaultObjectCacheLimit
+ * 
+ * @see YapDatabase defaultMetadataCacheEnabled
+ * @see YapDatabase defaultMetadataCacheLimit
+ * 
+ * @see YapDatabase defaultObjectPolicy
+ * @see YapDatabase defaultMetadataPolicy
+ * 
+ * @see YapDatabase defaultAutoFlushMemoryLevel
+**/
+@interface YapDatabaseDefaults : NSObject <NSCopying>
+
+@property (nonatomic, assign, readwrite) BOOL objectCacheEnabled;
+@property (nonatomic, assign, readwrite) NSUInteger objectCacheLimit;
+
+@property (nonatomic, assign, readwrite) BOOL metadataCacheEnabled;
+@property (nonatomic, assign, readwrite) NSUInteger metadataCacheLimit;
+
+@property (nonatomic, assign, readwrite) YapDatabasePolicy objectPolicy;
+@property (nonatomic, assign, readwrite) YapDatabasePolicy metadataPolicy;
+
+#if TARGET_OS_IPHONE
+@property (nonatomic, assign, readwrite) int autoFlushMemoryLevel;
+#endif
+
+@end

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

@@ -0,0 +1,83 @@
+#import "YapDatabaseDefaults.h"
+
+
+@implementation YapDatabaseDefaults
+
+@synthesize objectCacheEnabled = objectCacheEnabled;
+@synthesize objectCacheLimit = objectCacheLimit;
+
+@synthesize metadataCacheEnabled = metadataCacheEnabled;
+@synthesize metadataCacheLimit = metadataCacheLimit;
+
+@synthesize objectPolicy = objectPolicy;
+@synthesize metadataPolicy = metadataPolicy;
+
+#if TARGET_OS_IPHONE
+@synthesize autoFlushMemoryLevel = autoFlushMemoryLevel;
+#endif
+
+- (id)init
+{
+	if ((self = [super init]))
+	{
+		objectCacheEnabled = YES;
+		objectCacheLimit = 250;
+		
+		metadataCacheEnabled = YES;
+		metadataCacheLimit = 500;
+		
+		objectPolicy = YapDatabasePolicyContainment;
+		metadataPolicy = YapDatabasePolicyContainment;
+		
+		#if TARGET_OS_IPHONE
+		autoFlushMemoryLevel = YapDatabaseConnectionFlushMemoryLevelMild;
+		#endif
+	}
+	return self;
+}
+
+- (id)copyWithZone:(NSZone *)zone
+{
+	YapDatabaseDefaults *copy = [[[self class] alloc] init];
+	
+	copy->objectCacheEnabled = objectCacheEnabled;
+	copy->objectCacheLimit = objectCacheLimit;
+	
+	copy->metadataCacheEnabled = metadataCacheEnabled;
+	copy->metadataCacheLimit = metadataCacheLimit;
+	
+	copy->objectPolicy = objectPolicy;
+	copy->metadataPolicy = metadataPolicy;
+	
+	#if TARGET_OS_IPHONE
+	copy->autoFlushMemoryLevel = autoFlushMemoryLevel;
+	#endif
+	
+	return copy;
+}
+
+- (void)setObjectPolicy:(YapDatabasePolicy)newObjectPolicy
+{
+	// sanity check
+	switch (newObjectPolicy)
+	{
+		case YapDatabasePolicyContainment :
+		case YapDatabasePolicyShare       :
+		case YapDatabasePolicyCopy        : objectPolicy = newObjectPolicy; break;
+		default                           : objectPolicy = YapDatabasePolicyContainment; // revert to default
+	}
+}
+
+- (void)setMetadataPolicy:(YapDatabasePolicy)newMetadataPolicy
+{
+	// sanity check
+	switch (newMetadataPolicy)
+	{
+		case YapDatabasePolicyContainment :
+		case YapDatabasePolicyShare       :
+		case YapDatabasePolicyCopy        : metadataPolicy = newMetadataPolicy; break;
+		default                           : metadataPolicy = YapDatabasePolicyContainment; // revert to default
+	}
+}
+
+@end

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

@@ -0,0 +1,158 @@
+/**
+ * Logging plays a very important role in open-source libraries.
+ * 
+ * Good documentation and comments decrease the learning time required to use a library.
+ * But proper logging takes this futher by:
+ * - Providing a way to trace the execution of the library
+ * - Allowing developers to quickly identify subsets of the code that need analysis
+ * - Making it easier for developers to find potential bugs, either in their code or the library
+ * - Drawing attention to potential mis-configurations or mis-uses of the API
+ * 
+ * Ultimately logging is an interactive extension to comments.
+**/
+
+/**
+ * Define log levels.
+ * YapDatabase uses 4 log levels:
+ * 
+ * error   - For critical errors that will likely break functionality
+ * warn    - For problems that are concerning, but not quite critical
+ * info    - For general, but important, information such as performing a database upgrade
+ * verbose - For all the other low-level debugging type information
+ * 
+ * Notice that the levels are actually defined using bitwise flags.
+ * This means you have full control to flip individual logs on/off.
+ * For example, you could enable errors and info, but not warnings, if you wanted.
+**/
+
+#define YDB_LOG_FLAG_ERROR   (1 << 0) // 0...00001
+#define YDB_LOG_FLAG_WARN    (1 << 1) // 0...00010
+#define YDB_LOG_FLAG_INFO    (1 << 2) // 0...00100
+#define YDB_LOG_FLAG_VERBOSE (1 << 3) // 0...01000
+
+#define YDB_LOG_LEVEL_OFF     0                                            // 0...00000
+#define YDB_LOG_LEVEL_ERROR   (YDB_LOG_LEVEL_OFF   | YDB_LOG_FLAG_ERROR)   // 0...00001
+#define YDB_LOG_LEVEL_WARN    (YDB_LOG_LEVEL_ERROR | YDB_LOG_FLAG_WARN)    // 0...00011
+#define YDB_LOG_LEVEL_INFO    (YDB_LOG_LEVEL_WARN  | YDB_LOG_FLAG_INFO)    // 0...00111
+#define YDB_LOG_LEVEL_VERBOSE (YDB_LOG_LEVEL_INFO  | YDB_LOG_FLAG_VERBOSE) // 0...01111
+
+#define YDB_LOG_ERROR   (ydbLogLevel & YDB_LOG_LEVEL_ERROR)
+#define YDB_LOG_WARN    (ydbLogLevel & YDB_LOG_LEVEL_WARN)
+#define YDB_LOG_INFO    (ydbLogLevel & YDB_LOG_LEVEL_INFO)
+#define YDB_LOG_VERBOSE (ydbLogLevel & YDB_LOG_LEVEL_VERBOSE)
+
+/**
+ * Define trace, which is in addition to log levels.
+ * It may be turned on/off independent of the log level.
+**/
+
+#define YDB_LOG_FLAG_TRACE   (1 << 4) // 0...10000
+
+/**
+ * YapDatabase supports multiple logging techniques.
+ * 
+ * YapDatabase supports the CocoaLumberjack logging framework.
+ * This is a professional open-source logging library for Mac and iOS development.
+ *
+ * If you're not using Lumberjack then you can downgrade to NSLog.
+ * You can also completely disable logging throughout the entire library.
+ * 
+ * You are strongly discouraged from modifying this file.
+ * If you do, you make it more difficult on yourself to merge future bug fixes and improvements from the project.
+ * Instead, you should override the default values in your own application.
+**/
+
+#define YapDatabaseLoggingTechnique_Lumberjack 2 // optimal
+#define YapDatabaseLoggingTechnique_NSLog      1 // slower
+#define YapDatabaseLoggingTechnique_Disabled   0 // disabled
+
+#ifndef YapDatabaseLoggingTechnique
+#define YapDatabaseLoggingTechnique YapDatabaseLoggingTechnique_Lumberjack
+#endif
+
+/**
+ * CocoaLumberjack has several useful macros and functions.
+ * If not using Lumberjack, we re-define these macros for our own use.
+**/
+
+#if YapDatabaseLoggingTechnique != YapDatabaseLoggingTechnique_Lumberjack
+
+#ifndef THIS_METHOD
+#define THIS_METHOD NSStringFromSelector(_cmd)
+#endif
+
+#ifndef THIS_FILE
+NSString *YDBExtractFileNameWithoutExtension(const char *filePath);
+#define THIS_FILE (YDBExtractFileNameWithoutExtension(__FILE__))
+#endif
+
+#endif
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+#if (YapDatabaseLoggingTechnique == YapDatabaseLoggingTechnique_Lumberjack)
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// Logging Enabled.
+// Logging uses the CocoaLumberjack framework. (optimal)
+//
+// There is a TON of documentation available from the project page:
+// https://github.com/robbiehanson/CocoaLumberjack
+
+#import "DDLog.h"
+
+#define YDBLogAsync   NO
+#define YDBLogContext 27017
+
+#define YDBLogMaybe(flg, frmt, ...) LOG_OBJC_MAYBE(YDBLogAsync, ydbLogLevel, flg, YDBLogContext, frmt, ##__VA_ARGS__)
+
+#define YDBLogError(frmt, ...)     YDBLogMaybe(YDB_LOG_FLAG_ERROR,   (@"%@: " frmt), THIS_FILE, ##__VA_ARGS__)
+#define YDBLogWarn(frmt, ...)      YDBLogMaybe(YDB_LOG_FLAG_WARN,    (@"%@: " frmt), THIS_FILE, ##__VA_ARGS__)
+#define YDBLogInfo(frmt, ...)      YDBLogMaybe(YDB_LOG_FLAG_INFO,    (@"%@: " frmt), THIS_FILE, ##__VA_ARGS__)
+#define YDBLogVerbose(frmt, ...)   YDBLogMaybe(YDB_LOG_FLAG_VERBOSE, (@"%@: " frmt), THIS_FILE, ##__VA_ARGS__)
+
+#define YDBLogTrace(frmt, ...) YDBLogMaybe(YDB_LOG_FLAG_TRACE, (@"%@: " frmt), THIS_FILE, ##__VA_ARGS__)
+#define YDBLogAutoTrace()      YDBLogMaybe(YDB_LOG_FLAG_TRACE,  @"%@: %@",     THIS_FILE, THIS_METHOD)
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+#elif (YapDatabaseLoggingTechnique == YapDatabaseLoggingTechnique_NSLog)
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// Logging Enabled.
+// Logging uses plain old NSLog. (slower)
+
+#define YDBLogMaybe(flg, frmt, ...) \
+    do{ if(ydbLogLevel & flg) NSLog((@"%@: " frmt), THIS_FILE, ##__VA_ARGS__); } while(0)
+
+#define YDBLogError(frmt, ...)    YDBLogMaybe(YDB_LOG_FLAG_ERROR,   frmt, ##__VA_ARGS__)
+#define YDBLogWarn(frmt, ...)     YDBLogMaybe(YDB_LOG_FLAG_WARN,    frmt, ##__VA_ARGS__)
+#define YDBLogInfo(frmt, ...)     YDBLogMaybe(YDB_LOG_FLAG_INFO,    frmt, ##__VA_ARGS__)
+#define YDBLogVerbose(frmt, ...)  YDBLogMaybe(YDB_LOG_FLAG_VERBOSE, frmt, ##__VA_ARGS__)
+
+#define YDBLogTrace(frmt, ...) YDBLogMaybe(YDB_LOG_FLAG_TRACE, (@"%@: " frmt), THIS_FILE, ##__VA_ARGS__)
+#define YDBLogAutoTrace()      YDBLogMaybe(YDB_LOG_FLAG_TRACE,  @"%@: %@",     THIS_FILE, THIS_METHOD)
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+#else
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// Logging Disabled
+
+#undef YDB_LOG_ERROR
+#undef YDB_LOG_WARN
+#undef YDB_LOG_INFO
+#undef YDB_LOG_VERBOSE
+
+#define YDB_LOG_ERROR   (NO)
+#define YDB_LOG_WARN    (NO)
+#define YDB_LOG_INFO    (NO)
+#define YDB_LOG_VERBOSE (NO)
+
+#define YDBLogError(frmt, ...)     {}
+#define YDBLogWarn(frmt, ...)      {}
+#define YDBLogInfo(frmt, ...)      {}
+#define YDBLogVerbose(frmt, ...)   {}
+
+#define YDBLogTrace(frmt, ...)     {}
+#define YDBLogAutoTrace()          {}
+
+#endif

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

@@ -0,0 +1,73 @@
+#import "YapDatabaseLogging.h"
+
+
+#if YapDatabaseLoggingTechnique != YapDatabaseLoggingTechnique_Lumberjack
+
+/**
+ * This method is based on CocoaLumberjack's DDExtractFileNameWithoutExtension function.
+ * The copy option has been removed, as we only use __FILE__ as the filePath parameter.
+**/
+NSString *YDBExtractFileNameWithoutExtension(const char *filePath)
+{
+	if (filePath == NULL) return nil;
+	
+	char *lastSlash = NULL;
+	char *lastDot = NULL;
+	
+	char *p = (char *)filePath;
+	
+	while (*p != '\0')
+	{
+		if (*p == '/')
+			lastSlash = p;
+		else if (*p == '.')
+			lastDot = p;
+		
+		p++;
+	}
+	
+	char *subStr;
+	NSUInteger subLen;
+	
+	if (lastSlash)
+	{
+		if (lastDot)
+		{
+			// lastSlash -> lastDot
+			subStr = lastSlash + 1;
+			subLen = lastDot - subStr;
+		}
+		else
+		{
+			// lastSlash -> endOfString
+			subStr = lastSlash + 1;
+			subLen = p - subStr;
+		}
+	}
+	else
+	{
+		if (lastDot)
+		{
+			// startOfString -> lastDot
+			subStr = (char *)filePath;
+			subLen = lastDot - subStr;
+		}
+		else
+		{
+			// startOfString -> endOfString
+			subStr = (char *)filePath;
+			subLen = p - subStr;
+		}
+	}
+	
+	// We can take advantage of the fact that __FILE__ is a string literal.
+	// Specifically, we don't need to waste time copying the string.
+	// We can just tell NSString to point to a range within the string literal.
+	
+	return [[NSString alloc] initWithBytesNoCopy:subStr
+	                                      length:subLen
+	                                    encoding:NSUTF8StringEncoding
+	                                freeWhenDone:NO];
+}
+
+#endif

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

@@ -0,0 +1,17 @@
+#import <Foundation/Foundation.h>
+
+/**
+ * There should only be one YapDatabase or YapCollectionDatabase per file.
+ *
+ * The architecture design is to create a single parent database instance,
+ * and then spawn connections to the database as needed from the parent.
+ * 
+ * The architecture is built around this restriction, and is dependent upon it for proper operation.
+ * This class simply helps maintain this requirement.
+**/
+@interface YapDatabaseManager : NSObject
+
++ (BOOL)registerDatabaseForPath:(NSString *)path;
++ (void)deregisterDatabaseForPath:(NSString *)path;
+
+@end