motion-yapper 0.0.1 → 0.0.2

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

@@ -0,0 +1,99 @@
+#import <Foundation/Foundation.h>
+#import "YapDatabaseRelationshipEdge.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
+**/
+
+typedef enum  {
+	YDB_SourceNodeDeleted,
+	YDB_DestinationNodeDeleted,
+} YDB_NotifyReason;
+
+
+/**
+ * There are 2 techniques you may use to add edges to the relationship graph:
+ *
+ * - Use the YapDatabaseRelationshipNode protocol
+ * - Manually manage the edges by adding / removing them yourself
+ *
+ * You are welcome to use either technique. In fact you can use them both simultaneously.
+ * Which you choose may simply be whichever works best depending on the situation.
+ * 
+ * The YapDatabaseRelationshipNode protocol works quite simply:
+ *
+ * Any object that is stored in the database may optionally implement this protocol in order to
+ * specify a list of relationships that apply to it. The object just needs to:
+ * 1.) Add the YapDatabaseRelationshipNode protocol to its declared list of protocols (in header file)
+ * 2.) Implement the yapDatabaseRelationshipEdges method
+ * 
+ * When the object is inserted or updated in the database, the YapDatabaseRelationshipExtension will automatically
+ * invoke the yapDatabaseRelationshipEdges method to get the list of edges. It then inserts the list of edges
+ * into the database (if object was inserted), or updates the previously inserted list (if object was updated).
+ *
+ * Typically this protocol is convenient to use if:
+ * - Your objects already contain identifiers that can be used to create the edges you desire
+ * - You'd like to be able to delete objects in the database by simply setting identifier properties to nil
+ * 
+ * @see YapDatabaseRelationshipEdge
+**/
+@protocol YapDatabaseRelationshipNode <NSObject>
+@required
+
+/**
+ * Implement this method in order to return the edges that start from this node.
+ * Note that although edges are directional, the associated rules are bidirectional.
+ * 
+ * In terms of edge direction, this object is the "source" of the edge.
+ * And the object at the other end of the edge is called the "destination".
+ * 
+ * Every edge also has a name (which can be any string you specify), and a bidirectional rule.
+ * For example, you could specify either of the following:
+ * - delete the destination if I am deleted
+ * - delete me if the destination is deleted
+ * 
+ * In fact, you could specify both of those rules simultaneously for a single edge.
+ * And there are similar rules if your graph is one-to-many for this node.
+ *
+ * Thus it is unnecessary to duplicate the edge on the destination node.
+ * So you can pick which node you'd like to create the edge(s) from.
+ * Either side is fine, just pick whichever is easier, or whichever makes more sense for your data model.
+ *
+ * YapDatabaseRelationship supports one-to-one, one-to-many, and even many-to-many relationships.
+ * 
+ * Important: This method will not be invoked unless the object implements the protocol.
+ * That is, the object's class declaration must have YapDatabaseRelationshipNode in its listed protocols.
+ *
+ * @interface MyObject : NSObject <YapDatabaseRelationshipNode> // <-- Must be in protocol list
+ *
+ * @see YapDatabaseRelationshipEdge
+**/
+- (NSArray *)yapDatabaseRelationshipEdges;
+
+@optional
+
+/**
+ * If an edge is deleted due to one of two associated nodes being deleted,
+ * and the edge has a notify rule associated with it (YDB_NotifyIfSourceDeleted or YDB_NotifyIfDestinationDeleted),
+ * then this method may be invoked on the remaining node.
+ * 
+ * It doesn't matter which side created the edge (the source or destination side).
+ * If the rule exists, and the remaining side implements this particular
+**/
+- (id)yapDatabaseRelationshipEdgeDeleted:(YapDatabaseRelationshipEdge *)edge withReason:(YDB_NotifyReason)reason;
+
+@end
+
+

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

