motion-yapper 0.0.1 → 0.0.2

data/vendor/Pods/YapDatabase/YapDatabase/Extensions/Views/YapDatabaseView.h

@@ -1,9 +1,13 @@
 #import <Foundation/Foundation.h>
 
 #import "YapDatabaseExtension.h"
+#import "YapDatabaseViewTypes.h"
 #import "YapDatabaseViewOptions.h"
 #import "YapDatabaseViewConnection.h"
 #import "YapDatabaseViewTransaction.h"
+#import "YapDatabaseViewMappings.h"
+#import "YapDatabaseViewChange.h"
+#import "YapDatabaseViewRangeOptions.h"
 
 /**
  * Welcome to YapDatabase!
@@ -22,122 +26,46 @@
  * Just in case you don't have Internet access,
  * see the quick overview in YapDatabaseView.h.
 **/
+@interface YapDatabaseView : YapDatabaseExtension
 
-/**
- * The grouping block handles both filtering and grouping.
- * 
- * When you add or update rows in the databse the grouping block is invoked.
- * Your grouping block can inspect the row and determine if it should be a part of the view.
- * If not, your grouping block simply returns 'nil' and the object is excluded from the view (removing it if needed).
- * Otherwise your grouping block returns a group, which can be any string you want.
- * Once the view knows what group the row belongs to,
- * it will then determine the position of the row within the group (using the sorting block).
- * 
- * You should choose a block type that takes the minimum number of required parameters.
- * The view can make various optimizations based on required parameters of the block.
-**/
-typedef id YapDatabaseViewGroupingBlock; // One of the YapDatabaseViewGroupingX types below.
+/* Inherited from YapDatabaseExtension
+ 
+@property (nonatomic, strong, readonly) NSString *registeredName;
 
-typedef NSString* (^YapDatabaseViewGroupingWithKeyBlock)(NSString *collection, NSString *key);
-typedef NSString* (^YapDatabaseViewGroupingWithObjectBlock)(NSString *collection, NSString *key, id object);
-typedef NSString* (^YapDatabaseViewGroupingWithMetadataBlock)(NSString *collection, NSString *key, id metadata);
-typedef NSString* (^YapDatabaseViewGroupingWithRowBlock)(NSString *collection, NSString *key, id object, id metadata);
+*/
 
 /**
- * The sorting block handles sorting of objects within their group.
+ * See the wiki for an example of how to initialize a view:
+ * https://github.com/yaptv/YapDatabase/wiki/Views#wiki-initializing_a_view
  *
- * After the view invokes the grouping block to determine what group a database row belongs to (if any),
- * the view then needs to determine what index within that group the row should be.
- * In order to do this, it needs to compare the new/updated row with existing rows in the same view group.
- * This is what the sorting block is used for.
- * So the sorting block will be invoked automatically during this process until the view has come to a conclusion.
+ * @param groupingBlock
  * 
- * You should choose a block type that takes the minimum number of required parameters.
- * The view can make various optimizations based on required parameters of the block.
+ *   The grouping block handles both filtering and grouping.
+ *   
+ *   @see YapDatabaseViewTypes.h for block type definition(s).
  * 
- * For example, if sorting is based on the object, and the metadata of a row is updated,
- * then the view can deduce that the index hasn't changed (if the group hans't), and can skip this step.
+ * @param groupingBlockType
  * 
- * Performance Note:
+ *   Specify the type of groupingBlock that is being passed.
+ *   
+ *   @see YapDatabaseViewTypes.h for block type definition(s).
  * 
- * The view uses various optimizations (based on common patterns)
- * to reduce the number of times it needs to invoke the sorting block.
- *
- * - Pattern      : row is updated, but its index in the view doesn't change.
- *   Optimization : if an updated row doesn't change groups, the view will first compare it with
- *                  objects to the left and right.
- *
- * - Pattern      : rows are added to the beginning or end or a view
- *   Optimization : if the last change put an object at the beginning of the view, then it will test this quickly.
- *                  if the last change put an object at the end of the view, then it will test this quickly.
+ * @param sortingBlock
  * 
- * These optimizations offer huge performance benefits to many common cases.
- * For example, adding objects to a view that are sorted by timestamp of when they arrived.
- *
- * The optimizations are not always performed.
- * That is, if the row is added to a group it didn't previously belong,
- * or if the last change didn't place an item at the beginning or end of the view.
- *
- * If optimizations fail, or are skipped, then the view uses a binary search algorithm.
+ *   The sorting block handles sorting of objects within their group.
+ *   
+ *   @see YapDatabaseViewTypes.h for block type definition(s).
  * 
- * Although this may be considered "internal information",
- * I feel it is important to explain for the following reason:
+ * @param sortingBlockType
  * 
- * Another common pattern is to fetch a number of objects in a batch, and then insert them into the database.
- * Now imagine a situation in which the view is sorting posts based on timestamp,
- * and you just fetched the most recent 10 posts. You can enumerate these 10 posts in forwards or backwards
- * while adding them to the database. One direction will hit the optimization every time. The other will cause
- * the view to perform a binary search every time. These little one-liner optimzations are easy.
-**/
-typedef id YapDatabaseViewSortingBlock; // One of the YapDatabaseViewSortingX types below.
-
-typedef NSComparisonResult (^YapDatabaseViewSortingWithKeyBlock) \
-                 (NSString *group, NSString *collection1, NSString *key1, \
-                                   NSString *collection2, NSString *key2);
-typedef NSComparisonResult (^YapDatabaseViewSortingWithObjectBlock) \
-                 (NSString *group, NSString *collection1, NSString *key1, id object1, \
-                                   NSString *collection2, NSString *key2, id object2);
-typedef NSComparisonResult (^YapDatabaseViewSortingWithMetadataBlock) \
-                 (NSString *group, NSString *collection1, NSString *key1, id metadata, \
-                                   NSString *collection2, NSString *key2, id metadata2);
-typedef NSComparisonResult (^YapDatabaseViewSortingWithRowBlock) \
-                 (NSString *group, NSString *collection1, NSString *key1, id object1, id metadata1, \
-                                   NSString *collection2, NSString *key2, id object2, id metadata2);
-
-#ifndef YapDatabaseViewBlockTypeDefined
-#define YapDatabaseViewBlockTypeDefined 1
-
-/**
- * I wish there was a way to inspect a given block and see what kind of parameters it takes.
- * Sadly this does not appear to be possible (at least not in any kind of standard legal way).
- * 
- * Thus, unfortunately (for now), you will have to specify what kind of block you're passing.
-**/
-typedef enum {
-	YapDatabaseViewBlockTypeWithKey       = 1,
-	YapDatabaseViewBlockTypeWithObject    = 2,
-	YapDatabaseViewBlockTypeWithMetadata  = 3,
-	YapDatabaseViewBlockTypeWithRow       = 4
-} YapDatabaseViewBlockType;
-
-#endif
-
-@interface YapDatabaseView : YapDatabaseExtension
-
-/* Inherited from YapDatabaseExtension
- 
-@property (nonatomic, strong, readonly) NSString *registeredName;
-
-*/
-
-/**
- * See the wiki for an example of how to initialize a view:
- * https://github.com/yaptv/YapDatabase/wiki/Views#wiki-initializing_a_view
+ *   Specify the type of sortingBlock that is being passed.
+ *   
+ *   @see YapDatabaseViewTypes.h for block type definition(s).
  *
- * @param version
+ * @param versionTag
  *
  *   If, after creating a view, you need to change either the groupingBlock or sortingBlock,
- *   then simply use the version parameter. If you pass a version that is different from the last
+ *   then simply use the versionTag parameter. If you pass a versionTag that is different from the last
  *   initialization of the view, then the view will automatically flush its tables, and re-populate itself.
  *
  * @param options
@@ -154,13 +82,13 @@ typedef enum {
           groupingBlockType:(YapDatabaseViewBlockType)groupingBlockType
                sortingBlock:(YapDatabaseViewSortingBlock)sortingBlock
            sortingBlockType:(YapDatabaseViewBlockType)sortingBlockType
-                    version:(int)version;
+                 versionTag:(NSString *)versionTag;
 
 - (id)initWithGroupingBlock:(YapDatabaseViewGroupingBlock)groupingBlock
           groupingBlockType:(YapDatabaseViewBlockType)groupingBlockType
                sortingBlock:(YapDatabaseViewSortingBlock)sortingBlock
            sortingBlockType:(YapDatabaseViewBlockType)sortingBlockType
-                    version:(int)version
+                 versionTag:(NSString *)versionTag
                     options:(YapDatabaseViewOptions *)options;
 
 @property (nonatomic, strong, readonly) YapDatabaseViewGroupingBlock groupingBlock;
@@ -170,13 +98,26 @@ typedef enum {
 @property (nonatomic, assign, readonly) YapDatabaseViewBlockType sortingBlockType;
 
 /**
- * The version assists you in updating your blocks.
+ * The versionTag assists you in updating your blocks.
  *
  * If you need to change the groupingBlock or sortingBlock,
- * then simply pass an incremented version during the init method,
- * and the view will automatically update itself.
+ * then simply pass a different versionTag during the init method, and the view will automatically update itself.
+ * 
+ * If you want to keep things simple, you can use something like @"1",
+ * representing version 1 of my groupingBlock & sortingBlock.
+ * 
+ * For more advanced applications, you may also include within the versionTag string:
+ * - localization information (if you're using localized sorting routines)
+ * - configuration information (if your sorting routine is based on some in-app configuration)
+ *
+ * For example, if you're sorting strings using a localized string compare method, then embedding the localization
+ * information into your versionTag means the view will automatically re-populate itself (re-sort)
+ * if the user launches the app in a different language than last time.
+ * 
+ * NSString *localeIdentifier = [[NSLocale currentLocale] localeIdentifier];
+ * NSString *versionTag = [NSString stringWithFormat:@"1-%@", localeIdentifier];
 **/
