motion-logger 0.1.3 → 0.1.4

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

@@ -1,618 +0,0 @@
-#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);
-		dispatch_release(saveTimer);
-		saveTimer = NULL;
-	}
-}
-
-- (void)updateAndResumeSaveTimer
-{
-	if ((saveTimer != NULL) && (saveInterval > 0.0) && (unsavedTime > 0.0))
-	{
-		uint64_t interval = 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);
-		dispatch_release(deleteTimer);
-		deleteTimer = NULL;
-	}
-}
-
-- (void)updateDeleteTimer
-{
-	if ((deleteTimer != NULL) && (deleteInterval > 0.0) && (maxAge > 0.0))
-	{
-		uint64_t interval = 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);
-		
-		dispatch_source_set_event_handler(deleteTimer, ^{ @autoreleasepool {
-			
-			[self performDelete];
-			
-		}});
-		
-		[self updateDeleteTimer];
-		
-		dispatch_resume(deleteTimer);
-	}
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark Configuration
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-- (NSUInteger)saveThreshold
-{
-	if (dispatch_get_current_queue() == loggerQueue)
-	{
-		return saveThreshold;
-	}
-	else
-	{
-		__block NSUInteger result;
-		
-		dispatch_sync(loggerQueue, ^{
-			result = saveThreshold;
-		});
-		
-		return result;
-	}
-}
-
-- (void)setSaveThreshold:(NSUInteger)threshold
-{
-	dispatch_block_t block = ^{
-		
-		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))
-			{
-				@autoreleasepool {
-					
-					[self performSaveAndSuspendSaveTimer];
-				
-				}
-			}
-		}
-	};
-	
-	if (dispatch_get_current_queue() == loggerQueue)
-		block();
-	else
-		dispatch_async(loggerQueue, block);
-}
-
-- (NSTimeInterval)saveInterval
-{
-	if (dispatch_get_current_queue() == loggerQueue)
-	{
-		return saveInterval;
-	}
-	else
-	{
-		__block NSTimeInterval result;
-		
-		dispatch_sync(loggerQueue, ^{
-			result = saveInterval;
-		});
-		
-		return result;
-	}
-}
-
-- (void)setSaveInterval:(NSTimeInterval)interval
-{
-	dispatch_block_t block = ^{
-	
-		// 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)
-			{
-				@autoreleasepool
-				{
-					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];
-			}
-		}
-	};
-	
-	if (dispatch_get_current_queue() == loggerQueue)
-		block();
-	else
-		dispatch_async(loggerQueue, block);
-}
-
-- (NSTimeInterval)maxAge
-{
-	if (dispatch_get_current_queue() == loggerQueue)
-	{
-		return maxAge;
-	}
-	else
-	{
-		__block NSTimeInterval result;
-		
-		dispatch_sync(loggerQueue, ^{
-			result = maxAge;
-		});
-		
-		return result;
-	}
-}
-
-- (void)setMaxAge:(NSTimeInterval)interval
-{
-	dispatch_block_t block = ^{
-		
-		// 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)
-			{
-				@autoreleasepool
-				{
-					[self performDelete];
-					
-					if (deleteTimer)
-						[self updateDeleteTimer];
-					else
-						[self createAndStartDeleteTimer];
-				}
-			}
-		}
-	};
-	
-	if (dispatch_get_current_queue() == loggerQueue)
-		block();
-	else
-		dispatch_async(loggerQueue, block);
-}
-
-- (NSTimeInterval)deleteInterval
-{
-	if (dispatch_get_current_queue() == loggerQueue)
-	{
-		return deleteInterval;
-	}
-	else
-	{
-		__block NSTimeInterval result;
-		
-		dispatch_sync(loggerQueue, ^{
-			result = deleteInterval;
-		});
-		
-		return result;
-	}
-}
-
-- (void)setDeleteInterval:(NSTimeInterval)interval
-{
-	dispatch_block_t block = ^{
-		
-		// 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)
-			{
-				@autoreleasepool
-				{
-					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];
-			}
-		}
-	};
-	
-	if (dispatch_get_current_queue() == loggerQueue)
-		block();
-	else
-		dispatch_async(loggerQueue, block);
-}
-
-- (BOOL)deleteOnEverySave
-{
-	if (dispatch_get_current_queue() == loggerQueue)
-	{
-		return deleteOnEverySave;
-	}
-	else
-	{
-		__block BOOL result;
-		
-		dispatch_sync(loggerQueue, ^{
-			result = deleteOnEverySave;
-		});
-		
-		return result;
-	}
-}
-
-- (void)setDeleteOnEverySave:(BOOL)flag
-{
-	dispatch_block_t block = ^{
-		
-		deleteOnEverySave = flag;
-	};
-	
-	if (dispatch_get_current_queue() == loggerQueue)
-		block();
-	else
-		dispatch_async(loggerQueue, block);
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark Public API
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-- (void)savePendingLogEntries
-{
-	dispatch_block_t block = ^{ @autoreleasepool {
-		
-		[self performSaveAndSuspendSaveTimer];
-	}};
-	
-	if (dispatch_get_current_queue() == loggerQueue)
-		block();
-	else
-		dispatch_async(loggerQueue, block);
-}
-
-- (void)deleteOldLogEntries
-{
-	dispatch_block_t block = ^{ @autoreleasepool {
-		
-		[self performDelete];
-	}};
-	
-	if (dispatch_get_current_queue() == loggerQueue)
-		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