motion-yapper 0.0.1

data/vendor/Pods/BuildHeaders/YapDatabase/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/BuildHeaders/YapDatabase/YapDatabaseSecondaryIndex.h

@@ -0,0 +1,100 @@
+#import <Foundation/Foundation.h>
+
+#import "YapDatabaseExtension.h"
+#import "YapDatabaseSecondaryIndexSetup.h"
+#import "YapDatabaseSecondaryIndexConnection.h"
+#import "YapDatabaseSecondaryIndexTransaction.h"
+
+/**
+ * Welcome to YapDatabase!
+ *
+ * https://github.com/yaptv/YapDatabase
+ *
+ * The project wiki has a wealth of documentation if you have any questions.
+ * https://github.com/yaptv/YapDatabase/wiki
+ *
+ * YapDatabaseSecondaryIndex is an extension which allows you to add additional indexes.
+ * That is, it allows you to create index(es) within sqlite for particular properties of your objects.
+ * You can then issue queries to find or enumerate objects using the indexes. (e.g. age >= 62)
+ * This allows for increased flexibility above the traditional key-value model.
+**/
+
+/**
+ * The block handles extracting the column values for the secondary indexes.
+ *
+ * When you add or update rows in the databse the block is invoked.
+ * Your block can inspect the row and determine if it contains any values that should be added to the secondary indexes.
+ * If not, the  block can simply return.
+ * Otherwise the block should extract any values and add them to the given dictionary.
+ *
+ * After the block returns, the dictionary parameter will be inspected,
+ * and any set values will be automatically inserted/updated within the sqlite indexes.
+ *
+ * You should choose a block type that takes the minimum number of required parameters.
+ * The extension can make various optimizations based on required parameters of the block.
+ * For example, if metadata isn't required, then the extension can ignore metadata-only updates.
+**/
+typedef id YapDatabaseSecondaryIndexBlock; // One of the YapDatabaseSecondaryIndexWith_X_Block types below.
+
+typedef void (^YapDatabaseSecondaryIndexWithKeyBlock)      \
+                            (NSMutableDictionary *dict, NSString *collection, NSString *key);
+typedef void (^YapDatabaseSecondaryIndexWithObjectBlock)   \
+                            (NSMutableDictionary *dict, NSString *collection, NSString *key, id object);
+typedef void (^YapDatabaseSecondaryIndexWithMetadataBlock) \
+                            (NSMutableDictionary *dict, NSString *collection, NSString *key, id metadata);
+typedef void (^YapDatabaseSecondaryIndexWithRowBlock)      \
+                            (NSMutableDictionary *dict, NSString *collection, NSString *key, id object, id metadata);
+
+/**
+ * Use this enum to specify what kind of block you're passing.
+**/
+typedef enum {
+	YapDatabaseSecondaryIndexBlockTypeWithKey       = 1031,
+	YapDatabaseSecondaryIndexBlockTypeWithObject    = 1032,
+	YapDatabaseSecondaryIndexBlockTypeWithMetadata  = 1033,
+	YapDatabaseSecondaryIndexBlockTypeWithRow       = 1034
+} YapDatabaseSecondaryIndexBlockType;
+
+
+@interface YapDatabaseSecondaryIndex : YapDatabaseExtension
+
+/* Inherited from YapDatabaseExtension
+
+@property (nonatomic, strong, readonly) NSString *registeredName;
+
+*/
+
+/**
+ * Creates a new secondary index extension.
+ * After creation, you'll need to register the extension with the database system.
+ *
+ * @param setup
+ * 
+ *   A YapDatabaseSecondaryIndexSetup instance allows you to specify the column names and type.
+ *   The column names can be whatever you want, with a few exceptions for reserved names such as "rowid".
+ *   The types can reflect numbers or text.
+ * 
+ * @param block
+ * 
+ *   Pass a block that is one of the following types:
+ *    - YapDatabaseSecondaryIndexWithKeyBlock
+ *    - YapDatabaseSecondaryIndexWithObjectBlock
+ *    - YapDatabaseSecondaryIndexWithMetadataBlock
+ *    - YapDatabaseSecondaryIndexWithRowBlock
+ * 
+ * @param blockType
+ * 
+ *   Pass the blockType enum that matches the passed block:
+ *    - YapDatabaseSecondaryIndexBlockTypeWithKey
+ *    - YapDatabaseSecondaryIndexBlockTypeWithObject
+ *    - YapDatabaseSecondaryIndexBlockTypeWithMetadata
+ *    - YapDatabaseSecondaryIndexBlockTypeWithRow
+ *
+ * @see YapDatabaseSecondaryIndexSetup
+ * @see YapDatabase registerExtension:withName:
+**/
+- (id)initWithSetup:(YapDatabaseSecondaryIndexSetup *)setup
+              block:(YapDatabaseSecondaryIndexBlock)block
+          blockType:(YapDatabaseSecondaryIndexBlockType)blockType;
+
+@end

