motion-yapper 0.0.1

data/vendor/Pods/BuildHeaders/YapDatabase/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/BuildHeaders/YapDatabase/YapNull.h

@@ -0,0 +1,17 @@
+#import <Foundation/Foundation.h>
+
+/**
+ * There are various situations in which we need to add a placeholder to signify a nil value.
+ * For example, we need to cache the fact that the metadata for a given key is nil.
+ *
+ * However, we cannot add a nil object to a dictionary.
+ * And we cannot use NSNull, or we prevent the user from using NSNull for their own purposes.
+ * 
+ * And thus, we replicate NSNull, and use it instead.
+ * And now the user is free to use NSNull if needed.
+**/
+@interface YapNull : NSObject
+
++ (id)null;
+
+@end

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

@@ -0,0 +1,41 @@
+#import <Foundation/Foundation.h>
+
+/**
+ * The YapSet class can be treated more or less like a regular NSSet.
+ *
+ * It is designed to expose internal mutable objects to the external world.
+ * That is, we skip all the overhead associated with making immutable copies,
+ * and instead just use this simple wrapper class.
+ * 
+ * In general, the external world won't interact with this class.
+ * They are encouraged to instead use the changeset methods exposed in the connection classes.
+ * 
+ * @see YapDatabaseConnection hasChangeForKey:inNotifications:
+ * @see YapDatabaseConnection hasChangeForAnyKeys:inNotifications:
+**/
+@interface YapSet : NSObject <NSFastEnumeration>
+
+- (id)initWithSet:(NSMutableSet *)set;
+- (id)initWithDictionary:(NSMutableDictionary *)dictionary;
+
+// NSSet methods
+
+- (BOOL)containsObject:(id)anObject;
+- (BOOL)intersectsSet:(NSSet *)otherSet;
+
+- (void)enumerateObjectsUsingBlock:(void (^)(id obj, BOOL *stop))block;
+
+// It's open source!
+// You are encouraged to add any methods you may need that are available in the NSSet API.
+//
+// Not every method from NSSet is available here because the author is lazy,
+// and only implemented what was needed at the time.
+//
+// If you add something, keep in mind the spirit of this class.
+// It is designed to expose mutable internals in a safe (immutable) manner.
+// It is designed to expose them in the form of a set.
+//
+// If you make improvements, feel free to submit a patch to the github project and get some good karma for it!
+// https://github.com/yaptv/YapDatabase
+
+@end

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

@@ -0,0 +1,15 @@
+#import <Foundation/Foundation.h>
+
+/**
+ * Singleton class to represent the "value" for a key that was touched. (i.e. value didn't change)
+ *
+ * YapDatabase stores changesets in dictionaries, where the object represents the updated value for a key.
+ * When an item is touched, we use this singleton as the value to signify internally that the item didn't change.
+ * This allows us to act as if the item did change in most all respects,
+ * but internally won't cause us to flush the item from the caches.
+**/
+@interface YapTouch : NSObject
+
++ (id)touch;
+
+@end

data/vendor/Pods/CocoaLumberjack/LICENSE.txt

@@ -0,0 +1,18 @@
+Software License Agreement (BSD License)
+
+Copyright (c) 2010, Deusty, LLC
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Neither the name of Deusty nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of Deusty, LLC.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/vendor/Pods/CocoaLumberjack/Lumberjack/DDASLLogger.h

@@ -0,0 +1,41 @@
+#import <Foundation/Foundation.h>
+#import <asl.h>
+
+#import "DDLog.h"
+
+/**
+ * Welcome to Cocoa Lumberjack!
+ * 
+ * The project page has a wealth of documentation if you have any questions.
+ * https://github.com/robbiehanson/CocoaLumberjack
+ * 
+ * If you're new to the project you may wish to read the "Getting Started" wiki.
+ * https://github.com/robbiehanson/CocoaLumberjack/wiki/GettingStarted
+ * 
+ * 
+ * This class provides a logger for the Apple System Log facility.
+ * 
+ * As described in the "Getting Started" page,
+ * the traditional NSLog() function directs it's output to two places:
+ * 
+ * - Apple System Log
+ * - StdErr (if stderr is a TTY) so log statements show up in Xcode console
+ * 
+ * To duplicate NSLog() functionality you can simply add this logger and a tty logger.
+ * However, if you instead choose to use file logging (for faster performance),
+ * you may choose to use a file logger and a tty logger.
+**/
+
+@interface DDASLLogger : DDAbstractLogger <DDLogger>
+{
+	aslclient client;
+}
+
++ (DDASLLogger *)sharedInstance;
+
+// Inherited from DDAbstractLogger
+
+// - (id <DDLogFormatter>)logFormatter;
+// - (void)setLogFormatter:(id <DDLogFormatter>)formatter;
+
+@end

