motion-yapper 0.0.1

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

@@ -0,0 +1,13 @@
+#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

@@ -0,0 +1,26 @@
+#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

@@ -0,0 +1,121 @@
+/**
+ * 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

@@ -0,0 +1,74 @@
+#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

@@ -0,0 +1,603 @@
+#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