motion-yapper 0.0.3 → 0.1.0

data/vendor/Pods/YapDatabase/YapDatabase/Internal/YapDatabaseStatement.h

@@ -1,13 +0,0 @@
-#import <Foundation/Foundation.h>
-#import "sqlite3.h"
-
-/**
- * Simple wrapper class to facilitate storing sqlite3_stmt items as objects (primarily in YapCache).
-**/
-@interface YapDatabaseStatement : NSObject
-
-- (id)initWithStatement:(sqlite3_stmt *)stmt;
-
-@property (nonatomic, assign, readonly) sqlite3_stmt *stmt;
-
-@end

data/vendor/Pods/YapDatabase/YapDatabase/Internal/YapDatabaseStatement.m

@@ -1,26 +0,0 @@
-#import "YapDatabaseStatement.h"
-#import "YapDatabasePrivate.h"
-
-
-@implementation YapDatabaseStatement
-{
-	sqlite3_stmt *stmt;
-}
-
-@synthesize stmt = stmt;
-
-- (id)initWithStatement:(sqlite3_stmt *)inStmt
-{
-	if ((self = [super init]))
-	{
-		stmt = inStmt;
-	}
-	return self;
-}
-
-- (void)dealloc
-{
-	sqlite_finalize_null(&stmt);
-}
-
-@end

data/vendor/Pods/YapDatabase/YapDatabase/Internal/YapDatabaseString.h