-@property (nonatomic, assign, readonly) int version;
+@property (nonatomic, copy, readonly) NSString *versionTag;
 
 /**
  * The options allow you to specify things like creating an in-memory-only view (non persistent).

data/vendor/Pods/YapDatabase/YapDatabase/Extensions/Views/YapDatabaseView.m

@@ -89,7 +89,7 @@
 @synthesize groupingBlockType = groupingBlockType;
 @synthesize sortingBlockType = sortingBlockType;
 
-@synthesize version = version;
+@synthesize versionTag = versionTag;
 @dynamic options;
 
 - (id)initWithGroupingBlock:(YapDatabaseViewGroupingBlock)inGroupingBlock
@@ -101,7 +101,7 @@
 	                 groupingBlockType:inGroupingBlockType
 	                      sortingBlock:inSortingBlock
 	                  sortingBlockType:inSortingBlockType
-	                           version:0
+	                        versionTag:@""
 	                           options:nil];
 }
 
@@ -109,13 +109,13 @@
           groupingBlockType:(YapDatabaseViewBlockType)inGroupingBlockType
                sortingBlock:(YapDatabaseViewSortingBlock)inSortingBlock
            sortingBlockType:(YapDatabaseViewBlockType)inSortingBlockType
-                    version:(int)inVersion
+                 versionTag:(NSString *)inVersionTag
 {
 	return [self initWithGroupingBlock:inGroupingBlock
 	                 groupingBlockType:inGroupingBlockType
 	                      sortingBlock:inSortingBlock
 	                  sortingBlockType:inSortingBlockType
-	                           version:inVersion
+	                        versionTag:inVersionTag
 	                           options:nil];
 }
 
@@ -123,11 +123,14 @@
           groupingBlockType:(YapDatabaseViewBlockType)inGroupingBlockType
                sortingBlock:(YapDatabaseViewSortingBlock)inSortingBlock
            sortingBlockType:(YapDatabaseViewBlockType)inSortingBlockType
-                    version:(int)inVersion
-                    options:(YapDatabaseViewOptions *)inOptions;
+                 versionTag:(NSString *)inVersionTag
+                    options:(YapDatabaseViewOptions *)inOptions
 {
 	if ((self = [super init]))
 	{
+		NSAssert(inGroupingBlock != NULL, @"Invalid grouping block");
+		NSAssert(inSortingBlock != NULL, @"Invalid sorting block");
+		
 		NSAssert(inGroupingBlockType == YapDatabaseViewBlockTypeWithKey ||
 		         inGroupingBlockType == YapDatabaseViewBlockTypeWithObject ||
 		         inGroupingBlockType == YapDatabaseViewBlockTypeWithMetadata ||
@@ -146,7 +149,7 @@
 		sortingBlock = inSortingBlock;
 		sortingBlockType = inSortingBlockType;
 		
-		version = inVersion;
+		versionTag = inVersionTag ? [inVersionTag copy] : @"";
 		
 		options = inOptions ? [inOptions copy] : [[YapDatabaseViewOptions alloc] init];
 	}

data/vendor/Pods/YapDatabase/YapDatabase/Extensions/Views/YapDatabaseViewConnection.h

@@ -1,4 +1,5 @@
 #import <Foundation/Foundation.h>
+
 #import "YapDatabaseExtensionConnection.h"
 #import "YapDatabaseViewChange.h"
 #import "YapDatabaseViewMappings.h"

data/vendor/Pods/YapDatabase/YapDatabase/Extensions/Views/YapDatabaseViewConnection.m

@@ -69,6 +69,11 @@ static NSString *const key_changes                  = @"changes";
 }
 
 - (void)dealloc
+{
+	[self _flushStatements];
+}
+
+- (void)_flushStatements
 {
 	sqlite_finalize_null(&mapTable_getPageKeyForRowidStatement);
 	sqlite_finalize_null(&mapTable_setPageKeyForRowidStatement);
@@ -87,33 +92,17 @@ static NSString *const key_changes                  = @"changes";
 /**
  * Required override method from YapDatabaseExtensionConnection
 **/
