motion-yapper 0.0.1 → 0.0.2

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

@@ -14,6 +14,9 @@
 @property (nonatomic, strong, readonly) NSString *collection;
 @property (nonatomic, strong, readonly) NSString *key;
 
+- (BOOL)isEqualToCollectionKey:(YapCollectionKey *)collectionKey;
+
+// These methods are overriden and optimized:
 - (BOOL)isEqual:(id)anObject;
 - (NSUInteger)hash;
 

data/vendor/Pods/Headers/YapDatabase/YapDatabase.h

@@ -330,7 +330,7 @@ extern NSString *const YapDatabaseAllKeysRemovedKey;
 
 #if TARGET_OS_IPHONE
 /**
- * Allows you to set the default autoFlushMemoryLevel for all new connections.
+ * Allows you to set the default autoFlushMemoryFlags for all new connections.
  *
  * When you create a connection via [database newConnection], that new connection will inherit
  * its initial configuration via the default values configured for the parent database.
@@ -339,12 +339,12 @@ extern NSString *const YapDatabaseAllKeysRemovedKey;
  * Changing the default values only affects future connections that will be created.
  * It does not affect connections that have already been created.
  * 
- * The default defaultAutoFlushMemoryLevel is YapDatabaseConnectionFlushMemoryLevelMild.
+ * The default defaultAutoFlushMemoryFlags is YapDatabaseConnectionFlushMemoryFlags_All.
  *
  * For more detailed documentation on these properties, see the YapDatabaseConnection header file.
- * @see YapDatabaseConnection autoFlushMemoryLevel
+ * @see YapDatabaseConnection autoFlushMemoryFlags
 **/
-@property (atomic, assign, readwrite) int defaultAutoFlushMemoryLevel;
+@property (atomic, assign, readwrite) int defaultAutoFlushMemoryFlags;
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

data/vendor/Pods/Headers/YapDatabase/YapDatabaseConnection.h

@@ -29,12 +29,14 @@
  * But for conncurrent access between multiple threads you must use multiple connections.
 **/
 
