RubyGems - motion-yapper - Versions diffs - 0.0.3 → 0.1.0 - Mend

motion-yapper 0.0.3 → 0.1.0

Files changed (294) hide show

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

@@ -1,727 +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/CocoaLumberjack/CocoaLumberjack
- *
- * If you're new to the project you may wish to read the "Getting Started" wiki.
- * https://github.com/CocoaLumberjack/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];
-            if (deleteTimer != NULL) 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