data/vendor/Pods/CocoaLumberjack/Lumberjack/DDASLLogger.m

@@ -0,0 +1,99 @@
+#import "DDASLLogger.h"
+
+#import <libkern/OSAtomic.h>
+
+/**
+ * Welcome to Cocoa Lumberjack!
+ * 
+ * The project page has a wealth of documentation if you have any questions.
+ * https://github.com/robbiehanson/CocoaLumberjack
+ * 
+ * If you're new to the project you may wish to read the "Getting Started" wiki.
+ * https://github.com/robbiehanson/CocoaLumberjack/wiki/GettingStarted
+**/
+
+#if ! __has_feature(objc_arc)
+#warning This file must be compiled with ARC. Use -fobjc-arc flag (or convert project to ARC).
+#endif
+
+
+@implementation DDASLLogger
+
+static DDASLLogger *sharedInstance;
+
+/**
+ * The runtime sends initialize to each class in a program exactly one time just before the class,
+ * or any class that inherits from it, is sent its first message from within the program. (Thus the
+ * method may never be invoked if the class is not used.) The runtime sends the initialize message to
+ * classes in a thread-safe manner. Superclasses receive this message before their subclasses.
+ *
+ * This method may also be called directly (assumably by accident), hence the safety mechanism.
+**/
++ (void)initialize
+{
+	static BOOL initialized = NO;
+	if (!initialized)
+	{
+		initialized = YES;
+		
+		sharedInstance = [[DDASLLogger alloc] init];
+	}
+}
+
++ (DDASLLogger *)sharedInstance
+{
+	return sharedInstance;
+}
+
+- (id)init
+{
+	if (sharedInstance != nil)
+	{
+		return nil;
+	}
+	
+	if ((self = [super init]))
+	{
+		// A default asl client is provided for the main thread,
+		// but background threads need to create their own client.
+		
+		client = asl_open(NULL, "com.apple.console", 0);
+	}
+	return self;
+}
+
+- (void)logMessage:(DDLogMessage *)logMessage
+{
+	NSString *logMsg = logMessage->logMsg;
+	
+	if (formatter)
+	{
+		logMsg = [formatter formatLogMessage:logMessage];
+	}
+	
+	if (logMsg)
+	{
+		const char *msg = [logMsg UTF8String];
+		
+		int aslLogLevel;
+		switch (logMessage->logFlag)
+		{
+			// Note: By default ASL will filter anything above level 5 (Notice).
+			// So our mappings shouldn't go above that level.
+			
+			case LOG_FLAG_ERROR : aslLogLevel = ASL_LEVEL_CRIT;    break;
+			case LOG_FLAG_WARN  : aslLogLevel = ASL_LEVEL_ERR;     break;
+			case LOG_FLAG_INFO  : aslLogLevel = ASL_LEVEL_WARNING; break;
+			default             : aslLogLevel = ASL_LEVEL_NOTICE;  break;
+		}
+		
+		asl_log(client, NULL, aslLogLevel, "%s", msg);
+	}
+}
+
+- (NSString *)loggerName
+{
+	return @"cocoa.lumberjack.aslLogger";
+}
+
+@end

data/vendor/Pods/CocoaLumberjack/Lumberjack/DDAbstractDatabaseLogger.h