data/vendor/Pods/BuildHeaders/YapDatabase/YapDatabaseSecondaryIndexConnection.h

@@ -0,0 +1,33 @@
+#import <Foundation/Foundation.h>
+#import "YapDatabaseExtensionConnection.h"
+
+@class YapDatabaseSecondaryIndex;
+
+
+@interface YapDatabaseSecondaryIndexConnection : YapDatabaseExtensionConnection
+
+/**
+ * Returns the parent instance.
+**/
+@property (nonatomic, strong, readonly) YapDatabaseSecondaryIndex *secondaryIndex;
+
+/**
+ * The queryCache speeds up the transaction methods. (enumerateXMatchingQuery:usingBlock:)
+ *
+ * In order for a query to be executed, it first has to be compiled by SQLite into an executable routine.
+ * The queryCache stores these compiled reusable routines, so that repeated queries can be executed faster.
+ *
+ * Please note that, in terms of caching, only the queryString matters. The queryParameters do not.
+ * That is, if you use the same queryString over and over, but with different parameters,
+ * you will get a nice benefit from caching as it will be able to recyle the compiled routine,
+ * and simply bind the different parameters each time.
+ *
+ * By default the queryCache is enabled and has a limit of 10.
+ *
+ * To disable the cache entirely, set queryCacheEnabled to NO.
+ * To use an inifinite cache size, set the queryCacheLimit to ZERO.
+**/
+@property (atomic, assign, readwrite) BOOL queryCacheEnabled;
+@property (atomic, assign, readwrite) NSUInteger queryCacheLimit;
+
+@end

data/vendor/Pods/BuildHeaders/YapDatabase/YapDatabaseSecondaryIndexPrivate.h

@@ -0,0 +1,73 @@
+#import "YapDatabase.h"
+#import "YapDatabaseConnection.h"
+#import "YapDatabaseTransaction.h"
+
+#import "YapDatabaseSecondaryIndex.h"
+#import "YapDatabaseSecondaryIndexConnection.h"
+#import "YapDatabaseSecondaryIndexTransaction.h"
+
+#import "YapDatabaseSecondaryIndexSetup.h"
+#import "YapCache.h"
+
+#import "sqlite3.h"
+
+@interface YapDatabaseSecondaryIndex () {
+@public
+	
+	YapDatabaseSecondaryIndexSetup *setup;
+	
+	YapDatabaseSecondaryIndexBlock block;
+	YapDatabaseSecondaryIndexBlockType blockType;
+	
+	int version;
+	
+	id columnNamesSharedKeySet;
+}
+
+- (NSString *)tableName;
+
+@end
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+#pragma mark -
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+@interface YapDatabaseSecondaryIndexConnection () {
+@public
+	
+	__strong YapDatabaseSecondaryIndex *secondaryIndex;
+	__unsafe_unretained YapDatabaseConnection *databaseConnection;
+	
+	NSMutableDictionary *blockDict;
+	
+	YapCache *queryCache;
+	NSUInteger queryCacheLimit;
+}
+
+- (id)initWithSecondaryIndex:(YapDatabaseSecondaryIndex *)secondaryIndex
+          databaseConnection:(YapDatabaseConnection *)databaseConnection;
+
+- (sqlite3_stmt *)insertStatement;
+- (sqlite3_stmt *)updateStatement;
+- (sqlite3_stmt *)removeStatement;
+- (sqlite3_stmt *)removeAllStatement;
+
+@end
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+#pragma mark -
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+@interface YapDatabaseSecondaryIndexTransaction () {
+@private
+	
+	__unsafe_unretained YapDatabaseSecondaryIndexConnection *secondaryIndexConnection;
+	__unsafe_unretained YapDatabaseReadTransaction *databaseTransaction;
+	
+	BOOL isMutated;
+}
+
+- (id)initWithSecondaryIndexConnection:(YapDatabaseSecondaryIndexConnection *)secondaryIndexConnection
+                   databaseTransaction:(YapDatabaseReadTransaction *)databaseTransaction;
+
+@end

data/vendor/Pods/BuildHeaders/YapDatabase/YapDatabaseSecondaryIndexSetup.h