@@ -1,121 +0,0 @@
-/**
- * There are a LOT of conversions from NSString to char array.
- * This happens in almost every method, where we bind text to prepared sqlite3 statements.
- * 
- * It is inefficient to use [key UTF8String] for these situations.
- * The Apple documentation is very explicit concerning the UTF8String method:
- * 
- * > The returned C string is automatically freed just as a returned object would be released;
- * > you should copy the C string if [you need] to store it outside of the
- * > autorelease context in which the C string is created.
- * 
- * In other words, the UTF8String method does a malloc for character buffer, copies the characters,
- * and autoreleases the buffer (just like an autoreleased NSData instance).
- * 
- * Thus we suffer a bunch of malloc's if we use UTF8String.
- * 
- * Considering that almost all keys are likely to be relatively small,
- * a much faster technique is to use the stack instead of the heap (with obvious precautions, see below).
- * 
- * Note: This technique ONLY applies to key names and collection names.
- * It does NOT apply to object/primitiveData or metadata. Those are binded to sqlite3 statements using binary blobs.
-**/
-
-
-/**
- * We must be cautious and conservative so as to avoid stack overflow.
- * This is possibe if really huge key names or collection names are used.
- *
- * The number below represents the largest amount of memory (in bytes) that will be allocated on the stack per string.
-**/
-#define YapDatabaseStringMaxStackLength (1024 * 4)
-
-/**
- * Struct designed to be allocated on the stack.
- * You then use the inline functions below to "setup" and "teardown" the struct.
- * For example:
- * 
- * > YapDatabaseString myKeyChar;
- * > MakeYapDatabaseString(&myKeyChar, myNSStringKey);
- * > ...
- * > sqlite3_bind_text(statement, position, myKeyChar.str, myKeyChar.length, SQLITE_STATIC);
- * > ...
- * > sqlite3_clear_bindings(statement);
- * > sqlite3_reset(statement);
- * > FreeYapDatabaseString(&myKeyChar);
- *
- * There are 2 "public" fields:
- * str    - Pointer to the char[] string.
- * length - Represents the length (in bytes) of the char[] str (excluding the NULL termination byte, as usual).
- * 
- * The other 2 "private" fields are for internal use:
- * strStack - If the string doesn't exceed YapDatabaseStringMaxStackLength,
- *            then the bytes are copied here (onto stack storage), and str actually points to strStack.
- * strHeap  - If the string exceeds YapDatabaseStringMaxStackLength,
- *            the space is allocated on the heap, strHeap holds the pointer, and str has the same pointer.
- * 
- * Thus the "setup" and "teardown" methods below will automatically switch to heap storage (just like UTF8String),
- * if the key/collection name is too long, and performance will be equivalent.
- * But in the common case of short key/collection names, we can skip the more expensive heap allocation/deallocation.
-**/
-struct YapDatabaseString {
-	int length;
-	char strStack[YapDatabaseStringMaxStackLength];
-	char *strHeap;
-	char *str; // Pointer to either strStack or strHeap
-};
-typedef struct YapDatabaseString YapDatabaseString;
-
-/**
- * Initializes the YapDatabaseString structure.
- * It will automatically use heap storage if the given NSString is too long.
- * 
- * This method should always be balanced with a call to FreeYapDatabaseString.
-**/
-NS_INLINE void MakeYapDatabaseString(YapDatabaseString *dbStr, NSString *nsStr)
-{
-	if (nsStr)
-	{
-		// We convert to int because the sqlite3_bind_text() function expects an int parameter.
-		// So we can change it to int here, or we can cast everywhere throughout the project.
-		
-		dbStr->length = (int)[nsStr lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
-	
-		if ((dbStr->length + 1) <= YapDatabaseStringMaxStackLength)
-		{
-			dbStr->strHeap = NULL;
-			dbStr->str = dbStr->strStack;
-		}
-		else
-		{
-			dbStr->strHeap = (char *)malloc((dbStr->length + 1));
-			dbStr->str = dbStr->strHeap;
-		}
-	
-		[nsStr getCString:dbStr->str maxLength:(dbStr->length + 1) encoding:NSUTF8StringEncoding];
-	}
-	else
-	{
-		dbStr->length = 0;
-		dbStr->strHeap = NULL;
-		dbStr->str = NULL;
-	}
-}
-
-/**
- * If heap storage was needed (because the string length exceeded YapDatabaseStringMaxStackLength),
- * this method frees the heap allocated memory.
- *
- * In the common case of stack storage, strHeap will be NULL, and this method is essentially a no-op.
- * 
- * This method should be invoked AFTER sqlite3_clear_bindings (assuming SQLITE_STATIC is used).
-**/
-NS_INLINE void FreeYapDatabaseString(YapDatabaseString *dbStr)
-{
-	if (dbStr->strHeap)
-	{
-		free(dbStr->strHeap);
-		dbStr->strHeap = NULL;
-		dbStr->str = NULL;
-	}
-}

data/vendor/Pods/YapDatabase/YapDatabase/Internal/YapMemoryTable.h

@@ -1,74 +0,0 @@
-#import <Foundation/Foundation.h>
-
-@class YapMemoryTableTransaction;
-
-
-/**
- * A "memory table" is a dictionary that supports versioning.
- * There may be multiple values for a single key, with each value associated with a different snapshot.
- * 
- * The memory table is accessed via a YapMemoryTableTransaction instance,
- * which is itself associated with a particular timestamp. Thus the transaction is able to properly identify
- * which version is appropriate for itself.
-**/
-@interface YapMemoryTable : NSObject
-
-/**
- * Initializes a memory table.
- *
- * The keyClass is used for debugging, to ensure the proper key type is always used when accessing the table.
- * The keyClass is used within NSAssert statements that typically get compiled out for release builds.
-**/
-- (id)initWithKeyClass:(Class)keyClass;
-
-/**
- * Creates and returns a new connection associated with the shared cache.
-**/
-- (YapMemoryTableTransaction *)newReadTransactionWithSnapshot:(uint64_t)snapshot;
-- (YapMemoryTableTransaction *)newReadWriteTransactionWithSnapshot:(uint64_t)snapshot;
-
-/**
- * Invoked automatically by YapDatabase architecture.
-**/
-- (void)asyncCheckpoint:(int64_t)minSnapshot;
-
-@end
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark -
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-@interface YapMemoryTableTransaction : NSObject
-
-@property (nonatomic, readonly) uint64_t snapshot;
-@property (nonatomic, readonly) BOOL isReadWriteTransaction;
-
-- (id)objectForKey:(id)key;
-
-- (void)enumerateKeysWithBlock:(void (^)(id key, BOOL *stop))block;
-
-- (void)enumerateKeysAndObjectsWithBlock:(void (^)(id key, id obj, BOOL *stop))block;
-
-//
-// For ReadWrite transactions:
-
-- (void)setObject:(id)object forKey:(id)key;
-
-- (void)removeObjectForKey:(id)key;
-- (void)removeObjectsForKeys:(NSArray *)keys;
-
-- (void)removeAllObjects;
-
-//
-// Batch access / modifications
-
-- (void)accessWithBlock:(dispatch_block_t)block;
-- (void)modifyWithBlock:(dispatch_block_t)block;
-
-//
-// Transaction state
-
-- (void)commit;
-- (void)rollback;
-
-@end

data/vendor/Pods/YapDatabase/YapDatabase/Internal/YapMemoryTable.m

@@ -1,603 +0,0 @@
-#import "YapMemoryTable.h"
-
-
-/**
- * There may be multiple simulatneous database transactions, each using different atomic snapshots.
- * In other words, the value in the database at snapshot A may be different than at snapshot B.
- * Each value is correct, and depends entirely on the snapshot being used by the transaction.
- *
- * This presents a unique property of the table:
- * - the table may store multiple values for a single key.
- * - the stored values are associated with a snapshot
- *
- * This class represents a single stored value and its associated snapshot.
- * It is one value contained within a linked-list of possibly multiple values for the same key.
- * The linked-list remains sorted, with the most recent value at the front of the linked-list.
- **/
-@interface YapMemoryTableValue : NSObject {
-@public
-	YapMemoryTableValue *olderValue;
-	
-	uint64_t snapshot;
-	id object;
-}
-
-@end
-
-@implementation YapMemoryTableValue
-
-- (NSString *)description
-{
-	return [NSString stringWithFormat:@"<YapMemoryTableValue[%p]: snapshot(%llu), olderValue(%p), object(%@)>",
-	        self, snapshot, olderValue, object];
-}
-
-@end
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark -
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-@interface YapMemoryTable () {
-@public
-	
-	Class keyClass;
-	
-	NSMutableDictionary *dict;
-	
-	dispatch_queue_t queue;
-	void *IsOnQueueKey;
-	
-	NSMutableArray *snapshots;
-	NSMutableArray *changes;
-	NSLock *lock;
-}
-@end
-
-@interface YapMemoryTableTransaction () {
-@public
-	
-	__unsafe_unretained YapMemoryTable *table;
-	
-	uint64_t snapshot;
-	BOOL isReadWriteTransaction;
-	
-	NSMutableSet *changedKeys;
-}
-@end
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark -
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-@implementation YapMemoryTable
-
-- (id)initWithKeyClass:(Class)inKeyClass
-{
-	if ((self = [super init]))
-	{
-		keyClass = inKeyClass;
-		
-		dict = [[NSMutableDictionary alloc] init];
-		queue = dispatch_queue_create("YapMemoryTable", DISPATCH_QUEUE_CONCURRENT);
-		
-		IsOnQueueKey = &IsOnQueueKey;
-		dispatch_queue_set_specific(queue, IsOnQueueKey, IsOnQueueKey, NULL);
-		
-		snapshots = [[NSMutableArray alloc] init];
-		changes   = [[NSMutableArray alloc] init];
-		lock = [[NSLock alloc] init];
-	}
-	return self;
-}
-- (YapMemoryTableTransaction *)newReadTransactionWithSnapshot:(uint64_t)snapshot
-{
-	YapMemoryTableTransaction *transaction = [[YapMemoryTableTransaction alloc] init];
-	transaction->table = self;
-	transaction->snapshot = snapshot;
-	transaction->isReadWriteTransaction = NO;
-	
-	return transaction;
-}
-
-- (YapMemoryTableTransaction *)newReadWriteTransactionWithSnapshot:(uint64_t)snapshot
-{
-	YapMemoryTableTransaction *transaction = [[YapMemoryTableTransaction alloc] init];
-	transaction->table = self;
-	transaction->snapshot = snapshot;
-	transaction->isReadWriteTransaction = YES;
-	
-	return transaction;
-}
-
-- (void)asyncCheckpoint:(int64_t)minSnapshot
-{
-	dispatch_barrier_async(queue, ^{ @autoreleasepool {
-		
-		while (YES) // using manual return
-		{
-			int64_t snapshot = 0;
-			NSSet *changedKeys = nil;
-			
-			[lock lock];
-			
-			if ([snapshots count] > 0)
-			{
-				snapshot = [[snapshots objectAtIndex:0] unsignedLongLongValue];
-				
-				if (snapshot < minSnapshot)
-				{
-					changedKeys = [changes objectAtIndex:0];
-			
-					[snapshots removeObjectAtIndex:0];
-					[changes removeObjectAtIndex:0];
-				}
-			}
-			
-			[lock unlock];
-			
-			if (changedKeys == nil)
-			{
-				return; // Done
-			}
-			
-			for (id key in changedKeys)
-			{
-				BOOL hasObject = NO;
-				
-				__unsafe_unretained YapMemoryTableValue *prvValue = nil;
-				__unsafe_unretained YapMemoryTableValue *value = [dict objectForKey:key];
-				
-				while (value && value->snapshot >= minSnapshot)
-				{
-					if (hasObject == NO)
-						hasObject = (value->object != nil);
-					
-					prvValue = value;
-					value = value->olderValue;
-				}
-				
-				if (value)
-				{
-					if (prvValue)
-					{
-						// The 'value' is not the latest value
-						
-						if (!hasObject)
-						{
-							// All values >= minSnapshot represent a deletion.
-							// So we can just dump all values.
-							
-							[dict removeObjectForKey:key];
-						}
-						else
-						{
-							// There are values >= minSnapshot in the table.
-							// So the stay in the dict.
-							// But everything older than minSnapshot can go.
-							
-							prvValue->olderValue = nil;
-						}
-					}
-					else
-					{
-						// The 'value' is the latest value
-						
-						if (value->object == nil)
-						{
-							// The 'value' is the latest value.
-							// And 'value' represents a deletion.
-							// So we can just dump all values.
-							
-							[dict removeObjectForKey:key];
-						}
-						else
-						{
-							// The 'value' is the latest value.
-							// So it stays in the dict.
-							// But everything after it can go (if there is anything).
-							
-							value->olderValue = nil;
-						}
-					}
-					
-				} // end: if (value)
-				
-			} // end: for (id key in changedKeys)
-			
-		} // end: while (YES)
-	}});
-}
-
-- (void)asyncRollback:(int64_t)snapshot withChanges:(NSSet *)changedKeys
-{
-	dispatch_barrier_async(queue, ^{ @autoreleasepool {
-		
-		for (id key in changedKeys)
-		{
-			__unsafe_unretained YapMemoryTableValue *value = [dict objectForKey:key];
-			
-			if (value && value->snapshot == snapshot)
-			{
-				if (value->olderValue == nil)
-				{
-					[dict removeObjectForKey:key];
-				}
-				else
-				{
-					[dict setObject:value->olderValue forKey:key];
-				}
-			}
-		}
-	}});
-}
-
-@end
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark -
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-@implementation YapMemoryTableTransaction
-
-@synthesize snapshot = snapshot;
-@synthesize isReadWriteTransaction = isReadWriteTransaction;
-
-- (id)objectForKey:(id)key
-{
-	NSAssert([key isKindOfClass:table->keyClass],
-	         @"Unexpected key class. Expected %@, passed %@", table->keyClass, [key class]);
-	
-	__block id result = nil;
-	
-	dispatch_block_t block = ^{
-		
-		__unsafe_unretained YapMemoryTableValue *value = [table->dict objectForKey:key];
-		
-		while (value)
-		{
-			if (value->snapshot <= snapshot)
-			{
-				result = value->object;
-				break;
-			}
-			else
-			{
-				value = value->olderValue;
-			}
-		}
-	};
-	
-	if (dispatch_get_specific(table->IsOnQueueKey))
-		block();
-	else
-		dispatch_sync(table->queue, block);
-	
-	return result;
-}
-
-- (void)enumerateKeysWithBlock:(void (^)(id key, BOOL *stop))userBlock
-{
-	dispatch_block_t block = ^{ @autoreleasepool {
-		
-		[table->dict enumerateKeysAndObjectsUsingBlock:^(id key, id obj, BOOL *stop) {
-			
-			__unsafe_unretained YapMemoryTableValue *value = [table->dict objectForKey:key];
-			while (value)
-			{
-				if (value->snapshot <= snapshot)
-				{
-					if (value->object)
-					{
-						userBlock(key, stop);
-					}
-					break;
-				}
-				else
-				{
-					value = value->olderValue;
-				}
-			}
-		}];
-	}};
-	
-	if (dispatch_get_specific(table->IsOnQueueKey))
-		block();
-	else
-		dispatch_sync(table->queue, block);
-}
-
-- (void)enumerateKeysAndObjectsWithBlock:(void (^)(id key, id obj, BOOL *stop))userBlock
-{
-	dispatch_block_t block = ^{ @autoreleasepool {
-		
-		[table->dict enumerateKeysAndObjectsUsingBlock:^(id key, id obj, BOOL *stop) {
-			
-			__unsafe_unretained YapMemoryTableValue *value = [table->dict objectForKey:key];
-			while (value)
-			{
-				if (value->snapshot <= snapshot)
-				{
-					if (value->object)
-					{
-						userBlock(key, value->object, stop);
-					}
-					break;
-				}
-				else
-				{
-					value = value->olderValue;
-				}
-			}
-		}];
-	}};
-	
-	if (dispatch_get_specific(table->IsOnQueueKey))
-		block();
-	else
-		dispatch_sync(table->queue, block);
-}
-
-- (void)setObject:(id)object forKey:(id)key
-{
-	NSAssert([key isKindOfClass:table->keyClass],
-	         @"Unexpected key class. Expected %@, passed %@", table->keyClass, [key class]);
-	
-	if (!isReadWriteTransaction) {
-		NSAssert(NO, @"Cannot modify table in read-only transaction.");
-		return;
-	}
-	
-	if (changedKeys == nil)
-		changedKeys = [[NSMutableSet alloc] init];
-	
-	dispatch_block_t block = ^{
-		
-		__unsafe_unretained YapMemoryTableValue *value = [table->dict objectForKey:key];
-		
-		if (value && value->snapshot == snapshot)
-		{
-			// We've already updated this key during this transaction.
-			
-			value->object = object;
-		}
-		else
-		{
-			// First update for this key during this transaction.
-			
-			YapMemoryTableValue *newValue = [[YapMemoryTableValue alloc] init];
-			newValue->olderValue = value;
-			newValue->object = object;
-			newValue->snapshot = snapshot;
-			
-			[table->dict setObject:newValue forKey:key];
-			
-			[changedKeys addObject:key];
-		}
-	};
-	
-	if (dispatch_get_specific(table->IsOnQueueKey))
-		block();
-	else
-		dispatch_barrier_sync(table->queue, block);
-}
-
-- (void)removeObjectForKey:(id)key
-{
-	NSAssert([key isKindOfClass:table->keyClass],
-	         @"Unexpected key class. Expected %@, passed %@", table->keyClass, [key class]);
-	
-	if (!isReadWriteTransaction) {
-		NSAssert(NO, @"Cannot modify table in read-only transaction.");
-		return;
-	}
-	
-	if (changedKeys == nil)
-		changedKeys = [[NSMutableSet alloc] init];
-	
-	dispatch_block_t block = ^{
-		
-		__unsafe_unretained YapMemoryTableValue *value = [table->dict objectForKey:key];
-		
-		if (value)
-		{
-			if (value->snapshot == snapshot)
-			{
-				// We've already updated this key during this transaction.
-				
-				if (value->olderValue == nil)
-				{
-					// Removing a previously set value within this transaction.
-					// And there are no other values outside this transaction.
-					
-					[table->dict removeObjectForKey:key];
-					
-					[changedKeys removeObject:key];
-				}
-				else
-				{
-					// Updating a previously set value within this transaction.
-					// But there are other values for older snapshots.
-					
-					value->object = nil;
-				}
-			}
-			else
-			{
-				// First update for this key during this transaction.
-				
-				YapMemoryTableValue *newValue = [[YapMemoryTableValue alloc] init];
-				newValue->olderValue = value;
-				newValue->object = nil;
-				newValue->snapshot = snapshot;
-				
-				[table->dict setObject:newValue forKey:key];
-				
-				[changedKeys addObject:key];
-			}
-		}
-	};
-	
-	if (dispatch_get_specific(table->IsOnQueueKey))
-		block();
-	else
-		dispatch_barrier_sync(table->queue, block);
-}
-
-- (void)removeObjectsForKeys:(NSArray *)keys
-{
-	if (!isReadWriteTransaction) {
-		NSAssert(NO, @"Cannot modify table in read-only transaction.");
-		return;
-	}
-	
-	if (changedKeys == nil)
-		changedKeys = [[NSMutableSet alloc] init];
-	
-	dispatch_block_t block = ^{ @autoreleasepool {
-		
-		for (id key in keys)
-		{
-			NSAssert([key isKindOfClass:table->keyClass],
-			         @"Unexpected key class. Expected %@, passed %@", table->keyClass, [key class]);
-			
-			__unsafe_unretained YapMemoryTableValue *value = [table->dict objectForKey:key];
-			
-			if (value)
-			{
-				if (value->snapshot == snapshot)
-				{
-					// We've already updated this key during this transaction.
-					
-					if (value->olderValue == nil)
-					{
-						// Removing a previously set value within this transaction.
-						// And there are no other values outside this transaction.
-						
-						[table->dict removeObjectForKey:key];
-						
-						[changedKeys removeObject:key];
-					}
-					else
-					{
-						// Updating a previously set value within this transaction.
-						// But there are other values for older snapshots.
-						
-						value->object = nil;
-					}
-				}
-				else
-				{
-					// First update for this key during this transaction.
-					
-					YapMemoryTableValue *newValue = [[YapMemoryTableValue alloc] init];
-					newValue->olderValue = value;
-					newValue->object = nil;
-					newValue->snapshot = snapshot;
-					
-					[table->dict setObject:newValue forKey:key];
-					
-					[changedKeys addObject:key];
-				}
-			}
-		}
-	}};
-	
-	if (dispatch_get_specific(table->IsOnQueueKey))
-		block();
-	else
-		dispatch_barrier_sync(table->queue, block);
-}
-
-- (void)removeAllObjects
-{
-	NSAssert(isReadWriteTransaction, @"Cannot modify table in read-only transaction.");
-	
-	if (changedKeys == nil)
-		changedKeys = [[NSMutableSet alloc] init];
-	
-	dispatch_block_t block = ^{ @autoreleasepool {
-		
-		// Grab all keys
-		NSArray *keys = [table->dict allKeys];
-		
-		// Mark all keys as changed
-		[changedKeys addObjectsFromArray:keys];
-		
-		// Now enumerate all the keys, and update accordingly
-		for (id key in keys)
-		{
-			__unsafe_unretained YapMemoryTableValue *value = [table->dict objectForKey:key];
-			
-			if (value->snapshot == snapshot)
-			{
-				// We've already updated this key during this transaction.
-				
-				if (value->olderValue == nil)
-				{
-					// Removing a previously set value within this transaction.
-					// And there are no other values outside this transaction.
-					
-					[table->dict removeObjectForKey:key];
-					[changedKeys removeObject:key];
-				}
-				else
-				{
-					// Updating a previously set value within this transaction.
-					// But there are other values for older snapshots.
-					
-					value->object = nil;
-				}
-			}
-			else
-			{
-				// First update for this key during this transaction.
-				
-				YapMemoryTableValue *newValue = [[YapMemoryTableValue alloc] init];
-				newValue->olderValue = value;
-				newValue->object = nil;
-				newValue->snapshot = snapshot;
-				
-				[table->dict setObject:newValue forKey:key];
-			}
-		}
-	}};
-	
-	if (dispatch_get_specific(table->IsOnQueueKey))
-		block();
-	else
-		dispatch_barrier_sync(table->queue, block);
-}
-
-- (void)accessWithBlock:(dispatch_block_t)block
-{
-	dispatch_sync(table->queue, block);
-}
-
-- (void)modifyWithBlock:(dispatch_block_t)block
-{
-	dispatch_barrier_sync(table->queue, block);
-}
-
-- (void)commit
-{
-	if (isReadWriteTransaction && [changedKeys count] > 0)
-	{
-		[table->lock lock];
-		{
-			[table->snapshots addObject:@(snapshot)];
-			[table->changes addObject:changedKeys];
-		}
-		[table->lock unlock];
-	}
-}
-
-- (void)rollback
-{
-	if (isReadWriteTransaction && [changedKeys count] > 0)
-	{
-		[table asyncRollback:snapshot withChanges:changedKeys];
-	}
-}
-
-@end