@@ -0,0 +1,102 @@
+#import <Foundation/Foundation.h>
+
+#import "DDLog.h"
+
+/**
+ * Welcome to Cocoa Lumberjack!
+ * 
+ * The project page has a wealth of documentation if you have any questions.
+ * https://github.com/robbiehanson/CocoaLumberjack
+ * 
+ * If you're new to the project you may wish to read the "Getting Started" wiki.
+ * https://github.com/robbiehanson/CocoaLumberjack/wiki/GettingStarted
+ * 
+ * 
+ * This class provides an abstract implementation of a database logger.
+ * 
+ * That is, it provides the base implementation for a database logger to build atop of.
+ * All that is needed for a concrete database logger is to extend this class
+ * and override the methods in the implementation file that are prefixed with "db_".
+**/
+
+@interface DDAbstractDatabaseLogger : DDAbstractLogger {
+@protected
+	NSUInteger saveThreshold;
+	NSTimeInterval saveInterval;
+	NSTimeInterval maxAge;
+	NSTimeInterval deleteInterval;
+	BOOL deleteOnEverySave;
+	
+	BOOL saveTimerSuspended;
+	NSUInteger unsavedCount;
+	dispatch_time_t unsavedTime;
+	dispatch_source_t saveTimer;
+	dispatch_time_t lastDeleteTime;
+	dispatch_source_t deleteTimer;
+}
+
+/**
+ * Specifies how often to save the data to disk.
+ * Since saving is an expensive operation (disk io) it is not done after every log statement.
+ * These properties allow you to configure how/when the logger saves to disk.
+ * 
+ * A save is done when either (whichever happens first):
+ * 
+ * - The number of unsaved log entries reaches saveThreshold
+ * - The amount of time since the oldest unsaved log entry was created reaches saveInterval
+ * 
+ * You can optionally disable the saveThreshold by setting it to zero.
+ * If you disable the saveThreshold you are entirely dependent on the saveInterval.
+ * 
+ * You can optionally disable the saveInterval by setting it to zero (or a negative value).
+ * If you disable the saveInterval you are entirely dependent on the saveThreshold.
+ * 
+ * It's not wise to disable both saveThreshold and saveInterval.
+ * 
+ * The default saveThreshold is 500.
+ * The default saveInterval is 60 seconds.
+**/
+@property (assign, readwrite) NSUInteger saveThreshold;
+@property (assign, readwrite) NSTimeInterval saveInterval;
+
+/**
+ * It is likely you don't want the log entries to persist forever.
+ * Doing so would allow the database to grow infinitely large over time.
+ * 
+ * The maxAge property provides a way to specify how old a log statement can get
+ * before it should get deleted from the database.
+ * 
+ * The deleteInterval specifies how often to sweep for old log entries.
+ * Since deleting is an expensive operation (disk io) is is done on a fixed interval.
+ * 
+ * An alternative to the deleteInterval is the deleteOnEverySave option.
+ * This specifies that old log entries should be deleted during every save operation.
+ * 
+ * You can optionally disable the maxAge by setting it to zero (or a negative value).
+ * If you disable the maxAge then old log statements are not deleted.
+ * 
+ * You can optionally disable the deleteInterval by setting it to zero (or a negative value).
+ * 
+ * If you disable both deleteInterval and deleteOnEverySave then old log statements are not deleted.
+ * 
+ * It's not wise to enable both deleteInterval and deleteOnEverySave.
+ * 
+ * The default maxAge is 7 days.
+ * The default deleteInterval is 5 minutes.
+ * The default deleteOnEverySave is NO.
+**/
+@property (assign, readwrite) NSTimeInterval maxAge;
+@property (assign, readwrite) NSTimeInterval deleteInterval;
+@property (assign, readwrite) BOOL deleteOnEverySave;
+
+/**
+ * Forces a save of any pending log entries (flushes log entries to disk).
+**/
+- (void)savePendingLogEntries;
+
+/**
+ * Removes any log entries that are older than maxAge.
+**/
+- (void)deleteOldLogEntries;
+
+@end

data/vendor/Pods/CocoaLumberjack/Lumberjack/DDAbstractDatabaseLogger.m