-- (void)_flushMemoryWithLevel:(int)level
+- (void)_flushMemoryWithFlags:(YapDatabaseConnectionFlushMemoryFlags)flags
 {
-	if (level >= YapDatabaseConnectionFlushMemoryLevelMild)
+	if (flags & YapDatabaseConnectionFlushMemoryFlags_Caches)
 	{
 		[mapCache removeAllObjects];
 		[pageCache removeAllObjects];
 	}
 	
-	if (level >= YapDatabaseConnectionFlushMemoryLevelModerate)
+	if (flags & YapDatabaseConnectionFlushMemoryFlags_Statements)
 	{
-		sqlite_finalize_null(&mapTable_setPageKeyForRowidStatement);
-		sqlite_finalize_null(&mapTable_removeForRowidStatement);
-		sqlite_finalize_null(&mapTable_removeAllStatement);
-		
-		sqlite_finalize_null(&pageTable_insertForPageKeyStatement);
-		sqlite_finalize_null(&pageTable_updateAllForPageKeyStatement);
-		sqlite_finalize_null(&pageTable_updatePageForPageKeyStatement);
-		sqlite_finalize_null(&pageTable_updateLinkForPageKeyStatement);
-		sqlite_finalize_null(&pageTable_removeForPageKeyStatement);
-		sqlite_finalize_null(&pageTable_removeAllStatement);
-	}
-	
-	if (level >= YapDatabaseConnectionFlushMemoryLevelFull)
-	{
-		sqlite_finalize_null(&mapTable_getPageKeyForRowidStatement);
-		
-		sqlite_finalize_null(&pageTable_getDataForPageKeyStatement);
+		[self _flushStatements];
 	}
 }
 