@@ -0,0 +1,33 @@
+#import <Foundation/Foundation.h>
+
+@class YapDatabaseSecondaryIndexColumn;
+
+typedef enum {
+	YapDatabaseSecondaryIndexTypeInteger,
+	YapDatabaseSecondaryIndexTypeReal,
+	YapDatabaseSecondaryIndexTypeText
+} YapDatabaseSecondaryIndexType;
+
+
+@interface YapDatabaseSecondaryIndexSetup : NSObject <NSCopying, NSFastEnumeration>
+
+- (id)init;
+- (id)initWithCapacity:(NSUInteger)capacity;
+
+- (void)addColumn:(NSString *)name withType:(YapDatabaseSecondaryIndexType)type;
+
+- (NSUInteger)count;
+- (YapDatabaseSecondaryIndexColumn *)columnAtIndex:(NSUInteger)index;
+
+- (NSArray *)columnNames;
+
+@end
+
+#pragma mark -
+
+@interface YapDatabaseSecondaryIndexColumn : NSObject
+
+@property (nonatomic, copy, readonly) NSString *name;
+@property (nonatomic, assign, readonly) YapDatabaseSecondaryIndexType type;
+
+@end

data/vendor/Pods/BuildHeaders/YapDatabase/YapDatabaseSecondaryIndexTransaction.h

@@ -0,0 +1,58 @@
+#import <Foundation/Foundation.h>
+
+#import "YapDatabaseExtensionTransaction.h"
+#import "YapDatabaseQuery.h"
+
+
+@interface YapDatabaseSecondaryIndexTransaction : YapDatabaseExtensionTransaction
+
+/**
+ * These methods allow you to enumerates matches from the secondary index(es) using a given query.
+ *
+ * The query that you input is an SQL style query (appropriate for SQLite semantics),
+ * excluding the "SELECT ... FROM 'tableName'" component.
+ * 
+ * For example:
+ * 
+ * query = [YapDatabaseQuery queryWithFormat:@"WHERE age >= 62"];
+ * [[transaction ext:@"idx"] enumerateKeysMatchingQuery:query usingBlock:^(NSString *key, BOOL *stop) {
+ * 
+ *     // ...
+ * }];
+ *
+ * You can also pass parameters to the query using the standard SQLite placeholder:
+ * 
+ * query = [YapDatabaseQuery queryWithFormat:@"WHERE age >= ? AND state == ?", @(age), state];
+ * [[transaction ext:@"idx"] enumerateKeysMatchingQuery:query usingBlock:^(NSString *key, BOOL *stop) {
+ *
+ *     // ...
+ * }];
+ *
+ * For more information, and more examples, please see YapDatabaseQuery.
+ * 
+ * @return NO if there was a problem with the given query. YES otherwise.
+ * 
+ * @see YapDatabaseQuery
+**/
+
+- (BOOL)enumerateKeysMatchingQuery:(YapDatabaseQuery *)query
+                        usingBlock:(void (^)(NSString *collection, NSString *key, BOOL *stop))block;
+
+- (BOOL)enumerateKeysAndMetadataMatchingQuery:(YapDatabaseQuery *)query
+                                   usingBlock:
+                            (void (^)(NSString *collection, NSString *key, id metadata, BOOL *stop))block;
+
+- (BOOL)enumerateKeysAndObjectsMatchingQuery:(YapDatabaseQuery *)query
+                                  usingBlock:
+                            (void (^)(NSString *collection, NSString *key, id object, BOOL *stop))block;
+
+- (BOOL)enumerateRowsMatchingQuery:(YapDatabaseQuery *)query
+                        usingBlock:
+                            (void (^)(NSString *collection, NSString *key, id object, id metadata, BOOL *stop))block;
+/**
+ * Skips the enumeration process, and just gives you the count of matching rows.
+**/
+
+- (BOOL)getNumberOfRows:(NSUInteger *)count matchingQuery:(YapDatabaseQuery *)query;
+
+@end

data/vendor/Pods/BuildHeaders/YapDatabase/YapDatabaseStatement.h

@@ -0,0 +1,13 @@
+#import <Foundation/Foundation.h>
+#import "sqlite3.h"
+
+/**
+ * Simple wrapper class to facilitate storing sqlite3_stmt items as objects (primarily in YapCache).
+**/
+@interface YapDatabaseStatement : NSObject
+
+- (id)initWithStatement:(sqlite3_stmt *)stmt;
+
+@property (nonatomic, assign, readonly) sqlite3_stmt *stmt;
+
+@end

data/vendor/Pods/BuildHeaders/YapDatabase/YapDatabaseString.h