@@ -0,0 +1,727 @@
+#import "DDAbstractDatabaseLogger.h"
+#import <math.h>
+
+/**
+ * Welcome to Cocoa Lumberjack!
+ * 
+ * The project page has a wealth of documentation if you have any questions.
+ * https://github.com/robbiehanson/CocoaLumberjack
+ * 
+ * If you're new to the project you may wish to read the "Getting Started" wiki.
+ * https://github.com/robbiehanson/CocoaLumberjack/wiki/GettingStarted
+**/
+
+#if ! __has_feature(objc_arc)
+#warning This file must be compiled with ARC. Use -fobjc-arc flag (or convert project to ARC).
+#endif
+
+@interface DDAbstractDatabaseLogger ()
+- (void)destroySaveTimer;
+- (void)destroyDeleteTimer;
+@end
+
+#pragma mark -
+
+@implementation DDAbstractDatabaseLogger
+
+- (id)init
+{
+	if ((self = [super init]))
+	{
+        saveThreshold = 500;
+		saveInterval = 60;           // 60 seconds
+		maxAge = (60 * 60 * 24 * 7); //  7 days
+		deleteInterval = (60 * 5);   //  5 minutes
+	}
+	return self;
+}
+
+- (void)dealloc
+{
+	[self destroySaveTimer];
+	[self destroyDeleteTimer];
+	
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+#pragma mark Override Me
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+- (BOOL)db_log:(DDLogMessage *)logMessage
+{
+	// Override me and add your implementation.
+	// 
+	// Return YES if an item was added to the buffer.
+	// Return NO if the logMessage was ignored.
+	
+	return NO;
+}
+
+- (void)db_save
+{
+	// Override me and add your implementation.
+}
+
+- (void)db_delete
+{
+	// Override me and add your implementation.
+}
+
+- (void)db_saveAndDelete
+{
+	// Override me and add your implementation.
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+#pragma mark Private API
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+- (void)performSaveAndSuspendSaveTimer
+{
+	if (unsavedCount > 0)
+	{
+		if (deleteOnEverySave)
+			[self db_saveAndDelete];
+		else
+			[self db_save];
+	}
+	
+	unsavedCount = 0;
+	unsavedTime = 0;
+	
+	if (saveTimer && !saveTimerSuspended)
+	{
+		dispatch_suspend(saveTimer);
+		saveTimerSuspended = YES;
+	}
+}
+
+- (void)performDelete
+{
+	if (maxAge > 0.0)
+	{
+		[self db_delete];
+		
+		lastDeleteTime = dispatch_time(DISPATCH_TIME_NOW, 0);
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+#pragma mark Timers
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+- (void)destroySaveTimer
+{
+	if (saveTimer)
+	{
+		dispatch_source_cancel(saveTimer);
+		if (saveTimerSuspended)
+		{
+			// Must resume a timer before releasing it (or it will crash)
+			dispatch_resume(saveTimer);
+			saveTimerSuspended = NO;
+		}
+		#if !OS_OBJECT_USE_OBJC
+		dispatch_release(saveTimer);
+		#endif
+		saveTimer = NULL;
+	}
+}
+
+- (void)updateAndResumeSaveTimer
+{
+	if ((saveTimer != NULL) && (saveInterval > 0.0) && (unsavedTime > 0.0))
+	{
+		uint64_t interval = (uint64_t)(saveInterval * NSEC_PER_SEC);
+		dispatch_time_t startTime = dispatch_time(unsavedTime, interval);
+		
+		dispatch_source_set_timer(saveTimer, startTime, interval, 1.0);
+		
+		if (saveTimerSuspended)
+		{
+			dispatch_resume(saveTimer);
+			saveTimerSuspended = NO;
+		}
+	}
+}
+
+- (void)createSuspendedSaveTimer
+{
+	if ((saveTimer == NULL) && (saveInterval > 0.0))
+	{
+		saveTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, loggerQueue);
+		
+		dispatch_source_set_event_handler(saveTimer, ^{ @autoreleasepool {
+			
+			[self performSaveAndSuspendSaveTimer];
+			
+		}});
+		
+		saveTimerSuspended = YES;
+	}
+}
+
+- (void)destroyDeleteTimer
+{
+	if (deleteTimer)
+	{
+		dispatch_source_cancel(deleteTimer);
+		#if !OS_OBJECT_USE_OBJC
+		dispatch_release(deleteTimer);
+		#endif
+		deleteTimer = NULL;
+	}
+}
+
+- (void)updateDeleteTimer
+{
+	if ((deleteTimer != NULL) && (deleteInterval > 0.0) && (maxAge > 0.0))
+	{
+		uint64_t interval = (uint64_t)(deleteInterval * NSEC_PER_SEC);
+		dispatch_time_t startTime;
+		
+		if (lastDeleteTime > 0)
+			startTime = dispatch_time(lastDeleteTime, interval);
+		else
+			startTime = dispatch_time(DISPATCH_TIME_NOW, interval);
+		
+		dispatch_source_set_timer(deleteTimer, startTime, interval, 1.0);
+	}
+}
+
+- (void)createAndStartDeleteTimer
+{
+	if ((deleteTimer == NULL) && (deleteInterval > 0.0) && (maxAge > 0.0))
+	{
+		deleteTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, loggerQueue);
+
+        if (deleteTimer != NULL) {
+            dispatch_source_set_event_handler(deleteTimer, ^{ @autoreleasepool {
+
+                [self performDelete];
+
+            }});
+
+            [self updateDeleteTimer];
+            
+            dispatch_resume(deleteTimer);
+        }
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+#pragma mark Configuration
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+- (NSUInteger)saveThreshold
+{
+	// The design of this method is taken from the DDAbstractLogger implementation.
+	// For extensive documentation please refer to the DDAbstractLogger implementation.
+	
+	// Note: The internal implementation MUST access the colorsEnabled variable directly,
+	// This method is designed explicitly for external access.
+	//
+	// Using "self." syntax to go through this method will cause immediate deadlock.
+	// This is the intended result. Fix it by accessing the ivar directly.
+	// Great strides have been take to ensure this is safe to do. Plus it's MUCH faster.
+	
+	NSAssert(![self isOnGlobalLoggingQueue], @"Core architecture requirement failure");
+	NSAssert(![self isOnInternalLoggerQueue], @"MUST access ivar directly, NOT via self.* syntax.");
+	
+	dispatch_queue_t globalLoggingQueue = [DDLog loggingQueue];
+	
+	__block NSUInteger result;
+	
+	dispatch_sync(globalLoggingQueue, ^{
+		dispatch_sync(loggerQueue, ^{
+			result = saveThreshold;
+		});
+	});
+	
+	return result;
+}
+
+- (void)setSaveThreshold:(NSUInteger)threshold
+{
+	dispatch_block_t block = ^{ @autoreleasepool {
+		
+		if (saveThreshold != threshold)
+		{
+			saveThreshold = threshold;
+			
+			// Since the saveThreshold has changed,
+			// we check to see if the current unsavedCount has surpassed the new threshold.
+			// 
+			// If it has, we immediately save the log.
+			
+			if ((unsavedCount >= saveThreshold) && (saveThreshold > 0))
+			{
+				[self performSaveAndSuspendSaveTimer];
+			}
+		}
+	}};
+	
+	// The design of the setter logic below is taken from the DDAbstractLogger implementation.
+	// For documentation please refer to the DDAbstractLogger implementation.
+	
+	if ([self isOnInternalLoggerQueue])
+	{
+		block();
+	}
+	else
+	{
+		dispatch_queue_t globalLoggingQueue = [DDLog loggingQueue];
+		NSAssert(![self isOnGlobalLoggingQueue], @"Core architecture requirement failure");
+		
+		dispatch_async(globalLoggingQueue, ^{
+			dispatch_async(loggerQueue, block);
+		});
+	}
+}
+
+- (NSTimeInterval)saveInterval
+{
+	// The design of this method is taken from the DDAbstractLogger implementation.
+	// For extensive documentation please refer to the DDAbstractLogger implementation.
+	
+	// Note: The internal implementation MUST access the colorsEnabled variable directly,
+	// This method is designed explicitly for external access.
+	//
+	// Using "self." syntax to go through this method will cause immediate deadlock.
+	// This is the intended result. Fix it by accessing the ivar directly.
+	// Great strides have been take to ensure this is safe to do. Plus it's MUCH faster.
+	
+	NSAssert(![self isOnGlobalLoggingQueue], @"Core architecture requirement failure");
+	NSAssert(![self isOnInternalLoggerQueue], @"MUST access ivar directly, NOT via self.* syntax.");
+	
+	dispatch_queue_t globalLoggingQueue = [DDLog loggingQueue];
+	
+	__block NSTimeInterval result;
+	
+	dispatch_sync(globalLoggingQueue, ^{
+		dispatch_sync(loggerQueue, ^{
+			result = saveInterval;
+		});
+	});
+	
+	return result;
+}
+
+- (void)setSaveInterval:(NSTimeInterval)interval
+{
+	dispatch_block_t block = ^{ @autoreleasepool {
+	
+		// C99 recommended floating point comparison macro
+		// Read: isLessThanOrGreaterThan(floatA, floatB)
+		
+		if (/* saveInterval != interval */ islessgreater(saveInterval, interval))
+		{
+			saveInterval = interval;
+			
+			// There are several cases we need to handle here.
+			// 
+			// 1. If the saveInterval was previously enabled and it just got disabled,
+			//    then we need to stop the saveTimer. (And we might as well release it.)
+			// 
+			// 2. If the saveInterval was previously disabled and it just got enabled,
+			//    then we need to setup the saveTimer. (Plus we might need to do an immediate save.)
+			// 
+			// 3. If the saveInterval increased, then we need to reset the timer so that it fires at the later date.
+			// 
+			// 4. If the saveInterval decreased, then we need to reset the timer so that it fires at an earlier date.
+			//    (Plus we might need to do an immediate save.)
+			
+			if (saveInterval > 0.0)
+			{
+				if (saveTimer == NULL)
+				{
+					// Handles #2
+					//
+					// Since the saveTimer uses the unsavedTime to calculate it's first fireDate,
+					// if a save is needed the timer will fire immediately.
+					
+					[self createSuspendedSaveTimer];
+					[self updateAndResumeSaveTimer];
+				}
+				else
+				{
+					// Handles #3
+					// Handles #4
+					//
+					// Since the saveTimer uses the unsavedTime to calculate it's first fireDate,
+					// if a save is needed the timer will fire immediately.
+					
+					[self updateAndResumeSaveTimer];
+				}
+			}
+			else if (saveTimer)
+			{
+				// Handles #1
+				
+				[self destroySaveTimer];
+			}
+		}
+	}};
+	
+	// The design of the setter logic below is taken from the DDAbstractLogger implementation.
+	// For documentation please refer to the DDAbstractLogger implementation.
+	
+	if ([self isOnInternalLoggerQueue])
+	{
+		block();
+	}
+	else
+	{
+		dispatch_queue_t globalLoggingQueue = [DDLog loggingQueue];
+		NSAssert(![self isOnGlobalLoggingQueue], @"Core architecture requirement failure");
+		
+		dispatch_async(globalLoggingQueue, ^{
+			dispatch_async(loggerQueue, block);
+		});
+	}
+}
+
+- (NSTimeInterval)maxAge
+{
+	// The design of this method is taken from the DDAbstractLogger implementation.
+	// For extensive documentation please refer to the DDAbstractLogger implementation.
+	
+	// Note: The internal implementation MUST access the colorsEnabled variable directly,
+	// This method is designed explicitly for external access.
+	//
+	// Using "self." syntax to go through this method will cause immediate deadlock.
+	// This is the intended result. Fix it by accessing the ivar directly.
+	// Great strides have been take to ensure this is safe to do. Plus it's MUCH faster.
+	
+	NSAssert(![self isOnGlobalLoggingQueue], @"Core architecture requirement failure");
+	NSAssert(![self isOnInternalLoggerQueue], @"MUST access ivar directly, NOT via self.* syntax.");
+	
+	dispatch_queue_t globalLoggingQueue = [DDLog loggingQueue];
+	
+	__block NSTimeInterval result;
+	
+	dispatch_sync(globalLoggingQueue, ^{
+		dispatch_sync(loggerQueue, ^{
+			result = maxAge;
+		});
+	});
+	
+	return result;
+}
+
+- (void)setMaxAge:(NSTimeInterval)interval
+{
+	dispatch_block_t block = ^{ @autoreleasepool {
+		
+		// C99 recommended floating point comparison macro
+		// Read: isLessThanOrGreaterThan(floatA, floatB)
+		
+		if (/* maxAge != interval */ islessgreater(maxAge, interval))
+		{
+			NSTimeInterval oldMaxAge = maxAge;
+			NSTimeInterval newMaxAge = interval;
+			
+			maxAge = interval;
+			
+			// There are several cases we need to handle here.
+			// 
+			// 1. If the maxAge was previously enabled and it just got disabled,
+			//    then we need to stop the deleteTimer. (And we might as well release it.)
+			// 
+			// 2. If the maxAge was previously disabled and it just got enabled,
+			//    then we need to setup the deleteTimer. (Plus we might need to do an immediate delete.)
+			// 
+			// 3. If the maxAge was increased,
+			//    then we don't need to do anything.
+			// 
+			// 4. If the maxAge was decreased,
+			//    then we should do an immediate delete.
+			
+			BOOL shouldDeleteNow = NO;
+			
+			if (oldMaxAge > 0.0)
+			{
+				if (newMaxAge <= 0.0)
+				{
+					// Handles #1
+					
+					[self destroyDeleteTimer];
+				}
+				else if (oldMaxAge > newMaxAge)
+				{
+					// Handles #4
+					shouldDeleteNow = YES;
+				}
+			}
+			else if (newMaxAge > 0.0)
+			{
+				// Handles #2
+				shouldDeleteNow = YES;
+			}
+			
+			if (shouldDeleteNow)
+			{
+				[self performDelete];
+				
+				if (deleteTimer)
+					[self updateDeleteTimer];
+				else
+					[self createAndStartDeleteTimer];
+			}
+		}
+	}};
+	
+	// The design of the setter logic below is taken from the DDAbstractLogger implementation.
+	// For documentation please refer to the DDAbstractLogger implementation.
+	
+	if ([self isOnInternalLoggerQueue])
+	{
+		block();
+	}
+	else
+	{
+		dispatch_queue_t globalLoggingQueue = [DDLog loggingQueue];
+		NSAssert(![self isOnGlobalLoggingQueue], @"Core architecture requirement failure");
+		
+		dispatch_async(globalLoggingQueue, ^{
+			dispatch_async(loggerQueue, block);
+		});
+	}
+}
+
+- (NSTimeInterval)deleteInterval
+{
+	// The design of this method is taken from the DDAbstractLogger implementation.
+	// For extensive documentation please refer to the DDAbstractLogger implementation.
+	
+	// Note: The internal implementation MUST access the colorsEnabled variable directly,
+	// This method is designed explicitly for external access.
+	//
+	// Using "self." syntax to go through this method will cause immediate deadlock.
+	// This is the intended result. Fix it by accessing the ivar directly.
+	// Great strides have been take to ensure this is safe to do. Plus it's MUCH faster.
+	
+	NSAssert(![self isOnGlobalLoggingQueue], @"Core architecture requirement failure");
+	NSAssert(![self isOnInternalLoggerQueue], @"MUST access ivar directly, NOT via self.* syntax.");
+	
+	dispatch_queue_t globalLoggingQueue = [DDLog loggingQueue];
+	
+	__block NSTimeInterval result;
+	
+	dispatch_sync(globalLoggingQueue, ^{
+		dispatch_sync(loggerQueue, ^{
+			result = deleteInterval;
+		});
+	});
+	
+	return result;
+}
+
+- (void)setDeleteInterval:(NSTimeInterval)interval
+{
+	dispatch_block_t block = ^{ @autoreleasepool {
+		
+		// C99 recommended floating point comparison macro
+		// Read: isLessThanOrGreaterThan(floatA, floatB)
+		
+		if (/* deleteInterval != interval */ islessgreater(deleteInterval, interval))
+		{
+			deleteInterval = interval;
+			
+			// There are several cases we need to handle here.
+			// 
+			// 1. If the deleteInterval was previously enabled and it just got disabled,
+			//    then we need to stop the deleteTimer. (And we might as well release it.)
+			// 
+			// 2. If the deleteInterval was previously disabled and it just got enabled,
+			//    then we need to setup the deleteTimer. (Plus we might need to do an immediate delete.)
+			// 
+			// 3. If the deleteInterval increased, then we need to reset the timer so that it fires at the later date.
+			// 
+			// 4. If the deleteInterval decreased, then we need to reset the timer so that it fires at an earlier date.
+			//    (Plus we might need to do an immediate delete.)
+			
+			if (deleteInterval > 0.0)
+			{
+				if (deleteTimer == NULL)
+				{
+					// Handles #2
+					//
+					// Since the deleteTimer uses the lastDeleteTime to calculate it's first fireDate,
+					// if a delete is needed the timer will fire immediately.
+					
+					[self createAndStartDeleteTimer];
+				}
+				else
+				{
+					// Handles #3
+					// Handles #4
+					//
+					// Since the deleteTimer uses the lastDeleteTime to calculate it's first fireDate,
+					// if a save is needed the timer will fire immediately.
+					
+					[self updateDeleteTimer];
+				}
+			}
+			else if (deleteTimer)
+			{
+				// Handles #1
+				
+				[self destroyDeleteTimer];
+			}
+		}
+	}};
+	
+	// The design of the setter logic below is taken from the DDAbstractLogger implementation.
+	// For documentation please refer to the DDAbstractLogger implementation.
+	
+	if ([self isOnInternalLoggerQueue])
+	{
+		block();
+	}
+	else
+	{
+		dispatch_queue_t globalLoggingQueue = [DDLog loggingQueue];
+		NSAssert(![self isOnGlobalLoggingQueue], @"Core architecture requirement failure");
+		
+		dispatch_async(globalLoggingQueue, ^{
+			dispatch_async(loggerQueue, block);
+		});
+	}
+}
+
+- (BOOL)deleteOnEverySave
+{
+	// The design of this method is taken from the DDAbstractLogger implementation.
+	// For extensive documentation please refer to the DDAbstractLogger implementation.
+	
+	// Note: The internal implementation MUST access the colorsEnabled variable directly,
+	// This method is designed explicitly for external access.
+	//
+	// Using "self." syntax to go through this method will cause immediate deadlock.
+	// This is the intended result. Fix it by accessing the ivar directly.
+	// Great strides have been take to ensure this is safe to do. Plus it's MUCH faster.
+	
+	NSAssert(![self isOnGlobalLoggingQueue], @"Core architecture requirement failure");
+	NSAssert(![self isOnInternalLoggerQueue], @"MUST access ivar directly, NOT via self.* syntax.");
+	
+	dispatch_queue_t globalLoggingQueue = [DDLog loggingQueue];
+	
+	__block BOOL result;
+	
+	dispatch_sync(globalLoggingQueue, ^{
+		dispatch_sync(loggerQueue, ^{
+			result = deleteOnEverySave;
+		});
+	});
+	
+	return result;
+}
+
+- (void)setDeleteOnEverySave:(BOOL)flag
+{
+	dispatch_block_t block = ^{
+		
+		deleteOnEverySave = flag;
+	};
+	
+	// The design of the setter logic below is taken from the DDAbstractLogger implementation.
+	// For documentation please refer to the DDAbstractLogger implementation.
+	
+	if ([self isOnInternalLoggerQueue])
+	{
+		block();
+	}
+	else
+	{
+		dispatch_queue_t globalLoggingQueue = [DDLog loggingQueue];
+		NSAssert(![self isOnGlobalLoggingQueue], @"Core architecture requirement failure");
+		
+		dispatch_async(globalLoggingQueue, ^{
+			dispatch_async(loggerQueue, block);
+		});
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+#pragma mark Public API
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+- (void)savePendingLogEntries
+{
+	dispatch_block_t block = ^{ @autoreleasepool {
+		
+		[self performSaveAndSuspendSaveTimer];
+	}};
+	
+	if ([self isOnInternalLoggerQueue])
+		block();
+	else
+		dispatch_async(loggerQueue, block);
+}
+
+- (void)deleteOldLogEntries
+{
+	dispatch_block_t block = ^{ @autoreleasepool {
+		
+		[self performDelete];
+	}};
+	
+	if ([self isOnInternalLoggerQueue])
+		block();
+	else
+		dispatch_async(loggerQueue, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+#pragma mark DDLogger
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+- (void)didAddLogger
+{
+	// If you override me be sure to invoke [super didAddLogger];
+	
+	[self createSuspendedSaveTimer];
+	
+	[self createAndStartDeleteTimer];
+}
+
+- (void)willRemoveLogger
+{
+	// If you override me be sure to invoke [super willRemoveLogger];
+	
+	[self performSaveAndSuspendSaveTimer];
+	
+	[self destroySaveTimer];
+	[self destroyDeleteTimer];
+}
+
+- (void)logMessage:(DDLogMessage *)logMessage
+{
+	if ([self db_log:logMessage])
+	{
+		BOOL firstUnsavedEntry = (++unsavedCount == 1);
+		
+		if ((unsavedCount >= saveThreshold) && (saveThreshold > 0))
+		{
+			[self performSaveAndSuspendSaveTimer];
+		}
+		else if (firstUnsavedEntry)
+		{
+			unsavedTime = dispatch_time(DISPATCH_TIME_NOW, 0);
+			[self updateAndResumeSaveTimer];
+		}
+	}
+}
+
+- (void)flush
+{
+	// This method is invoked by DDLog's flushLog method.
+	// 
+	// It is called automatically when the application quits,
+	// or if the developer invokes DDLog's flushLog method prior to crashing or something.
+	
+	[self performSaveAndSuspendSaveTimer];
+}
+
+@end