@@ -0,0 +1,59 @@
+#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
+**/
+
+@interface YapDatabaseRelationshipOptions : NSObject <NSCopying>
+
+/**
+ * You can optionally completely disable the YapDatabaseRelationshipProtocol.
+ * 
+ * If you don't use it at all (i.e. you manually manage all graph edges),
+ * then disabling the protocol, and its related processing, can reduce overhead.
+ *
+ * The default value is NO.
+**/
+@property (nonatomic, assign, readwrite) BOOL disableYapDatabaseRelationshipNodeProtocol;
+
+/**
+ * You can configure the extension to pre-filter all but a subset of collections.
+ *
+ * The primary motivation for this is to reduce the overhead when populating the graph.
+ * That is, when you first create the relationship extension, it will automatically enumerate all objects
+ * in the database and check to see if any of them implement the YapDatabaseRelationshipNode protocol.
+ * If there is only a single collection which includes objects implementing the YapDatabaseRelationshipNode protoco,
+ * then you could specify that collection here. So when the extension first populates itself,
+ * it will enumerate over just the allowedCollections, as opposed to enumerating over all collections.
+ * And enumerating a small subset of the entire database during graph population can improve speed,
+ * especially with larger databases.
+ * 
+ * In addition to reducing the overhead when first populating the graph,
+ * the allowedCollections will pre-filter while you're making changes to the database.
+ * So if you add a new object to the database, and the associated collection isn't in allowedCollections,
+ * then the extension will skip any associated processing that would normally occur. (Things like checking to see
+ * if the object implements the YapDatabaseRelationshipNode protocol, and checking to see if there were previously
+ * any associated protocol edges for the object.)
+ *
+ * For all rows whose collection is in the allowedCollections, the extension works normally.
+ *
+ * Note: If you disable the YapDatabaseRelationshipNode protocol, then this configuration option is ignored
+ * because it already skips all associated processing.
+ *
+ * The default value is nil.
+**/
+@property (nonatomic, copy, readwrite) NSSet *allowedCollections;
+
+@end

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

