Subversion Repositories Mobile Apps.GyroMouse

#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