motion-yapper 0.0.1 → 0.0.2

data/vendor/Pods/BuildHeaders/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/BuildHeaders/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/BuildHeaders/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

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

@@ -0,0 +1,79 @@
+#import "YapDatabaseRelationshipEdge.h"
+
+enum {
+	YDB_EdgeActionNone   = 0,
+	YDB_EdgeActionInsert = 1,
+	YDB_EdgeActionUpdate = 2,
+	YDB_EdgeActionDelete = 3
+};
+
+enum {
+	YDB_FlagsNone                        = 0,
+	YDB_FlagsSourceDeleted               = 1 << 0,
+	YDB_FlagsDestinationDeleted          = 1 << 1,
+	YDB_FlagsBadSource                   = 1 << 2,
+	YDB_FlagsBadDestination              = 1 << 3,
+	YDB_FlagsHasSourceRowid              = 1 << 4, // If set, sourceRowid lookup not needed
+	YDB_FlagsHasDestinationRowid         = 1 << 5, // If set, destinationRowid lookup not needed
+	YDB_FlagsHasEdgeRowid                = 1 << 6,
+	YDB_FlagsNotInDatabase               = 1 << 7,
+};
+
+
+@interface YapDatabaseRelationshipEdge () {
+@public
+	
+	// Public properties.
+	// Internal code should access these directly.
+	
+	NSString *name;
+	
+	NSString *sourceKey;
+	NSString *sourceCollection;
+	
+	NSString *destinationKey;
+	NSString *destinationCollection;
+	
+	NSString *destinationFilePath;
+	
+	YDB_NodeDeleteRules nodeDeleteRules;
+	
+	BOOL isManualEdge;
+	
+	// Internal properties.
+	// Internal code must access these directly.
+	
+	int64_t edgeRowid;
+	int64_t sourceRowid;
+	int64_t destinationRowid;
+	
+	int edgeAction;
+	int flags;
+}
+
+// Init directly from database row
+- (id)initWithRowid:(int64_t)rowid
+               name:(NSString *)name
+                src:(int64_t)src
+                dst:(int64_t)dst
+        dstFilePath:(NSString *)dstFilePath
+              rules:(int)rules
+             manual:(BOOL)isManual;
+
+// Copy for YapDatabaseRelationshipNode protocol
+- (id)copyWithSourceKey:(NSString *)newSrcKey collection:(NSString *)newSrcCollection rowid:(int64_t)newSrcRowid;
+
+/**
+ * Compares two manual edges to see if they represent the same relationship.
+ * That is, if both edges are manual edges, and the following are equal:
+ * 
+ * - name
+ * - sourceKey / sourceCollection
+ * - destinationKey / destinationCollection
+ * - destinationFilePath
+ * 
+ * The nodeDeleteRules do NOT need to match.
+**/
+- (BOOL)matchesManualEdge:(YapDatabaseRelationshipEdge *)edge;
+
+@end

data/vendor/Pods/BuildHeaders/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/BuildHeaders/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