@@ -0,0 +1,121 @@
+/**
+ * There are a LOT of conversions from NSString to char array.
+ * This happens in almost every method, where we bind text to prepared sqlite3 statements.
+ * 
+ * It is inefficient to use [key UTF8String] for these situations.
+ * The Apple documentation is very explicit concerning the UTF8String method:
+ * 
+ * > The returned C string is automatically freed just as a returned object would be released;
+ * > you should copy the C string if [you need] to store it outside of the
+ * > autorelease context in which the C string is created.
+ * 
+ * In other words, the UTF8String method does a malloc for character buffer, copies the characters,
+ * and autoreleases the buffer (just like an autoreleased NSData instance).
+ * 
+ * Thus we suffer a bunch of malloc's if we use UTF8String.
+ * 
+ * Considering that almost all keys are likely to be relatively small,
+ * a much faster technique is to use the stack instead of the heap (with obvious precautions, see below).
+ * 
+ * Note: This technique ONLY applies to key names and collection names.
+ * It does NOT apply to object/primitiveData or metadata. Those are binded to sqlite3 statements using binary blobs.
+**/
+
+
+/**
+ * We must be cautious and conservative so as to avoid stack overflow.
+ * This is possibe if really huge key names or collection names are used.
+ *
+ * The number below represents the largest amount of memory (in bytes) that will be allocated on the stack per string.
+**/
+#define YapDatabaseStringMaxStackLength (1024 * 4)
+
+/**
+ * Struct designed to be allocated on the stack.
+ * You then use the inline functions below to "setup" and "teardown" the struct.
+ * For example:
+ * 
+ * > YapDatabaseString myKeyChar;
+ * > MakeYapDatabaseString(&myKeyChar, myNSStringKey);
+ * > ...
+ * > sqlite3_bind_text(statement, position, myKeyChar.str, myKeyChar.length, SQLITE_STATIC);
+ * > ...
+ * > sqlite3_clear_bindings(statement);
+ * > sqlite3_reset(statement);
+ * > FreeYapDatabaseString(&myKeyChar);
+ *
+ * There are 2 "public" fields:
+ * str    - Pointer to the char[] string.
+ * length - Represents the length (in bytes) of the char[] str (excluding the NULL termination byte, as usual).
+ * 
+ * The other 2 "private" fields are for internal use:
+ * strStack - If the string doesn't exceed YapDatabaseStringMaxStackLength,
+ *            then the bytes are copied here (onto stack storage), and str actually points to strStack.
+ * strHeap  - If the string exceeds YapDatabaseStringMaxStackLength,
+ *            the space is allocated on the heap, strHeap holds the pointer, and str has the same pointer.
+ * 
+ * Thus the "setup" and "teardown" methods below will automatically switch to heap storage (just like UTF8String),
+ * if the key/collection name is too long, and performance will be equivalent.
+ * But in the common case of short key/collection names, we can skip the more expensive heap allocation/deallocation.
+**/
+struct YapDatabaseString {
+	int length;
+	char strStack[YapDatabaseStringMaxStackLength];
+	char *strHeap;
+	char *str; // Pointer to either strStack or strHeap
+};
+typedef struct YapDatabaseString YapDatabaseString;
+
+/**
+ * Initializes the YapDatabaseString structure.
+ * It will automatically use heap storage if the given NSString is too long.
+ * 
+ * This method should always be balanced with a call to FreeYapDatabaseString.
+**/
+NS_INLINE void MakeYapDatabaseString(YapDatabaseString *dbStr, NSString *nsStr)
+{
+	if (nsStr)
+	{
+		// We convert to int because the sqlite3_bind_text() function expects an int parameter.
+		// So we can change it to int here, or we can cast everywhere throughout the project.
+		
+		dbStr->length = (int)[nsStr lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
+	
+		if ((dbStr->length + 1) <= YapDatabaseStringMaxStackLength)
+		{
+			dbStr->strHeap = NULL;
+			dbStr->str = dbStr->strStack;
+		}
+		else
+		{
+			dbStr->strHeap = (char *)malloc((dbStr->length + 1));
+			dbStr->str = dbStr->strHeap;
+		}
+	
+		[nsStr getCString:dbStr->str maxLength:(dbStr->length + 1) encoding:NSUTF8StringEncoding];
+	}
+	else
+	{
+		dbStr->length = 0;
+		dbStr->strHeap = NULL;
+		dbStr->str = NULL;
+	}
+}
+
+/**
+ * If heap storage was needed (because the string length exceeded YapDatabaseStringMaxStackLength),
+ * this method frees the heap allocated memory.
+ *
+ * In the common case of stack storage, strHeap will be NULL, and this method is essentially a no-op.
+ * 
+ * This method should be invoked AFTER sqlite3_clear_bindings (assuming SQLITE_STATIC is used).
+**/
+NS_INLINE void FreeYapDatabaseString(YapDatabaseString *dbStr)
+{
+	if (dbStr->strHeap)
+	{
+		free(dbStr->strHeap);
+		dbStr->strHeap = NULL;
+		dbStr->str = NULL;
+	}
+}