@@ -293,7 +282,9 @@ static NSString *const key_changes                  = @"changes";
 	NSMutableDictionary *externalChangeset = nil;
 	BOOL hasDiskChanges = NO;
 	
-	if ([dirtyMaps count] || [dirtyPages count] || [dirtyLinks count] || reset)
+	if ([dirtyMaps count]  > 0 ||
+	    [dirtyPages count] > 0 ||
+	    [dirtyLinks count] > 0 || reset)
 	{
 		hasDiskChanges = view->options.isPersistent;
 		internalChangeset = [NSMutableDictionary dictionaryWithSharedKeySet:sharedKeySetForInternalChangeset];
@@ -323,7 +314,7 @@ static NSString *const key_changes                  = @"changes";
 		[internalChangeset setObject:pageKey_group_dict_copy       forKey:key_pageKey_group_dict];
 	}
 	
-	if ([changes count])
+	if ([changes count] > 0)
 	{
 		externalChangeset = [NSMutableDictionary dictionaryWithSharedKeySet:sharedKeySetForExternalChangeset];
 		

data/vendor/Pods/YapDatabase/YapDatabase/Extensions/Views/YapDatabaseViewOptions.h

@@ -43,11 +43,18 @@
  * 
  * The primary motivation for this is to reduce the overhead when first populating the view.
  * For example, if you're creating a view which only includes objects from a single collection,
- * then you could specify that collection here. And when the view first populates itself,
+ * then you could specify that collection here. So when the view 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 view population can improve speed,
+ * especially with larger databases.
  * 
- * The groupingBlock will still be invoked, but only if the collection is contained in allowedCollections.
- * If not, the view will not invoke the groupingBlock, and act as if the groupingBlock had returned nil.
+ * In addition to reducing the overhead when first populating the view,
+ * 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 groupingBlock will never be invoked, and the view will act as if the groupingBlock returned nil.
+ * 
+ * For all rows whose collection is in the allowedCollections, the view acts normally.
+ * So the groupingBlock would still be invoked as normal.
  *
  * The default value is nil.
 **/

data/vendor/Pods/YapDatabase/YapDatabase/Extensions/Views/YapDatabaseViewTransaction.h

@@ -1,5 +1,7 @@
 #import <Foundation/Foundation.h>
+
 #import "YapDatabaseExtensionTransaction.h"
+#import "YapDatabaseViewTypes.h"
 #import "YapDatabaseViewMappings.h"
 
 /**
@@ -127,18 +129,6 @@ typedef NSComparisonResult (^YapDatabaseViewFindWithMetadataBlock) \
 typedef NSComparisonResult (^YapDatabaseViewFindWithRowBlock)      \
                                                         (NSString *collection, NSString *key, id object, id metadata);
 
-#ifndef YapDatabaseViewBlockTypeDefined
-#define YapDatabaseViewBlockTypeDefined 1
-
-typedef enum {
-	YapDatabaseViewBlockTypeWithKey       = 201,
-	YapDatabaseViewBlockTypeWithObject    = 202,
-	YapDatabaseViewBlockTypeWithMetadata  = 203,
-	YapDatabaseViewBlockTypeWithRow       = 204
-} YapDatabaseViewBlockType;
-
-#endif
-
 /**
  * This method uses a binary search algorithm to find a range of items within the view that match the given criteria.
  * For example:
@@ -314,6 +304,17 @@ typedef enum {
 - (void)touchObjectForKey:(NSString *)key inCollection:(NSString *)collection;
 - (void)touchMetadataForKey:(NSString *)key inCollection:(NSString *)collection;
 
+/**
+ * This method allows you to change the groupingBlock and/or sortingBlock on-the-fly.
+ * 
+ * Note: You must pass a different versionTag, or this method does nothing.
+**/
+- (void)setGroupingBlock:(YapDatabaseViewGroupingBlock)groupingBlock
+       groupingBlockType:(YapDatabaseViewBlockType)groupingBlockType
+            sortingBlock:(YapDatabaseViewSortingBlock)sortingBlock
+        sortingBlockType:(YapDatabaseViewBlockType)sortingBlockType
+              versionTag:(NSString *)versionTag;
+
 @end
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -331,30 +332,30 @@ typedef enum {
 /**
  * Equivalent to invoking:
  *
- * NSString *collection = nil;
- * NSString *key = nil;
- * [[transaction ext:@"myView"] getKey:&key collection:&collection atIndex:index inGroup:group];
- * [transaction objectForKey:key inCollection:collection];
+ * NSString *collection, *key;
+ * if ([[transaction ext:@"myView"] getKey:&key collection:&collection atIndex:index inGroup:group]) {
+ *     object = [transaction objectForKey:key inCollection:collection];
+ * }
 **/
 - (id)objectAtIndex:(NSUInteger)keyIndex inGroup:(NSString *)group;
 
 /**
  * Equivalent to invoking:
  *
- * NSString *collection = nil;
- * NSString *key = nil;
- * [[transaction ext:@"myView"] getFirstKey:&key collection:&collection inGroup:group];
- * [transaction objectForKey:key inCollection:collection];
+ * NSString *collection, *key;
+ * if ([[transaction ext:@"myView"] getFirstKey:&key collection:&collection inGroup:group]) {
+ *     object = [transaction objectForKey:key inCollection:collection];
+ * }
 **/
 - (id)firstObjectInGroup:(NSString *)group;
 
 /**
  * Equivalent to invoking:
  *
- * NSString *collection = nil;
- * NSString *key = nil;
- * [[transaction ext:@"myView"] getLastKey:&key collection:&collection inGroup:group];
- * [transaction objectForKey:key inCollection:collection];
+ * NSString *collection, *key;
+ * if ([[transaction ext:@"myView"] getLastKey:&key collection:&collection inGroup:group]) {
+ *     object = [transaction objectForKey:key inCollection:collection];
+ * }
 **/
 - (id)lastObjectInGroup:(NSString *)group;
 
@@ -436,6 +437,45 @@ typedef enum {
    atIndexPath:(NSIndexPath *)indexPath
   withMappings:(YapDatabaseViewMappings *)mappings;
 
+/**
+ * Gets the key & collection at the given row & section, assuming the given mappings are being used.
+ * Returns NO if the row or section is invalid, or the mappings aren't initialized.
+ * Otherwise returns YES, and sets the key & collection ptr (both optional).
+**/
+- (BOOL)getKey:(NSString **)keyPtr
+    collection:(NSString **)collectionPtr
+        forRow:(NSUInteger)row
+     inSection:(NSUInteger)section
+  withMappings:(YapDatabaseViewMappings *)mappings;
+
+/**
+ * Gets the object at the given indexPath, assuming the given mappings are being used.
+ * 
+ * Equivalent to invoking:
+ *
+ * NSString *collection, *key;
+ * if ([[transaction ext:@"myView"] getKey:&key collection:&collection atIndexPath:indexPath withMappings:mappings]) {
+ *     object = [transaction objectForKey:key inCollection:collection];
+ * }
+**/
+- (id)objectAtIndexPath:(NSIndexPath *)indexPath withMappings:(YapDatabaseViewMappings *)mappings;
+
+/**
+ * Gets the object at the given indexPath, assuming the given mappings are being used.
+ *
+ * Equivalent to invoking:
+ *
+ * NSString *collection, *key;
+ * if ([[transaction ext:@"view"] getKey:&key
+ *                            collection:&collection
+ *                                forRow:row
+ *                             inSection:section
+ *                          withMappings:mappings]) {
+ *     object = [transaction objectForKey:key inCollection:collection];
+ * }
+**/
+- (id)objectAtRow:(NSUInteger)row inSection:(NSUInteger)section withMappings:(YapDatabaseViewMappings *)mappings;
+
 /**
  * Fetches the indexPath for the given {collection, key} tuple, assuming the given mappings are being used.
  * Returns nil if the {collection, key} tuple isn't included in the view + mappings.
@@ -444,4 +484,15 @@ typedef enum {
                     inCollection:(NSString *)collection
                     withMappings:(YapDatabaseViewMappings *)mappings;
 
+/**
+ * Fetches the row & section for the given {collection, key} tuple, assuming the given mappings are being used.
+ * Returns NO if the {collection, key} tuple isn't included in the view + mappings.
+ * Otherwise returns YES, and sets the row & section (both optional).
+**/
+- (BOOL)getRow:(NSUInteger *)rowPtr
+       section:(NSUInteger *)sectionPtr
+        forKey:(NSString *)key
+  inCollection:(NSString *)collection
+  withMappings:(YapDatabaseViewMappings *)mappings;
+
 @end