motion-yapper 0.0.3 → 0.1.0

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

@@ -1,149 +0,0 @@
-#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;
-
-/**
- * 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
- * 
- * @param version
- * 
- *   If, after creating the secondary index(es), you need to change the setup or block,
- *   then simply increment the version parameter. If you pass a version that is different from the last
- *   initialization of the extension, then it will automatically re-create itself.
- *
- * @see YapDatabaseSecondaryIndexSetup
- * @see YapDatabase registerExtension:withName:
-**/
-- (id)initWithSetup:(YapDatabaseSecondaryIndexSetup *)setup
-              block:(YapDatabaseSecondaryIndexBlock)block
-          blockType:(YapDatabaseSecondaryIndexBlockType)blockType
-            version:(int)version;
-
-/**
- * The version assists in making changes to the extension.
- *
- * If you need to change the columnNames and/or block,
- * then simply pass an incremented version during the init method,
- * and the FTS extension will automatically update itself.
-**/
-@property (nonatomic, assign, readonly) int version;
-
-@end

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

@@ -1,33 +0,0 @@
-#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/Headers/YapDatabase/YapDatabaseSecondaryIndexSetup.h

@@ -1,33 +0,0 @@
-#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/Headers/YapDatabase/YapDatabaseSecondaryIndexTransaction.h

@@ -1,58 +0,0 @@
-#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/Headers/YapDatabase/YapDatabaseTransaction.h