@@ -0,0 +1,384 @@
+#import <Foundation/Foundation.h>
+
+#import "YapDatabaseExtensionTransaction.h"
+#import "YapDatabaseRelationshipEdge.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 YapDatabaseRelationshipTransaction : YapDatabaseExtensionTransaction
+
+#pragma mark Node Fetch
+
+/**
+ * Shortcut for fetching the source object for the given edge.
+ * Equivalent to:
+ * 
+ * [transaction objectForKey:edge.sourceKey inCollection:edge.sourceCollection];
+**/
+- (id)sourceNodeForEdge:(YapDatabaseRelationshipEdge *)edge;
+
+/**
+ * Shortcut for fetching the destination object for the given edge.
+ * Equivalent to:
+ * 
+ * [transaction objectForKey:edge.destinationKey inCollection:edge.destinationCollection];
+**/
+- (id)destinationNodeForEdge:(YapDatabaseRelationshipEdge *)edge;
+
+#pragma mark Enumerate
+
+/**
+ * Enumerates every edge in the graph with the given name.
+ * 
+ * @param name
+ *   The name of the edge (case sensitive).
+**/
+- (void)enumerateEdgesWithName:(NSString *)name
+                    usingBlock:(void (^)(YapDatabaseRelationshipEdge *edge, BOOL *stop))block;
+
+/**
+ * Enumerates every edge that matches any parameters you specify.
+ * You can specify any combination of the following:
+ *
+ * - name only
+ * - sourceKey & sourceCollection only
+ * - name + sourceKey & sourceCollection
+ *
+ * @param name (optional)
+ *   The name of the edge (case sensitive).
+ *
+ * @param sourceKey (optional)
+ *   The edge.sourceKey to match.
+ * 
+ * @param sourceCollection (optional)
+ *   The edge.sourceCollection to match.
+ * 
+ * If you pass a non-nil sourceKey, and sourceCollection is nil,
+ * then the sourceCollection is treated as the empty string, just like the rest of the YapDatabase framework.
+**/
+- (void)enumerateEdgesWithName:(NSString *)name
+                     sourceKey:(NSString *)sourceKey
+                    collection:(NSString *)sourceCollection
+                    usingBlock:(void (^)(YapDatabaseRelationshipEdge *edge, BOOL *stop))block;
+
+/**
+ * Enumerates every edge that matches any parameters you specify.
+ * You can specify any combination of the following:
+ *
+ * - name only
+ * - destinationKey & destinationCollection only
+ * - name + destinationKey & destinationCollection
+ *
+ * @param name (optional)
+ *   The name of the edge (case sensitive).
+ *
+ * @param destinationKey (optional)
+ *   The edge.destinationKey to match.
+ * 
+ * @param destinationCollection (optional)
+ *   The edge.destinationCollection to match.
+ * 
+ * If you pass a non-nil destinationKey, and destinationCollection is nil,
+ * then the destinationCollection is treated as the empty string, just like the rest of the YapDatabase framework.
+**/
+- (void)enumerateEdgesWithName:(NSString *)name
+                destinationKey:(NSString *)destinationKey
+                    collection:(NSString *)destinationCollection
+                    usingBlock:(void (^)(YapDatabaseRelationshipEdge *edge, BOOL *stop))block;
+
+/**
+ * Enumerates every edge that matches any parameters you specify.
+ * You can specify any combination of the following:
+ *
+ * - name only
+ * - destinationFilePath
+ * - name + destinationFilePath
+ *
+ * @param name (optional)
+ *   The name of the edge (case sensitive).
+ *
+ * @param destinationFilePath (optional)
+ *   The edge.destinationFilePath to match.
+**/
+- (void)enumerateEdgesWithName:(NSString *)name
+           destinationFilePath:(NSString *)destinationFilePath
+                    usingBlock:(void (^)(YapDatabaseRelationshipEdge *edge, BOOL *stop))block;
+
+/**
+ * Enumerates every edge that matches any parameters you specify.
+ * You can specify any combination of the following:
+ *
+ * - name only
+ * - sourceKey & sourceCollection only
+ * - destinationKey & destinationCollection only
+ * - name + sourceKey & sourceCollection
+ * - name + destinationKey & destinationCollection
+ * - name + sourceKey & sourceCollection + destinationKey & destinationCollection
+ *
+ * @param name (optional)
+ *   The name of the edge (case sensitive).
+ *
+ * @param sourceKey (optional)
+ *   The edge.sourceKey to match.
+ *
+ * @param sourceCollection (optional)
+ *   The edge.sourceCollection to match.
+ * 
+ * @param destinationKey (optional)
+ *   The edge.destinationKey to match.
+ *
+ * @param destinationCollection (optional)
+ *   The edge.destinationCollection to match.
+ *
+ * If you pass a non-nil sourceKey, and sourceCollection is nil,
+ * then the sourceCollection is treated as the empty string, just like the rest of the YapDatabase framework.
+ * 
+ * If you pass a non-nil destinationKey, and destinationCollection is nil,
+ * then the destinationCollection is treated as the empty string, just like the rest of the YapDatabase framework.
+**/
+- (void)enumerateEdgesWithName:(NSString *)name
+                     sourceKey:(NSString *)sourceKey
+                    collection:(NSString *)sourceCollection
+                destinationKey:(NSString *)destinationKey
+                    collection:(NSString *)destinationCollection
+                    usingBlock:(void (^)(YapDatabaseRelationshipEdge *edge, BOOL *stop))block;
+
+/**
+ * Enumerates every edge that matches any parameters you specify.
+ * You can specify any combination of the following:
+ *
+ * - name only
+ * - sourceKey & sourceCollection only
+ * - destinationKey & destinationCollection only
+ * - name + sourceKey & sourceCollection
+ * - name + destinationKey & destinationCollection
+ * - name + sourceKey & sourceCollection + destinationKey & destinationCollection
+ *
+ * @param name (optional)
+ *   The name of the edge (case sensitive).
+ *
+ * @param sourceKey (optional)
+ *   The edge.sourceKey to match.
+ *
+ * @param sourceCollection (optional)
+ *   The edge.sourceCollection to match.
+ * 
+ * @param destinationFilePath (optional)
+ *   The edge.destinationFilePath to match.
+ *
+ * If you pass a non-nil sourceKey, and sourceCollection is nil,
+ * then the sourceCollection is treated as the empty string, just like the rest of the YapDatabase framework.
+**/
+- (void)enumerateEdgesWithName:(NSString *)name
+                     sourceKey:(NSString *)sourceKey
+                    collection:(NSString *)sourceCollection
+           destinationFilePath:(NSString *)destinationFilePath
+                    usingBlock:(void (^)(YapDatabaseRelationshipEdge *edge, BOOL *stop))block;
+
+#pragma mark Count
+
+/**
+ * Returns a count of every edge in the graph with the given name.
+ * 
+ * @param name
+ *   The name of the edge (case sensitive).
+**/
+- (NSUInteger)edgeCountWithName:(NSString *)name;
+
+/**
+ * Returns a count of every edge that matches any parameters you specify.
+ * You can specify any combination of the following:
+ *
+ * - name only
+ * - sourceKey & sourceCollection only
+ * - name + sourceKey & sourceCollection
+ *
+ * @param name (optional)
+ *   The name of the edge (case sensitive).
+ *
+ * @param sourceKey (optional)
+ *   The edge.sourceKey to match.
+ * 
+ * @param sourceCollection (optional)
+ *   The edge.sourceCollection to match.
+ * 
+ * If you pass a non-nil sourceKey, and sourceCollection is nil,
+ * then the sourceCollection is treated as the empty string, just like the rest of the YapDatabase framework.
+**/
+- (NSUInteger)edgeCountWithName:(NSString *)name
+                      sourceKey:(NSString *)sourceKey
+                     collection:(NSString *)sourceCollection;
+
+/**
+ * Returns a count of every edge that matches any parameters you specify.
+ * You can specify any combination of the following:
+ *
+ * - name only
+ * - destinationKey & destinationCollection only
+ * - name + destinationKey & destinationCollection
+ *
+ * @param name (optional)
+ *   The name of the edge (case sensitive).
+ *
+ * @param destinationKey (optional)
+ *   The edge.destinationKey to match.
+ * 
+ * @param destinationCollection (optional)
+ *   The edge.destinationCollection to match.
+ * 
+ * If you pass a non-nil destinationKey, and destinationCollection is nil,
+ * then the destinationCollection is treated as the empty string, just like the rest of the YapDatabase framework.
+**/
+- (NSUInteger)edgeCountWithName:(NSString *)name
+                 destinationKey:(NSString *)destinationKey
+                     collection:(NSString *)destinationCollection;
+
+/**
+ * Returns a count of every edge that matches any parameters you specify.
+ * You can specify any combination of the following:
+ *
+ * - name only
+ * - destinationFilePath
+ * - name + destinationFilePath
+ *
+ * @param name (optional)
+ *   The name of the edge (case sensitive).
+ *
+ * @param destinationFilePath (optional)
+ *   The edge.destinationFilePath to match.
+**/
+- (NSUInteger)edgeCountWithName:(NSString *)name
+            destinationFilePath:(NSString *)destinationFilePath;
+
+/**
+ * Returns a count of every edge that matches any parameters you specify.
+ * You can specify any combination of the following:
+ *
+ * - name only
+ * - sourceKey & sourceCollection only
+ * - destinationKey & destinationCollection only
+ * - name + sourceKey & sourceCollection
+ * - name + destinationKey & destinationCollection
+ * - name + sourceKey & sourceCollection + destinationKey & destinationCollection
+ *
+ * @param name (optional)
+ *   The name of the edge (case sensitive).
+ *
+ * @param sourceKey (optional)
+ *   The edge.sourceKey to match.
+ *
+ * @param sourceCollection (optional)
+ *   The edge.sourceCollection to match.
+ * 
+ * @param destinationKey (optional)
+ *   The edge.destinationKey to match.
+ *
+ * @param destinationCollection (optional)
+ *   The edge.destinationCollection to match.
+ *
+ * If you pass a non-nil sourceKey, and sourceCollection is nil,
+ * then the sourceCollection is treated as the empty string, just like the rest of the YapDatabase framework.
+ * 
+ * If you pass a non-nil destinationKey, and destinationCollection is nil,
+ * then the destinationCollection is treated as the empty string, just like the rest of the YapDatabase framework.
+**/
+- (NSUInteger)edgeCountWithName:(NSString *)name
+                      sourceKey:(NSString *)sourceKey
+                     collection:(NSString *)sourceCollection
+                 destinationKey:(NSString *)destinationKey
+                     collection:(NSString *)destinationCollection;
+
+/**
+ * Returns a count of every edge that matches any parameters you specify.
+ * You can specify any combination of the following:
+ *
+ * - name only
+ * - sourceKey & sourceCollection only
+ * - destinationFilePath
+ * - name + sourceKey & sourceCollection
+ * - name + destinationFilePath
+ * - name + sourceKey & sourceCollection + destinationFilePath
+ *
+ * @param name (optional)
+ *   The name of the edge (case sensitive).
+ *
+ * @param sourceKey (optional)
+ *   The edge.sourceKey to match.
+ *
+ * @param sourceCollection (optional)
+ *   The edge.sourceCollection to match.
+ * 
+ * @param destinationFilePath (optional)
+ *   The edge.destinationFilePath to match.
+ *
+ * If you pass a non-nil sourceKey, and sourceCollection is nil,
+ * then the sourceCollection is treated as the empty string, just like the rest of the YapDatabase framework.
+**/
+- (NSUInteger)edgeCountWithName:(NSString *)name
+                      sourceKey:(NSString *)sourceKey
+                     collection:(NSString *)sourceCollection
+            destinationFilePath:(NSString *)destinationFilePath;
+
+@end
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+#pragma mark -
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+@interface YapDatabaseRelationshipTransaction (ReadWrite)
+
+#pragma mark Manual Edge Management
+
+/**
+ * There are 2 ways to manage edges (add/remove) using the YapDatabaseRelationship extension:
+ * 
+ * - Manual edge management (via the methods below)
+ * - Implement the YapDatabaseRelationshipNode protocol for some of your objects
+ * 
+ * For more information, see the wiki section "Edge Creation":
+ * 
+ * https://github.com/yaptv/YapDatabase/wiki/Relationships#wiki-edge_creation
+**/
+
+/**
+ * The addEdge: method will add the manual edge (if it doesn't already exist).
+ * Otherwise it will replace the the existing manual edge with the same name & srcKey/collection & dstKey/collection.
+**/
+- (void)addEdge:(YapDatabaseRelationshipEdge *)edge;
+
+- (void)removeEdge:(YapDatabaseRelationshipEdge *)edge;
+
+#pragma mark Force Processing
+
+/**
+ * The extension automatically processes all changes to the graph at the end of a readwrite transaction.
+ * This allows it to consolidate multiple changes into a single batch,
+ * and also minimizes the impact of cascading delete rules, especially in the case where you'll be deleting
+ * many of the objects manually at some later point within the transaction block.
+ * 
+ * However, there may be certain use cases where it is preferable to have the extension execute its rules in advance.
+ * I'm struggling to come up with a really good example, so this semi-convoluted one will have to do:
+ * 
+ * You have a parent object, with a bunch of child objects that have edges to the parent.
+ * You need to replace the parent, and for whatever reason the new parent has the same collection/key.
+ * So instead of doing a setObject:forKey:inCollection:, you first delete the original parent.
+ * At that point you can invoke this flush method, and it will properly delete any child objects.
+ * Then you can safely set the new parent, knowing it won't accidentally inherit any children from the old parent.
+**/
+- (void)flush;
+
+@end