-typedef enum  {
-	YapDatabaseConnectionFlushMemoryLevelNone     = 0,
-	YapDatabaseConnectionFlushMemoryLevelMild     = 1,
-	YapDatabaseConnectionFlushMemoryLevelModerate = 2,
-	YapDatabaseConnectionFlushMemoryLevelFull     = 3,
-} YapDatabaseConnectionFlushMemoryLevel;
+enum  {
+	YapDatabaseConnectionFlushMemoryFlags_None       = 0,
+	YapDatabaseConnectionFlushMemoryFlags_Caches     = 1 << 0,
+	YapDatabaseConnectionFlushMemoryFlags_Statements = 1 << 1,
+	YapDatabaseConnectionFlushMemoryFlags_All        = (YapDatabaseConnectionFlushMemoryFlags_Caches |
+	                                                    YapDatabaseConnectionFlushMemoryFlags_Statements),
+};
+typedef int YapDatabaseConnectionFlushMemoryFlags;
 
 typedef enum {
 	YapDatabasePolicyContainment = 0,
@@ -418,30 +420,30 @@ typedef enum {
  * Depending upon how often you use the database connection,
  * you may want to be more or less aggressive on how much stuff you flush.
  *
- * YapDatabaseConnectionFlushMemoryLevelNone (0):
- *     No-op. Doesn't flush any caches or anything from internal memory.
+ * YapDatabaseConnectionFlushMemoryFlags_None:
+ *     No-op. Doesn't flush anything.
  * 
- * YapDatabaseConnectionFlushMemoryLevelMild (1):
- *     Flushes the object cache and metadata cache.
+ * YapDatabaseConnectionFlushMemoryFlags_Caches:
+ *     Flushes all caches, including the object cache and metadata cache.
  * 
- * YapDatabaseConnectionFlushMemoryLevelModerate (2):
- *     Mild plus drops less common pre-compiled sqlite statements.
+ * YapDatabaseConnectionFlushMemoryFlags_Statements:
+ *     Flushes all pre-compiled sqlite statements.
  * 
- * YapDatabaseConnectionFlushMemoryLevelFull (3):
- *     Full flush of all caches and removes all pre-compiled sqlite statements.
+ * YapDatabaseConnectionFlushMemoryFlags_All:
+ *     Full flush of all caches and  pre-compiled sqlite statements.
 **/
-- (void)flushMemoryWithLevel:(int)level;
+- (void)flushMemoryWithFlags:(YapDatabaseConnectionFlushMemoryFlags)flags;
 
 #if TARGET_OS_IPHONE
 /**
  * When a UIApplicationDidReceiveMemoryWarningNotification is received,
- * the code automatically invokes flushMemoryWithLevel and passes this set level.
+ * the code automatically invokes flushMemoryWithFlags and passes the set flags.
  * 
- * The default value is YapDatabaseConnectionFlushMemoryLevelMild.
+ * The default value is YapDatabaseConnectionFlushMemoryFlags_All.
  * 
- * @see flushMemoryWithLevel:
+ * @see flushMemoryWithFlags:
 **/
-@property (atomic, assign, readwrite) int autoFlushMemoryLevel;
+@property (atomic, assign, readwrite) YapDatabaseConnectionFlushMemoryFlags autoFlushMemoryFlags;
 #endif
 
 @end

data/vendor/Pods/Headers/YapDatabase/YapDatabaseFilteredView.h

@@ -1,26 +1,12 @@
 #import <Foundation/Foundation.h>
 
 #import "YapDatabaseView.h"
+
+#import "YapDatabaseFilteredViewTypes.h"
 #import "YapDatabaseFilteredViewConnection.h"
 #import "YapDatabaseFilteredViewTransaction.h"
 
 
-#ifndef YapDatabaseViewFilteringBlockDefined
-#define YapDatabaseViewFilteringBlockDefined 1
-
-typedef id YapDatabaseViewFilteringBlock; // One of the YapDatabaseViewGroupingX types below.
-
-typedef BOOL (^YapDatabaseViewFilteringWithKeyBlock)     \
-                                        (NSString *group, NSString *collection, NSString *key);
-typedef BOOL (^YapDatabaseViewFilteringWithObjectBlock)  \
-                                        (NSString *group, NSString *collection, NSString *key, id object);
-typedef BOOL (^YapDatabaseViewFilteringWithMetadataBlock)\
-                                        (NSString *group, NSString *collection, NSString *key, id metadata);
-typedef BOOL (^YapDatabaseViewFilteringWithRowBlock)     \
-                                        (NSString *group, NSString *collection, NSString *key, id object, id metadata);
-
-#endif
-
 @interface YapDatabaseFilteredView : YapDatabaseView
 
 /**
@@ -40,6 +26,8 @@ typedef BOOL (^YapDatabaseViewFilteringWithRowBlock)     \
  *   It allows you to filter items from this view that exist in the parent view.
  *   You should pick a block type that requires the minimum number of parameters that you need.
  *
+ *   @see YapDatabaseViewTypes.h for block type definition(s).
+ *
  * @param filteringBlockType
  *
  *   This parameter identifies the type of filtering block being used.
@@ -48,6 +36,8 @@ typedef BOOL (^YapDatabaseViewFilteringWithRowBlock)     \
  *    - YapDatabaseViewBlockTypeWithObject
  *    - YapDatabaseViewBlockTypeWithMetadata
  *    - YapDatabaseViewBlockTypeWithRow
+ * 
+ *   @see YapDatabaseViewTypes.h for block type definition(s).
  *
  * @param tag
  *
@@ -70,12 +60,12 @@ typedef BOOL (^YapDatabaseViewFilteringWithRowBlock)     \
 - (id)initWithParentViewName:(NSString *)viewName
               filteringBlock:(YapDatabaseViewFilteringBlock)filteringBlock
           filteringBlockType:(YapDatabaseViewBlockType)filteringBlockType
-                         tag:(NSString *)tag;
+                  versionTag:(NSString *)versionTag;
 
 - (id)initWithParentViewName:(NSString *)viewName
               filteringBlock:(YapDatabaseViewFilteringBlock)filteringBlock
           filteringBlockType:(YapDatabaseViewBlockType)filteringBlockType
-                         tag:(NSString *)tag
+                  versionTag:(NSString *)versionTag
                      options:(YapDatabaseViewOptions *)options;
 
 @property (nonatomic, strong, readonly) NSString *parentViewName;
@@ -83,23 +73,6 @@ typedef BOOL (^YapDatabaseViewFilteringWithRowBlock)     \
 @property (nonatomic, strong, readonly) YapDatabaseViewFilteringBlock filteringBlock;
 @property (nonatomic, assign, readonly) YapDatabaseViewBlockType filteringBlockType;
 
-/**
- * The tag assists you in updating the filteringBlock.
- *
- * Whenever you change the filteringBlock, just specify a tag to associate with the block.
- * The tag can help you to identify the filtering criteria, or perhaps be used as a versioning scheme.
- *
- * Here's how it works:
- * The very first time you create the filteredView, it will populate itself from the parentView + filteringBlock.
- * On subsequent app launches, when you re-register the filteredView, it will check the passed tag with
- * the tag it has stored from the previous app session. If the tags match then the filteredView knows it doesn't
- * have to do anything. (It's already setup from last app session.) However, if the tags don't match, then
- * the filteredView will re-populate itself.
- * 
- * It works the same way if you change the filteringBlock on-the-fly. (See setFilteringBlock:filteringBlockType:tag:)
-**/
-@property (nonatomic, copy, readonly) NSString *tag;
-
 /**
  * The options allow you to specify things like creating an IN-MEMORY-ONLY VIEW (non persistent).
 **/

data/vendor/Pods/Headers/YapDatabase/YapDatabaseFilteredViewTransaction.h

@@ -1,24 +1,9 @@
 #import <Foundation/Foundation.h>
 
 #import "YapDatabaseViewTransaction.h"
+#import "YapDatabaseFilteredViewTypes.h"
 #import "YapDatabaseFilteredView.h"
 
-#ifndef YapDatabaseViewFilteringBlockDefined
-#define YapDatabaseViewFilteringBlockDefined 1
-
-typedef id YapDatabaseViewFilteringBlock; // One of the YapDatabaseViewGroupingX types below.
-
-typedef BOOL (^YapDatabaseViewFilteringWithKeyBlock)     \
-                                        (NSString *group, NSString *collection, NSString *key);
-typedef BOOL (^YapDatabaseViewFilteringWithObjectBlock)  \
-                                        (NSString *group, NSString *collection, NSString *key, id object);
-typedef BOOL (^YapDatabaseViewFilteringWithMetadataBlock)\
-                                        (NSString *group, NSString *collection, NSString *key, id metadata);
-typedef BOOL (^YapDatabaseViewFilteringWithRowBlock)     \
-                                        (NSString *group, NSString *collection, NSString *key, id object, id metadata);
-
-#endif
-
 
 @interface YapDatabaseFilteredViewTransaction : YapDatabaseViewTransaction
 
@@ -32,8 +17,23 @@ typedef BOOL (^YapDatabaseViewFilteringWithRowBlock)     \
 
 @interface YapDatabaseFilteredViewTransaction (ReadWrite)
 
+/**
+ * This method allows you to change the filterBlock on-the-fly.
+ * 
+ * When you do so, the extension will emit the smallest change-set possible.
+ * That is, it does NOT clear the view and start from scratch.
+ * Rather it performs a quick in-place update.
+ * The end result is a minimal change-set that looks nice for tableView / collectionView animations.
+ * 
+ * For example, in Apple's phone app, in the Recents tab, one can switch between "all" and "missed" calls.
+ * Tapping the "missed" button smoothly animates away all non-red rows. It looks great.
+ * You can get the same effect by using a YapDatabaseFilteredView,
+ * and swapping in/out a filterBlock to allow/disallow non-missed calls.
+ *
+ * Note: You must pass a different versionTag, or this method does nothing.
+**/
 - (void)setFilteringBlock:(YapDatabaseViewFilteringBlock)filteringBlock
        filteringBlockType:(YapDatabaseViewBlockType)filteringBlockType
-                      tag:(NSString *)tag;
+               versionTag:(NSString *)tag;
 
 @end

data/vendor/Pods/Headers/YapDatabase/YapDatabaseFilteredViewTypes.h

@@ -0,0 +1,32 @@
+#import <Foundation/Foundation.h>
+
+
+/**
+ * The filtering block removes items from this view that are in the parent view.
+ *
+ * A YapDatabaseFilteredView will have the same groups and same sort order as the parent,
+ * with the exception of those groups/rows that the filter block returned NO for.
+ *
+ * Here's how it works:
+ * When you initialize a YapDatabaseFilteredView instance, it will enumerate the parentView
+ * and invoke the filter block for every row in every group. So it can quickly copy a parentView as it
+ * doesn't have to perform any sorting.
+ * 
+ * After its initialization, the filterView will automatically run for inserted / updated rows
+ * after the parentView has processed them. It then gets the group from parentView,
+ * and invokes the filterBlock again (if needed).
+ *
+ * You should choose a block type that takes the minimum number of required parameters.
+ * The filterView can make various optimizations based on required parameters of the block.
+**/
+typedef id YapDatabaseViewFilteringBlock; // One of the YapDatabaseViewGroupingX types below.
+
+typedef BOOL (^YapDatabaseViewFilteringWithKeyBlock)     \
+                                        (NSString *group, NSString *collection, NSString *key);
+typedef BOOL (^YapDatabaseViewFilteringWithObjectBlock)  \
+                                        (NSString *group, NSString *collection, NSString *key, id object);
+typedef BOOL (^YapDatabaseViewFilteringWithMetadataBlock)\
+                                        (NSString *group, NSString *collection, NSString *key, id metadata);
+typedef BOOL (^YapDatabaseViewFilteringWithRowBlock)     \
+                                        (NSString *group, NSString *collection, NSString *key, id object, id metadata);
+

data/vendor/Pods/Headers/YapDatabase/YapDatabaseRelationship.h

@@ -0,0 +1,35 @@
+#import <Foundation/Foundation.h>
+
+#import "YapDatabaseExtension.h"
+
+#import "YapDatabaseRelationshipNode.h"
+#import "YapDatabaseRelationshipEdge.h"
+#import "YapDatabaseRelationshipOptions.h"
+#import "YapDatabaseRelationshipConnection.h"
+#import "YapDatabaseRelationshipTransaction.h"
+
+/**
+ * Welcome to YapDatabase!
+ *
+ * The project page has a wealth of documentation if you have any questions.
+ * https://github.com/yaptv/YapDatabase
+ *
+ * If you're new to the project you may want to visit the wiki.
+ * https://github.com/yaptv/YapDatabase/wiki
+ *
+ * The YapDatabaseRelationship extension allow you to create relationships between objects,
+ * and configure automatic deletion rules.
+ *
+ * For tons of information about this extension, see the wiki article:
+ * https://github.com/yaptv/YapDatabase/wiki/Relationships
+**/
+
+@interface YapDatabaseRelationship : YapDatabaseExtension
+
+- (id)init;
+
+- (id)initWithVersion:(int)version;
+
+- (id)initWithVersion:(int)version options:(YapDatabaseRelationshipOptions *)options;
+
+@end

data/vendor/Pods/Headers/YapDatabase/YapDatabaseRelationshipConnection.h

@@ -0,0 +1,29 @@
+#import <Foundation/Foundation.h>
+#import "YapDatabaseExtensionConnection.h"
+
+@class YapDatabaseRelationship;
+
+/**
+ * Welcome to YapDatabase!
+ *
+ * The project page has a wealth of documentation if you have any questions.
+ * https://github.com/yaptv/YapDatabase
+ *
+ * If you're new to the project you may want to visit the wiki.
+ * https://github.com/yaptv/YapDatabase/wiki
+ *
+ * The YapDatabaseRelationship extension allow you to create relationships between objects,
+ * and configure automatic deletion rules.
+ *
+ * For tons of information about this extension, see the wiki article:
+ * https://github.com/yaptv/YapDatabase/wiki/Relationships
+**/
+
+@interface YapDatabaseRelationshipConnection : YapDatabaseExtensionConnection
+
+/**
+ * Returns the parent view instance.
+**/
+@property (nonatomic, strong, readonly) YapDatabaseRelationship *relationship;
+
+@end

data/vendor/Pods/Headers/YapDatabase/YapDatabaseRelationshipEdge.h

@@ -0,0 +1,163 @@
+#import <Foundation/Foundation.h>
+
+/**
+ * Welcome to YapDatabase!
+ *
+ * The project page has a wealth of documentation if you have any questions.
+ * https://github.com/yaptv/YapDatabase
+ *
+ * If you're new to the project you may want to visit the wiki.
+ * https://github.com/yaptv/YapDatabase/wiki
+ *
+ * The YapDatabaseRelationship extension allow you to create relationships between objects,
+ * and configure automatic deletion rules.
+ *
+ * For tons of information about this extension, see the wiki article:
+ * https://github.com/yaptv/YapDatabase/wiki/Relationships
+**/
+
+enum {
+	// notify only
+	YDB_NotifyIfSourceDeleted      = 1 << 0,
+	YDB_NotifyIfDestinationDeleted = 1 << 1,
+	
+	// one-to-one
+	YDB_DeleteSourceIfDestinationDeleted = 1 << 2,
+	YDB_DeleteDestinationIfSourceDeleted = 1 << 3,
+	
+	// one-to-many & many-to-many
+	YDB_DeleteSourceIfAllDestinationsDeleted = 1 << 4,
+	YDB_DeleteDestinationIfAllSourcesDeleted = 1 << 5,
+};
+typedef uint16_t YDB_NodeDeleteRules;
+
+
+@interface YapDatabaseRelationshipEdge : NSObject <NSCoding, NSCopying>
+
+/**
+ * Returns an edge with the given name, destination & nodeDeleteRules.
+ * 
+ * This method is suitable for use with the YapDatabaseRelationshipNode protocol.
+ * When using this protocol, the source object is directly queried by the YapDatabaseRelationship extension.
+ * Thus the extension already knows what the source node is,
+ * and so the source node information (sourceKey & sourceCollection) doesn't need to be explicitly set on the edge.
+ * 
+ * This method is not suitable for use with manual edge management.
+ * When manually adding an edge, you must fully specify the source node.
+**/
++ (instancetype)edgeWithName:(NSString *)name
+              destinationKey:(NSString *)destinationKey
+                  collection:(NSString *)destinationCollection
+             nodeDeleteRules:(YDB_NodeDeleteRules)rules;
+
+/**
+ * Returns an edge with the given name, destinationFilePath & nodeDeleteRules.
+ * 
+ * When using a destinationFilePath, only a subset of the nodeDeleteRules apply.
+ * Specifically only the following work:
+ * - YDB_DeleteDestinationIfSourceDeleted
+ * - YDB_DeleteDestinationIfAllSourcesDeleted
+ *
+ * This method is suitable for use with the YapDatabaseRelationshipNode protocol.
+ * When using this protocol, the source object is directly queried by the YapDatabaseRelationship extension.
+ * Thus the extension already knows what the source node is,
+ * and so the source node information (sourceKey & sourceCollection) doesn't need to be explicitly set on the edge.
+ * 
+ * This method is not suitable for use with manual edge management.
+ * When directly adding an edge, you must fully specify the source node.
+**/
++ (instancetype)edgeWithName:(NSString *)name
+         destinationFilePath:(NSString *)destinationFilePath
+             nodeDeleteRules:(YDB_NodeDeleteRules)rules;
+
+/**
+ * Returns a fully specified edge.
+ * 
+ * This method is suitable for use with manual edge management.
+ * 
+ * If you're using the YapDatabaseRelationshipNode protocol, then you can use the shorter version of this method
+ * which doesn't specify the source node. This is because the source node is implied with the
+ * YapDatabaseRelationshipNode protocol, and thus doesn't need to be explicitly specified in the edge.
+**/
++ (instancetype)edgeWithName:(NSString *)name
+                   sourceKey:(NSString *)sourceKey
+                  collection:(NSString *)sourceCollection
+              destinationKey:(NSString *)destinationKey
+                  collection:(NSString *)destinationCollection
+             nodeDeleteRules:(YDB_NodeDeleteRules)rules;
+
+/**
+ * Returns a fully specified edge.
+ * 
+ * When using a destinationFilePath, only a subset of the nodeDeleteRules apply.
+ * Specifically only the following work:
+ * - YDB_DeleteDestinationIfSourceDeleted
+ * - YDB_DeleteDestinationIfAllSourcesDeleted
+ *
+ * This method is suitable for use with manual edge management.
+ *
+ * If you're using the YapDatabaseRelationshipNode protocol, then you can use the shorter version of this method
+ * which doesn't specify the source node. This is because the source node is implied with the
+ * YapDatabaseRelationshipNode protocol, and thus doesn't need to be explicitly specified in the edge.
+**/
++ (instancetype)edgeWithName:(NSString *)name
+                   sourceKey:(NSString *)sourceKey
+                  collection:(NSString *)sourceCollection
+         destinationFilePath:(NSString *)destinationFilePath
+             nodeDeleteRules:(YDB_NodeDeleteRules)rules;
+
+#pragma mark Init
+
+/**
+ * For documentation @see edgeWithName:destinationKey:collection:nodeDeleteRules:
+**/
+- (id)initWithName:(NSString *)name
+    destinationKey:(NSString *)key
+        collection:(NSString *)collection
+   nodeDeleteRules:(YDB_NodeDeleteRules)rules;
+
+/**
+ * For documentation @see edgeWithName:destinationFilePath:nodeDeleteRules:
+**/
+- (id)initWithName:(NSString *)name destinationFilePath:(NSString *)destinationFilePath
+                                        nodeDeleteRules:(YDB_NodeDeleteRules)rules;
+
+/**
+ * For documentation @see edgeWithName:sourceKey:collection:destinationKey:collection:nodeDeleteRules:
+**/
+- (id)initWithName:(NSString *)name
+         sourceKey:(NSString *)sourceKey
+        collection:(NSString *)sourceCollection
+    destinationKey:(NSString *)destinationKey
+        collection:(NSString *)destinationCollection
+   nodeDeleteRules:(YDB_NodeDeleteRules)rules;
+
+/**
+ * For documentation @see edgeWithName:sourceKey:collection:destinationFilePath:nodeDeleteRules:
+**/
+- (id)initWithName:(NSString *)name sourceKey:(NSString *)sourceKey
+                                   collection:(NSString *)sourceCollection
+                          destinationFilePath:(NSString *)destinationFilePath
+                              nodeDeleteRules:(YDB_NodeDeleteRules)rules;
+
+#pragma mark Properties
+
+@property (nonatomic, copy, readonly) NSString *name;
+
+@property (nonatomic, copy, readonly) NSString *sourceKey;
+@property (nonatomic, copy, readonly) NSString *sourceCollection;
+
+@property (nonatomic, copy, readonly) NSString *destinationKey;
+@property (nonatomic, copy, readonly) NSString *destinationCollection;
+
+@property (nonatomic, copy, readonly) NSString *destinationFilePath;
+
+@property (nonatomic, assign, readonly) YDB_NodeDeleteRules nodeDeleteRules;
+
+/**
+ * NO if the edge was created via the YapDatabaseRelationshipNode protocol.
+ * YES if the edge was created via "manual edge management" methods.
+**/
+@property (nonatomic, assign, readonly) BOOL isManualEdge;
+
+@end