@@ -1,651 +0,0 @@
-#import <Foundation/Foundation.h>
-
-@class YapDatabaseConnection;
-
-/**
- * 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
- * 
- * Transactions represent atomic access to a database.
- * There are two types of transactions:
- * - Read-Only transactions
- * - Read-Write transactions
- *
- * Once a transaction is started, all data access within the transaction from that point forward until completion
- * represents an atomic "snapshot" of the current state of the database. For example, if a read-write operation
- * occurs in parallel with a read-only transaction, the read-only transaction won't see the changes made by
- * the read-write operation. But once the read-write operation completes, all transactions started from that point
- * forward will see the changes.
- *
- * You first create and configure a YapDatabase instance.
- * Then you can spawn one or more connections to the database file.
- * Each connection allows you to execute transactions in a serial fashion.
- * For concurrent access, you can create multiple connections,
- * and execute transactions on each connection simulataneously.
- *
- * Concurrency is straight-forward. Here are the rules:
- *
- * - You can have multiple connections.
- * - Every connection is thread-safe.
- * - You can have multiple read-only transactions simultaneously without blocking.
- *   (Each simultaneous transaction would be going through a separate connection.)
- * - You can have multiple read-only transactions and a single read-write transaction simultaneously without blocking.
- *   (Each simultaneous transaction would be going through a separate connection.)
- * - There can only be a single transaction per connection at a time.
- *   (Transactions go through a per-connection serial queue.)
- * - There can only be a single read-write transaction at a time.
- *   (Read-write transactions go through a per-database serial queue.)
-**/
-
-/**
- * A YapDatabaseReadTransaction encompasses a single read-only database transaction.
- * You can execute multiple operations within a single transaction.
- *
- * A transaction allows you to safely access the database as needed in a thread-safe and optimized manner.
-**/
-@interface YapDatabaseReadTransaction : NSObject
-
-/**
- * Transactions are light-weight objects created by connections.
- *
- * Connections are the parent objects of transactions.
- * Connections own the transaction objects.
- *
- * Transactions store nearly all their state in the parent connection object.
- * This reduces the memory requirements for transactions objects,
- * and reduces the overhead associated in creating them.
-**/
-@property (nonatomic, unsafe_unretained, readonly) YapDatabaseConnection *connection;
-
-#pragma mark Count
-
-/**
- * Returns the total number of collections.
- * Each collection may have 1 or more key/object pairs.
-**/
-- (NSUInteger)numberOfCollections;
-
-/**
- * Returns the total number of keys in the given collection.
- * Returns zero if the collection doesn't exist (or all key/object pairs from the collection have been removed).
-**/
-- (NSUInteger)numberOfKeysInCollection:(NSString *)collection;
-
-/**
- * Returns the total number of key/object pairs in the entire database (including all collections).
-**/
-- (NSUInteger)numberOfKeysInAllCollections;
-
-#pragma mark List
-
-/**
- * Returns a list of all collection names.
-**/
-- (NSArray *)allCollections;
-
-/**
- * Returns a list of all keys in the given collection.
-**/
-- (NSArray *)allKeysInCollection:(NSString *)collection;
-
-#pragma mark Primitive
-
-/**
- * Primitive access.
- *
- * These are available for in-case you store irregular data
- * that shouldn't go through configured serializer/deserializer.
- *
- * @see objectForKey:inCollection:
- * @see metadataForKey:inCollection:
-**/
-- (NSData *)primitiveDataForKey:(NSString *)key inCollection:(NSString *)collection;
-- (NSData *)primitiveMetadataForKey:(NSString *)key inCollection:(NSString *)collection;
-- (BOOL)getPrimitiveData:(NSData **)dataPtr
-       primitiveMetadata:(NSData **)primitiveMetadataPtr
-                  forKey:(NSString *)key
-            inCollection:(NSString *)collection;
-
-#pragma mark Object & Metadata
-
-/**
- * Object access.
- * Objects are automatically deserialized using database's configured deserializer.
-**/
-- (id)objectForKey:(NSString *)key inCollection:(NSString *)collection;
-
-/**
- * Returns whether or not the given key/collection exists in the database.
-**/
-- (BOOL)hasObjectForKey:(NSString *)key inCollection:(NSString *)collection;
-
-/**
- * Provides access to both object and metadata in a single call.
- *
- * @return YES if the key exists in the database. NO otherwise, in which case both object and metadata will be nil.
-**/
-- (BOOL)getObject:(id *)objectPtr metadata:(id *)metadataPtr forKey:(NSString *)key inCollection:(NSString *)collection;
-
-/**
- * Provides access to the metadata.
- * This fetches directly from the metadata dictionary stored in memory, and thus never hits the disk.
-**/
-- (id)metadataForKey:(NSString *)key inCollection:(NSString *)collection;
-
-#pragma mark Enumerate
-
-/**
- * Fast enumeration over all the collections in the database.
- * 
- * This uses a "SELECT collection FROM database" operation,
- * and then steps over the results invoking the given block handler.
-**/
-- (void)enumerateCollectionsUsingBlock:(void (^)(NSString *collection, BOOL *stop))block;
-
-/**
- * This method is rarely needed, but may be helpful in certain situations.
- * 
- * This method may be used if you have the key, but not the collection for a particular item.
- * Please note that this is not the ideal situation.
- * 
- * Since there may be numerous collections for a given key, this method enumerates all possible collections.
-**/
-- (void)enumerateCollectionsForKey:(NSString *)key usingBlock:(void (^)(NSString *collection, BOOL *stop))block;
-
-/**
- * Fast enumeration over all keys in the given collection.
- *
- * This uses a "SELECT key FROM database WHERE collection = ?" operation,
- * and then steps over the results invoking the given block handler.
-**/
-- (void)enumerateKeysInCollection:(NSString *)collection
-                       usingBlock:(void (^)(NSString *key, BOOL *stop))block;
-
-/**
- * Fast enumeration over all keys in the given collection.
- *
- * This uses a "SELECT collection, key FROM database" operation,
- * and then steps over the results invoking the given block handler.
-**/
-- (void)enumerateKeysInAllCollectionsUsingBlock:(void (^)(NSString *collection, NSString *key, BOOL *stop))block;
-
-/**
- * Fast enumeration over all keys and associated metadata in the given collection.
- * 
- * This uses a "SELECT key, metadata FROM database WHERE collection = ?" operation and steps over the results.
- * 
- * If you only need to enumerate over certain items (e.g. keys with a particular prefix),
- * consider using the alternative version below which provides a filter,
- * allowing you to skip the deserialization step for those items you're not interested in.
- * 
- * Keep in mind that you cannot modify the collection mid-enumeration (just like any other kind of enumeration).
-**/
-- (void)enumerateKeysAndMetadataInCollection:(NSString *)collection
-                                  usingBlock:(void (^)(NSString *key, id metadata, BOOL *stop))block;
-
-/**
- * Fast enumeration over all keys and associated metadata in the given collection.
- *
- * From the filter block, simply return YES if you'd like the block handler to be invoked for the given key.
- * If the filter block returns NO, then the block handler is skipped for the given key,
- * which avoids the cost associated with deserializing the object.
- * 
- * Keep in mind that you cannot modify the collection mid-enumeration (just like any other kind of enumeration).
-**/
-- (void)enumerateKeysAndMetadataInCollection:(NSString *)collection
-                                  usingBlock:(void (^)(NSString *key, id metadata, BOOL *stop))block
-                                  withFilter:(BOOL (^)(NSString *key))filter;
-
-
-
-/**
- * Fast enumeration over all key/metadata pairs in all collections.
- * 
- * This uses a "SELECT metadata FROM database ORDER BY collection ASC" operation, and steps over the results.
- * 
- * If you only need to enumerate over certain objects (e.g. keys with a particular prefix),
- * consider using the alternative version below which provides a filter,
- * allowing you to skip the deserialization step for those objects you're not interested in.
- * 
- * Keep in mind that you cannot modify the database mid-enumeration (just like any other kind of enumeration).
-**/
-- (void)enumerateKeysAndMetadataInAllCollectionsUsingBlock:
-                                        (void (^)(NSString *collection, NSString *key, id metadata, BOOL *stop))block;
-
-/**
- * Fast enumeration over all key/metadata pairs in all collections.
- *
- * This uses a "SELECT metadata FROM database ORDER BY collection ASC" operation and steps over the results.
- * 
- * From the filter block, simply return YES if you'd like the block handler to be invoked for the given key.
- * If the filter block returns NO, then the block handler is skipped for the given key,
- * which avoids the cost associated with deserializing the object.
- *
- * Keep in mind that you cannot modify the database mid-enumeration (just like any other kind of enumeration).
- **/
-- (void)enumerateKeysAndMetadataInAllCollectionsUsingBlock:
-                                        (void (^)(NSString *collection, NSString *key, id metadata, BOOL *stop))block
-                             withFilter:(BOOL (^)(NSString *collection, NSString *key))filter;
-
-/**
- * Fast enumeration over all objects in the database.
- *
- * This uses a "SELECT key, object from database WHERE collection = ?" operation, and then steps over the results,
- * deserializing each object, and then invoking the given block handler.
- *
- * If you only need to enumerate over certain objects (e.g. keys with a particular prefix),
- * consider using the alternative version below which provides a filter,
- * allowing you to skip the serialization step for those objects you're not interested in.
-**/
-- (void)enumerateKeysAndObjectsInCollection:(NSString *)collection
-                                 usingBlock:(void (^)(NSString *key, id object, BOOL *stop))block;
-
-/**
- * Fast enumeration over objects in the database for which you're interested in.
- * The filter block allows you to decide which objects you're interested in.
- *
- * From the filter block, simply return YES if you'd like the block handler to be invoked for the given key.
- * If the filter block returns NO, then the block handler is skipped for the given key,
- * which avoids the cost associated with deserializing the object.
-**/
-- (void)enumerateKeysAndObjectsInCollection:(NSString *)collection
-                                 usingBlock:(void (^)(NSString *key, id object, BOOL *stop))block
-                                 withFilter:(BOOL (^)(NSString *key))filter;
-
-/**
- * Enumerates all key/object pairs in all collections.
- * 
- * The enumeration is sorted by collection. That is, it will enumerate fully over a single collection
- * before moving onto another collection.
- * 
- * If you only need to enumerate over certain objects (e.g. subset of collections, or keys with a particular prefix),
- * consider using the alternative version below which provides a filter,
- * allowing you to skip the serialization step for those objects you're not interested in.
-**/
-- (void)enumerateKeysAndObjectsInAllCollectionsUsingBlock:
-                                            (void (^)(NSString *collection, NSString *key, id object, BOOL *stop))block;
-
-/**
- * Enumerates all key/object pairs in all collections.
- * The filter block allows you to decide which objects you're interested in.
- *
- * The enumeration is sorted by collection. That is, it will enumerate fully over a single collection
- * before moving onto another collection.
- * 
- * From the filter block, simply return YES if you'd like the block handler to be invoked for the given
- * collection/key pair. If the filter block returns NO, then the block handler is skipped for the given pair,
- * which avoids the cost associated with deserializing the object.
-**/
-- (void)enumerateKeysAndObjectsInAllCollectionsUsingBlock:
-                                            (void (^)(NSString *collection, NSString *key, id object, BOOL *stop))block
-                                 withFilter:(BOOL (^)(NSString *collection, NSString *key))filter;
-
-/**
- * Fast enumeration over all rows in the database.
- *
- * This uses a "SELECT key, data, metadata from database WHERE collection = ?" operation,
- * and then steps over the results, deserializing each object & metadata, and then invoking the given block handler.
- *
- * If you only need to enumerate over certain rows (e.g. keys with a particular prefix),
- * consider using the alternative version below which provides a filter,
- * allowing you to skip the serialization step for those rows you're not interested in.
-**/
-- (void)enumerateRowsInCollection:(NSString *)collection
-                       usingBlock:(void (^)(NSString *key, id object, id metadata, BOOL *stop))block;
-
-/**
- * Fast enumeration over rows in the database for which you're interested in.
- * The filter block allows you to decide which rows you're interested in.
- *
- * From the filter block, simply return YES if you'd like the block handler to be invoked for the given key.
- * If the filter block returns NO, then the block handler is skipped for the given key,
- * which avoids the cost associated with deserializing the object & metadata.
-**/
-- (void)enumerateRowsInCollection:(NSString *)collection
-                       usingBlock:(void (^)(NSString *key, id object, id metadata, BOOL *stop))block
-                       withFilter:(BOOL (^)(NSString *key))filter;
-
-/**
- * Enumerates all rows in all collections.
- * 
- * The enumeration is sorted by collection. That is, it will enumerate fully over a single collection
- * before moving onto another collection.
- * 
- * If you only need to enumerate over certain rows (e.g. subset of collections, or keys with a particular prefix),
- * consider using the alternative version below which provides a filter,
- * allowing you to skip the serialization step for those objects you're not interested in.
-**/
-- (void)enumerateRowsInAllCollectionsUsingBlock:
-                            (void (^)(NSString *collection, NSString *key, id object, id metadata, BOOL *stop))block;
-
-/**
- * Enumerates all rows in all collections.
- * The filter block allows you to decide which objects you're interested in.
- *
- * The enumeration is sorted by collection. That is, it will enumerate fully over a single collection
- * before moving onto another collection.
- * 
- * From the filter block, simply return YES if you'd like the block handler to be invoked for the given
- * collection/key pair. If the filter block returns NO, then the block handler is skipped for the given pair,
- * which avoids the cost associated with deserializing the object.
-**/
-- (void)enumerateRowsInAllCollectionsUsingBlock:
-                            (void (^)(NSString *collection, NSString *key, id object, id metadata, BOOL *stop))block
-                 withFilter:(BOOL (^)(NSString *collection, NSString *key))filter;
-
-/**
- * Enumerates over the given list of keys (unordered).
- *
- * This method is faster than fetching individual items as it optimizes cache access.
- * That is, it will first enumerate over items in the cache and then fetch items from the database,
- * thus optimizing the cache and reducing query size.
- *
- * If any keys are missing from the database, the 'metadata' parameter will be nil.
- *
- * IMPORTANT:
- * Due to cache optimizations, the items may not be enumerated in the same order as the 'keys' parameter.
-**/
-- (void)enumerateMetadataForKeys:(NSArray *)keys
-                    inCollection:(NSString *)collection
-             unorderedUsingBlock:(void (^)(NSUInteger keyIndex, id metadata, BOOL *stop))block;
-
-/**
- * Enumerates over the given list of keys (unordered).
- *
- * This method is faster than fetching individual items as it optimizes cache access.
- * That is, it will first enumerate over items in the cache and then fetch items from the database,
- * thus optimizing the cache and reducing query size.
- *
- * If any keys are missing from the database, the 'object' parameter will be nil.
- *
- * IMPORTANT:
- * Due to cache optimizations, the items may not be enumerated in the same order as the 'keys' parameter.
-**/
-- (void)enumerateObjectsForKeys:(NSArray *)keys
-                   inCollection:(NSString *)collection
-            unorderedUsingBlock:(void (^)(NSUInteger keyIndex, id object, BOOL *stop))block;
-
-/**
- * Enumerates over the given list of keys (unordered).
- *
- * This method is faster than fetching individual items as it optimizes cache access.
- * That is, it will first enumerate over items in the cache and then fetch items from the database,
- * thus optimizing the cache and reducing query size.
- *
- * If any keys are missing from the database, the 'object' and 'metadata' parameter will be nil.
- *
- * IMPORTANT:
- * Due to cache optimizations, the items may not be enumerated in the same order as the 'keys' parameter.
-**/
-- (void)enumerateRowsForKeys:(NSArray *)keys
-                inCollection:(NSString *)collection
-         unorderedUsingBlock:(void (^)(NSUInteger keyIndex, id object, id metadata, BOOL *stop))block;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark Extensions
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
- * Returns an extension transaction corresponding to the extension type registered under the given name.
- * If the extension has not yet been opened, it is done so automatically.
- *
- * @return
- *     A subclass of YapDatabaseExtensionTransaction,
- *     according to the type of extension registered under the given name.
- * 
- * One must register an extension with the database before it can be accessed from within connections or transactions.
- * After registration everything works automatically using just the registered extension name.
- *
- * @see [YapDatabase registerExtension:withName:]
-**/
-- (id)extension:(NSString *)extensionName;
-- (id)ext:(NSString *)extensionName; // <-- Shorthand (same as extension: method)
-
-@end
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark -
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-@interface YapDatabaseReadWriteTransaction : YapDatabaseReadTransaction
-
-/**
- * Under normal circumstances, when a read-write transaction block completes,
- * the changes are automatically committed. If, however, something goes wrong and
- * you'd like to abort and discard all changes made within the transaction,
- * then invoke this method.
- * 
- * You should generally return (exit the transaction block) after invoking this method.
- * Any changes made within the the transaction before and after invoking this method will be discarded.
-**/
-- (void)rollback;
-
-/**
- * The YapDatabaseModifiedNotification is posted following a readwrite transaction which made changes.
- * 
- * These notifications are used in a variety of ways:
- * - They may be used as a general notification mechanism to detect changes to the database.
- * - They may be used by extensions to post change information.
- *   For example, YapDatabaseView will post the index changes, which can easily be used to animate a tableView.
- * - They are integrated into the architecture of long-lived transactions in order to maintain a steady state.
- *
- * Thus it is recommended you integrate your own notification information into this existing notification,
- * as opposed to broadcasting your own separate notification.
-**/
-- (void)setCustomObjectForYapDatabaseModifiedNotification:(id)object;
-
-#pragma mark Primitive
-
-/**
- * Primitive access.
- * This method is available in case you need to store irregular data that
- * shouldn't go through the configured serializer/deserializer.
- *
- * Primitive data is stored into the database, but doesn't get routed through any of the extensions.
- *
- * Remember that if you place primitive data into the database via this method,
- * you are responsible for accessing it via the appropriate primitive accessor (such as
- * primitiveDataForKey:inCollection:). If you attempt to access it via the object accessor
- * (objectForKey:inCollection), then the system will attempt to deserialize the primitive data via the
- * configured deserializer, which may or may not work depending on the primitive data you're storing.
- * 
- * This method is the primitive version of setObject:forKey:inCollection:.
- * For more information see the documentation for setObject:forKey:inCollection:.
- *
- * @see setObject:forKey:inCollection:
- * @see primitiveDataForKey:inCollection:
-**/
-- (void)setPrimitiveData:(NSData *)primitiveData forKey:(NSString *)key inCollection:(NSString *)collection;
-
-/**
- * Primitive access.
- * This method is available in case you need to store irregular data that
- * shouldn't go through the configured serializer/deserializer.
- *
- * Primitive data is stored into the database, but doesn't get routed through any of the extensions.
- *
- * Remember that if you place primitive data into the database via this method,
- * you are responsible for accessing it via the appropriate primitive accessor (such as
- * primitiveDataForKey:inCollection:). If you attempt to access it via the object accessor
- * (objectForKey:inCollection), then the system will attempt to deserialize the primitive data via the
- * configured deserializer, which may or may not work depending on the primitive data you're storing.
- * 
- * This method is the primitive version of setObject:forKey:inCollection:withMetadata:.
- * For more information see the documentation for setObject:forKey:inCollection:withMetadata:.
- *
- * @see setObject:forKey:inCollection:withMetadata:
- * @see primitiveDataForKey:inCollection:
- * @see primitiveMetadataForKey:inCollection:
-**/
-- (void)setPrimitiveData:(NSData *)primitiveData
-                  forKey:(NSString *)key
-            inCollection:(NSString *)collection
-   withPrimitiveMetadata:(NSData *)primitiveMetadata;
-
-/**
- * Primitive access.
- * This method is available in case you need to store irregular data that
- * shouldn't go through the configured serializer/deserializer.
- *
- * Primitive data is stored into the database, but doesn't get routed through any of the extensions.
- *
- * Remember that if you place primitive data into the database via this method,
- * you are responsible for accessing it via the appropriate primitive accessor (such as
- * primitiveDataForKey:inCollection:). If you attempt to access it via the object accessor
- * (objectForKey:inCollection), then the system will attempt to deserialize the primitive data via the
- * configured deserializer, which may or may not work depending on the primitive data you're storing.
- *
- * This method is the primitive version of replaceObject:forKey:inCollection:.
- * For more information see the documentation for replaceObject:forKey:inCollection:.
- *
- * @see replaceObject:forKey:inCollection:
- * @see primitiveDataForKey:inCollection:
-**/
-- (void)replacePrimitiveData:(NSData *)primitiveData forKey:(NSString *)key inCollection:(NSString *)collection;
-
-/**
- * Primitive access.
- * This method is available in case you need to store irregular data that
- * shouldn't go through the configured serializer/deserializer.
- * 
- * Primitive data is stored into the database, but doesn't get routed through any of the extensions.
- * 
- * Remember that if you place primitive data into the database via this method,
- * you are responsible for accessing it via the appropriate primitive accessor (such as
- * primitiveMetadataForKey:inCollection:). If you attempt to access it via the object accessor
- * (metadataForKey:inCollection), then the system will attempt to deserialize the primitive data via the
- * configured deserializer, which may or may not work depending on the primitive data you're storing.
- *
- * This method is the primitive version of replaceMetadata:forKey:inCollection:.
- * For more information see the documentation for replaceMetadata:forKey:inCollection:.
- *
- * @see replaceMetadata:forKey:inCollection:
- * @see primitiveMetadataForKey:inCollection:
-**/
-- (void)replacePrimitiveMetadata:(NSData *)primitiveMetadata forKey:(NSString *)key inCollection:(NSString *)collection;
-
-/**
- * DEPRECATED: Use replacePrimitiveMetadata:forKey:inCollection: instead.
-**/
-- (void)setPrimitiveMetadata:(NSData *)primitiveMetadata forKey:(NSString *)key inCollection:(NSString *)collection
-__attribute((deprecated("Use method replacePrimitiveMetadata:forKey:inCollection: instead")));
-
-#pragma mark Object & Metadata
-
-/**
- * Sets the object for the given key/collection.
- * The object is automatically serialized using the database's configured objectSerializer.
- * 
- * If you pass nil for the object, then this method will remove the row from the database (if it exists).
- *
- * This method implicitly sets the associated metadata to nil.
-**/
-- (void)setObject:(id)object forKey:(NSString *)key inCollection:(NSString *)collection;
-
-/**
- * Sets the object & metadata for the given key/collection.
- * 
- * The object is automatically serialized using the database's configured objectSerializer.
- * The metadata is automatically serialized using the database's configured metadataSerializer.
- * 
- * The metadata is optional. You can pass nil for the metadata is unneeded.
- * If non-nil then the metadata is also written to the database (metadata is also persistent).
- *
- * If you pass nil for the object, then this method will remove the row from the database (if it exists).
-**/
-- (void)setObject:(id)object forKey:(NSString *)key inCollection:(NSString *)collection withMetadata:(id)metadata;
-
-/**
- * If a row with the given key/collection exists, then replaces the object for that row with the new value.
- * It only replaces the object. The metadata for the row doesn't change.
- * 
- * If there is no row in the database for the given key/collection then this method does nothing.
- * 
- * If you pass nil for the object, then this method will remove
-**/
-- (void)replaceObject:(id)object forKey:(NSString *)key inCollection:(NSString *)collection;
-
-/**
- * If a row with the given key/collection exists, then replaces the metadata for that row with the new value.
- * It only replaces the metadata. The object for the row doesn't change.
- *
- * If there is no row in the database for the given key/collection then this method does nothing.
- * 
- * If you pass nil for the metadata, any metadata previously associated with the key/collection is removed.
-**/
-- (void)replaceMetadata:(id)metadata forKey:(NSString *)key inCollection:(NSString *)collection;
-
-/**
- * DEPRECATED: Use replaceMetadata:forKey:inCollection: instead.
-**/
-- (void)setMetadata:(id)metadata forKey:(NSString *)key inCollection:(NSString *)collection
-__attribute((deprecated("Use method replaceMetadata:forKey:inCollection: instead")));
-
-#pragma mark Touch
-
-/**
- * You can touch an object if you want to mark it as updated without actually writing any changes to disk.
- *
- * For example:
- *
- *   You have a BNBook object in your database.
- *   One of the properties of the book object is a URL pointing to an image for the front cover of the book.
- *   This image gets changed on the server. Thus the UI representation of the book needs to be updated
- *   to reflect the updated image on the server. You realize that all your views are already listening for
- *   YapDatabaseModified notifications, so if you update the object in the database then all your views are
- *   already wired to update the UI appropriately. However, the actual object itself didn't change. So while
- *   there technically isn't any reason to update the object on disk, doing so would be the easiest way to
- *   keep the UI up-to-date. So what you really want is a way to "mark" the object as updated, without actually
- *   incurring the overhead of rewriting it to disk.
- *
- * And this is exactly what the touch methods were designed for.
- * It won't actually cause the object to get rewritten to disk.
- * However, it will mark the object as "updated" within the YapDatabaseModified notification,
- * so any UI components listening for changes will see this object as updated, and can update as appropriate.
- *
- * The touchObjectForKey:inCollection: method is similar to calling setObject:forKey:inCollection:withMetadata:,
- * and passing the object & metadata that already exists for the key. But without the overhead of fetching the items,
- * or re-writing the items to disk.
- *
- * The touchMetadataForKey: method is similar to calling replaceMetadata:forKey:,
- * and passing the metadata that already exists for the key. But without the overhead of fetching the metadata,
- * or re-writing the metadata to disk.
- * 
- * Note: It is safe to touch objects during enumeration.
- * Normally, altering the database while enumerating it will result in an exception (just like altering an array
- * while enumerating it). However, it's safe to touch objects during enumeration.
-**/
-- (void)touchObjectForKey:(NSString *)key inCollection:(NSString *)collection;
-- (void)touchMetadataForKey:(NSString *)key inCollection:(NSString *)collection;
-
-#pragma mark Remove
-
-/**
- * Deletes the database row with the given key/collection.
- * This method is automatically called if you invoke
- * setObject:forKey:collection: or setPrimitiveData:forKey:collection: and pass nil object/data.
-**/
-- (void)removeObjectForKey:(NSString *)key inCollection:(NSString *)collection;
-
-/**
- * Deletes the database rows with the given keys in the given collection.
-**/
-- (void)removeObjectsForKeys:(NSArray *)keys inCollection:(NSString *)collection;
-
-/**
- * Deletes every key/object pair from the given collection.
- * No trace of the collection will remain afterwards.
-**/
-- (void)removeAllObjectsInCollection:(NSString *)collection;
-
-/**
- * Removes every key/object pair in the entire database (from all collections).
-**/
-- (void)removeAllObjectsInAllCollections;
-
-@end