motion-logger 0.1.3 → 0.1.4

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

@@ -1,334 +0,0 @@
-#import <Foundation/Foundation.h>
-#import "DDLog.h"
-
-@class DDLogFileInfo;
-
-/**
- * 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 to write log statements to a file.
-**/
-
-
-// Default configuration and safety/sanity values.
-// 
-// maximumFileSize         -> DEFAULT_LOG_MAX_FILE_SIZE
-// rollingFrequency        -> DEFAULT_LOG_ROLLING_FREQUENCY
-// maximumNumberOfLogFiles -> DEFAULT_LOG_MAX_NUM_LOG_FILES
-// 
-// You should carefully consider the proper configuration values for your application.
-
-#define DEFAULT_LOG_MAX_FILE_SIZE     (1024 * 1024)   //  1 MB
-#define DEFAULT_LOG_ROLLING_FREQUENCY (60 * 60 * 24)  // 24 Hours
-#define DEFAULT_LOG_MAX_NUM_LOG_FILES (5)             //  5 Files
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark -
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-// The LogFileManager protocol is designed to allow you to control all aspects of your log files.
-// 
-// The primary purpose of this is to allow you to do something with the log files after they have been rolled.
-// Perhaps you want to compress them to save disk space.
-// Perhaps you want to upload them to an FTP server.
-// Perhaps you want to run some analytics on the file.
-// 
-// A default LogFileManager is, of course, provided.
-// The default LogFileManager simply deletes old log files according to the maximumNumberOfLogFiles property.
-// 
-// This protocol provides various methods to fetch the list of log files.
-// 
-// There are two variants: sorted and unsorted.
-// If sorting is not necessary, the unsorted variant is obviously faster.
-// The sorted variant will return an array sorted by when the log files were created,
-// with the most recently created log file at index 0, and the oldest log file at the end of the array.
-// 
-// You can fetch only the log file paths (full path including name), log file names (name only),
-// or an array of DDLogFileInfo objects.
-// The DDLogFileInfo class is documented below, and provides a handy wrapper that
-// gives you easy access to various file attributes such as the creation date or the file size.
-
-@protocol DDLogFileManager <NSObject>
-@required
-
-// Public properties
-
-/**
- * The maximum number of archived log files to keep on disk.
- * For example, if this property is set to 3,
- * then the LogFileManager will only keep 3 archived log files (plus the current active log file) on disk.
- * Once the active log file is rolled/archived, then the oldest of the existing 3 rolled/archived log files is deleted.
- * 
- * You may optionally disable deleting old/rolled/archived log files by setting this property to zero.
-**/
-@property (readwrite, assign) NSUInteger maximumNumberOfLogFiles;
-
-// Public methods
-
-- (NSString *)logsDirectory;
-
-- (NSArray *)unsortedLogFilePaths;
-- (NSArray *)unsortedLogFileNames;
-- (NSArray *)unsortedLogFileInfos;
-
-- (NSArray *)sortedLogFilePaths;
-- (NSArray *)sortedLogFileNames;
-- (NSArray *)sortedLogFileInfos;
-
-// Private methods (only to be used by DDFileLogger)
-
-- (NSString *)createNewLogFile;
-
-@optional
-
-// Notifications from DDFileLogger
-
-- (void)didArchiveLogFile:(NSString *)logFilePath;
-- (void)didRollAndArchiveLogFile:(NSString *)logFilePath;
-
-@end
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark -
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
- * Default log file manager.
- * 
- * All log files are placed inside the logsDirectory.
- * If a specific logsDirectory isn't specified, the default directory is used.
- * On Mac, this is in ~/Library/Logs/<Application Name>.
- * On iPhone, this is in ~/Library/Caches/Logs.
- * 
- * Log files are named "log-<uuid>.txt",
- * where uuid is a 6 character hexadecimal consisting of the set [0123456789ABCDEF].
- * 
- * Archived log files are automatically deleted according to the maximumNumberOfLogFiles property.
-**/
-@interface DDLogFileManagerDefault : NSObject <DDLogFileManager>
-{
-	NSUInteger maximumNumberOfLogFiles;
-	NSString *_logsDirectory;
-}
-
-- (id)init;
-- (id)initWithLogsDirectory:(NSString *)logsDirectory;
-
-/* Inherited from DDLogFileManager protocol:
-
-@property (readwrite, assign) NSUInteger maximumNumberOfLogFiles;
-
-- (NSString *)logsDirectory;
-
-- (NSArray *)unsortedLogFilePaths;
-- (NSArray *)unsortedLogFileNames;
-- (NSArray *)unsortedLogFileInfos;
-
-- (NSArray *)sortedLogFilePaths;
-- (NSArray *)sortedLogFileNames;
-- (NSArray *)sortedLogFileInfos;
-
-*/
-
-@end
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark -
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
- * Most users will want file log messages to be prepended with the date and time.
- * Rather than forcing the majority of users to write their own formatter,
- * we will supply a logical default formatter.
- * Users can easily replace this formatter with their own by invoking the setLogFormatter method.
- * It can also be removed by calling setLogFormatter, and passing a nil parameter.
- * 
- * In addition to the convenience of having a logical default formatter,
- * it will also provide a template that makes it easy for developers to copy and change.
-**/
-@interface DDLogFileFormatterDefault : NSObject <DDLogFormatter>
-{
-	NSDateFormatter *dateFormatter;
-}
-
-- (id)init;
-- (id)initWithDateFormatter:(NSDateFormatter *)dateFormatter;
-
-@end
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark -
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-@interface DDFileLogger : DDAbstractLogger <DDLogger>
-{
-	__strong id <DDLogFileManager> logFileManager;
-	
-	DDLogFileInfo *currentLogFileInfo;
-	NSFileHandle *currentLogFileHandle;
-	
-	dispatch_source_t rollingTimer;
-	
-	unsigned long long maximumFileSize;
-	NSTimeInterval rollingFrequency;
-}
-
-- (id)init;
-- (id)initWithLogFileManager:(id <DDLogFileManager>)logFileManager;
-
-/**
- * Log File Rolling:
- * 
- * maximumFileSize:
- *   The approximate maximum size to allow log files to grow.
- *   If a log file is larger than this value after a log statement is appended,
- *   then the log file is rolled.
- * 
- * rollingFrequency
- *   How often to roll the log file.
- *   The frequency is given as an NSTimeInterval, which is a double that specifies the interval in seconds.
- *   Once the log file gets to be this old, it is rolled.
- * 
- * Both the maximumFileSize and the rollingFrequency are used to manage rolling.
- * Whichever occurs first will cause the log file to be rolled.
- * 
- * For example:
- * The rollingFrequency is 24 hours,
- * but the log file surpasses the maximumFileSize after only 20 hours.
- * The log file will be rolled at that 20 hour mark.
- * A new log file will be created, and the 24 hour timer will be restarted.
- * 
- * You may optionally disable rolling due to filesize by setting maximumFileSize to zero.
- * If you do so, rolling is based solely on rollingFrequency.
- * 
- * You may optionally disable rolling due to time by setting rollingFrequency to zero (or any non-positive number).
- * If you do so, rolling is based solely on maximumFileSize.
- * 
- * If you disable both maximumFileSize and rollingFrequency, then the log file won't ever be rolled.
- * This is strongly discouraged.
-**/
-@property (readwrite, assign) unsigned long long maximumFileSize;
-@property (readwrite, assign) NSTimeInterval rollingFrequency;
-
-/**
- * The DDLogFileManager instance can be used to retrieve the list of log files,
- * and configure the maximum number of archived log files to keep.
- * 
- * @see DDLogFileManager.maximumNumberOfLogFiles
-**/
-@property (strong, nonatomic, readonly) id <DDLogFileManager> logFileManager;
-
-
-// You can optionally force the current log file to be rolled with this method.
-
-- (void)rollLogFile;
-
-// Inherited from DDAbstractLogger
-
-// - (id <DDLogFormatter>)logFormatter;
-// - (void)setLogFormatter:(id <DDLogFormatter>)formatter;
-
-@end
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark -
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
- * DDLogFileInfo is a simple class that provides access to various file attributes.
- * It provides good performance as it only fetches the information if requested,
- * and it caches the information to prevent duplicate fetches.
- * 
- * It was designed to provide quick snapshots of the current state of log files,
- * and to help sort log files in an array.
- * 
- * This class does not monitor the files, or update it's cached attribute values if the file changes on disk.
- * This is not what the class was designed for.
- * 
- * If you absolutely must get updated values,
- * you can invoke the reset method which will clear the cache.
-**/
-@interface DDLogFileInfo : NSObject
-{
-	__strong NSString *filePath;
-	__strong NSString *fileName;
-	
-	__strong NSDictionary *fileAttributes;
-	
-	__strong NSDate *creationDate;
-	__strong NSDate *modificationDate;
-	
-	unsigned long long fileSize;
-}
-
-@property (strong, nonatomic, readonly) NSString *filePath;
-@property (strong, nonatomic, readonly) NSString *fileName;
-
-@property (strong, nonatomic, readonly) NSDictionary *fileAttributes;
-
-@property (strong, nonatomic, readonly) NSDate *creationDate;
-@property (strong, nonatomic, readonly) NSDate *modificationDate;
-
-@property (nonatomic, readonly) unsigned long long fileSize;
-
-@property (nonatomic, readonly) NSTimeInterval age;
-
-@property (nonatomic, readwrite) BOOL isArchived;
-
-+ (id)logFileWithPath:(NSString *)filePath;
-
-- (id)initWithFilePath:(NSString *)filePath;
-
-- (void)reset;
-- (void)renameFile:(NSString *)newFileName;
-
-#if TARGET_IPHONE_SIMULATOR
-
-// So here's the situation.
-// Extended attributes are perfect for what we're trying to do here (marking files as archived).
-// This is exactly what extended attributes were designed for.
-// 
-// But Apple screws us over on the simulator.
-// Everytime you build-and-go, they copy the application into a new folder on the hard drive,
-// and as part of the process they strip extended attributes from our log files.
-// Normally, a copy of a file preserves extended attributes.
-// So obviously Apple has gone to great lengths to piss us off.
-// 
-// Thus we use a slightly different tactic for marking log files as archived in the simulator.
-// That way it "just works" and there's no confusion when testing.
-// 
-// The difference in method names is indicative of the difference in functionality.
-// On the simulator we add an attribute by appending a filename extension.
-// 
-// For example:
-// log-ABC123.txt -> log-ABC123.archived.txt
-
-- (BOOL)hasExtensionAttributeWithName:(NSString *)attrName;
-
-- (void)addExtensionAttributeWithName:(NSString *)attrName;
-- (void)removeExtensionAttributeWithName:(NSString *)attrName;
-
-#else
-
-// Normal use of extended attributes used everywhere else,
-// such as on Macs and on iPhone devices.
-
-- (BOOL)hasExtendedAttributeWithName:(NSString *)attrName;
-
-- (void)addExtendedAttributeWithName:(NSString *)attrName;
-- (void)removeExtendedAttributeWithName:(NSString *)attrName;
-
-#endif
-
-- (NSComparisonResult)reverseCompareByCreationDate:(DDLogFileInfo *)another;
-- (NSComparisonResult)reverseCompareByModificationDate:(DDLogFileInfo *)another;
-
-@end

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

@@ -1,1346 +0,0 @@
-#import "DDFileLogger.h"
-
-#import <unistd.h>
-#import <sys/attr.h>
-#import <sys/xattr.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
-
-// We probably shouldn't be using DDLog() statements within the DDLog implementation.
-// But we still want to leave our log statements for any future debugging,
-// and to allow other developers to trace the implementation (which is a great learning tool).
-// 
-// So we use primitive logging macros around NSLog.
-// We maintain the NS prefix on the macros to be explicit about the fact that we're using NSLog.
-
-#define LOG_LEVEL 2
-
-#define NSLogError(frmt, ...)    do{ if(LOG_LEVEL >= 1) NSLog((frmt), ##__VA_ARGS__); } while(0)
-#define NSLogWarn(frmt, ...)     do{ if(LOG_LEVEL >= 2) NSLog((frmt), ##__VA_ARGS__); } while(0)
-#define NSLogInfo(frmt, ...)     do{ if(LOG_LEVEL >= 3) NSLog((frmt), ##__VA_ARGS__); } while(0)
-#define NSLogVerbose(frmt, ...)  do{ if(LOG_LEVEL >= 4) NSLog((frmt), ##__VA_ARGS__); } while(0)
-
-@interface DDLogFileManagerDefault (PrivateAPI)
-
-- (void)deleteOldLogFiles;
-- (NSString *)defaultLogsDirectory;
-
-@end
-
-@interface DDFileLogger (PrivateAPI)
-
-- (void)rollLogFileNow;
-- (void)maybeRollLogFileDueToAge;
-- (void)maybeRollLogFileDueToSize;
-
-@end
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark -
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-@implementation DDLogFileManagerDefault
-
-@synthesize maximumNumberOfLogFiles;
-
-- (id)init
-{
-	return [self initWithLogsDirectory:nil];
-}
-
-- (id)initWithLogsDirectory:(NSString *)aLogsDirectory
-{
-	if ((self = [super init]))
-	{
-		maximumNumberOfLogFiles = DEFAULT_LOG_MAX_NUM_LOG_FILES;
-		
-		if (aLogsDirectory)
-			_logsDirectory = [aLogsDirectory copy];
-		else
-			_logsDirectory = [[self defaultLogsDirectory] copy];
-		
-		NSKeyValueObservingOptions kvoOptions = NSKeyValueObservingOptionOld | NSKeyValueObservingOptionNew;
-		
-		[self addObserver:self forKeyPath:@"maximumNumberOfLogFiles" options:kvoOptions context:nil];
-		
-		NSLogVerbose(@"DDFileLogManagerDefault: logsDirectory:\n%@", [self logsDirectory]);
-		NSLogVerbose(@"DDFileLogManagerDefault: sortedLogFileNames:\n%@", [self sortedLogFileNames]);
-	}
-	return self;
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark Configuration
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-- (void)observeValueForKeyPath:(NSString *)keyPath
-                      ofObject:(id)object
-                        change:(NSDictionary *)change
-                       context:(void *)context
-{
-	NSNumber *old = [change objectForKey:NSKeyValueChangeOldKey];
-	NSNumber *new = [change objectForKey:NSKeyValueChangeNewKey];
-	
-	if ([old isEqual:new])
-	{
-		// No change in value - don't bother with any processing.
-		return;
-	}
-	
-	if ([keyPath isEqualToString:@"maximumNumberOfLogFiles"])
-	{
-		NSLogInfo(@"DDFileLogManagerDefault: Responding to configuration change: maximumNumberOfLogFiles");
-		
-		dispatch_async([DDLog loggingQueue], ^{ @autoreleasepool {
-			
-			[self deleteOldLogFiles];
-		}});
-	}
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark File Deleting
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
- * Deletes archived log files that exceed the maximumNumberOfLogFiles configuration value.
-**/
-- (void)deleteOldLogFiles
-{
-	NSLogVerbose(@"DDLogFileManagerDefault: deleteOldLogFiles");
-	
-	NSUInteger maxNumLogFiles = self.maximumNumberOfLogFiles;
-	if (maxNumLogFiles == 0)
-	{
-		// Unlimited - don't delete any log files
-		return;
-	}
-	
-	NSArray *sortedLogFileInfos = [self sortedLogFileInfos];
-	
-	// Do we consider the first file?
-	// We are only supposed to be deleting archived files.
-	// In most cases, the first file is likely the log file that is currently being written to.
-	// So in most cases, we do not want to consider this file for deletion.
-	
-	NSUInteger count = [sortedLogFileInfos count];
-	BOOL excludeFirstFile = NO;
-	
-	if (count > 0)
-	{
-		DDLogFileInfo *logFileInfo = [sortedLogFileInfos objectAtIndex:0];
-		
-		if (!logFileInfo.isArchived)
-		{
-			excludeFirstFile = YES;
-		}
-	}
-	
-	NSArray *sortedArchivedLogFileInfos;
-	if (excludeFirstFile)
-	{
-		count--;
-		sortedArchivedLogFileInfos = [sortedLogFileInfos subarrayWithRange:NSMakeRange(1, count)];
-	}
-	else
-	{
-		sortedArchivedLogFileInfos = sortedLogFileInfos;
-	}
-	
-	NSUInteger i;
-	for (i = maxNumLogFiles; i < count; i++)
-	{
-		DDLogFileInfo *logFileInfo = [sortedArchivedLogFileInfos objectAtIndex:i];
-		
-		NSLogInfo(@"DDLogFileManagerDefault: Deleting file: %@", logFileInfo.fileName);
-		
-		[[NSFileManager defaultManager] removeItemAtPath:logFileInfo.filePath error:nil];
-	}
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark Log Files
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
- * Returns the path to the default logs directory.
- * If the logs directory doesn't exist, this method automatically creates it.
-**/
-- (NSString *)defaultLogsDirectory
-{
-#if TARGET_OS_IPHONE
-	NSArray *paths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES);
-	NSString *baseDir = ([paths count] > 0) ? [paths objectAtIndex:0] : nil;
-	NSString *logsDirectory = [baseDir stringByAppendingPathComponent:@"Logs"];
-    
-#else
-	NSString *appName = [[NSProcessInfo processInfo] processName];
-	NSArray *paths = NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSUserDomainMask, YES);
-	NSString *basePath = ([paths count] > 0) ? [paths objectAtIndex:0] : NSTemporaryDirectory();
-	NSString *logsDirectory = [[basePath stringByAppendingPathComponent:@"Logs"] stringByAppendingPathComponent:appName];
-
-#endif
-
-	return logsDirectory;
-}
-
-- (NSString *)logsDirectory
-{
-	// We could do this check once, during initalization, and not bother again.
-	// But this way the code continues to work if the directory gets deleted while the code is running.
-	
-	if (![[NSFileManager defaultManager] fileExistsAtPath:_logsDirectory])
-	{
-		NSError *err = nil;
-		if (![[NSFileManager defaultManager] createDirectoryAtPath:_logsDirectory
-		                               withIntermediateDirectories:YES attributes:nil error:&err])
-		{
-			NSLogError(@"DDFileLogManagerDefault: Error creating logsDirectory: %@", err);
-		}
-	}
-	
-	return _logsDirectory;
-}
-
-- (BOOL)isLogFile:(NSString *)fileName
-{
-	// A log file has a name like "log-<uuid>.txt", where <uuid> is a HEX-string of 6 characters.
-	// 
-	// For example: log-DFFE99.txt
-	
-	BOOL hasProperPrefix = [fileName hasPrefix:@"log-"];
-	
-	BOOL hasProperLength = [fileName length] >= 10;
-	
-	
-	if (hasProperPrefix && hasProperLength)
-	{
-		NSCharacterSet *hexSet = [NSCharacterSet characterSetWithCharactersInString:@"0123456789ABCDEF"];
-		
-		NSString *hex = [fileName substringWithRange:NSMakeRange(4, 6)];
-		NSString *nohex = [hex stringByTrimmingCharactersInSet:hexSet];
-		
-		if ([nohex length] == 0)
-		{
-			return YES;
-		}
-	}
-	
-	return NO;
-}
-
-/**
- * Returns an array of NSString objects,
- * each of which is the filePath to an existing log file on disk.
-**/
-- (NSArray *)unsortedLogFilePaths
-{
-	NSString *logsDirectory = [self logsDirectory];
-	NSArray *fileNames = [[NSFileManager defaultManager] contentsOfDirectoryAtPath:logsDirectory error:nil];
-	
-	NSMutableArray *unsortedLogFilePaths = [NSMutableArray arrayWithCapacity:[fileNames count]];
-	
-	for (NSString *fileName in fileNames)
-	{
-		// Filter out any files that aren't log files. (Just for extra safety)
-		
-		if ([self isLogFile:fileName])
-		{
-			NSString *filePath = [logsDirectory stringByAppendingPathComponent:fileName];
-			
-			[unsortedLogFilePaths addObject:filePath];
-		}
-	}
-	
-	return unsortedLogFilePaths;
-}
-
-/**
- * Returns an array of NSString objects,
- * each of which is the fileName of an existing log file on disk.
-**/
-- (NSArray *)unsortedLogFileNames
-{
-	NSArray *unsortedLogFilePaths = [self unsortedLogFilePaths];
-	
-	NSMutableArray *unsortedLogFileNames = [NSMutableArray arrayWithCapacity:[unsortedLogFilePaths count]];
-	
-	for (NSString *filePath in unsortedLogFilePaths)
-	{
-		[unsortedLogFileNames addObject:[filePath lastPathComponent]];
-	}
-	
-	return unsortedLogFileNames;
-}
-
-/**
- * Returns an array of DDLogFileInfo objects,
- * each representing an existing log file on disk,
- * and containing important information about the log file such as it's modification date and size.
-**/
-- (NSArray *)unsortedLogFileInfos
-{
-	NSArray *unsortedLogFilePaths = [self unsortedLogFilePaths];
-	
-	NSMutableArray *unsortedLogFileInfos = [NSMutableArray arrayWithCapacity:[unsortedLogFilePaths count]];
-	
-	for (NSString *filePath in unsortedLogFilePaths)
-	{
-		DDLogFileInfo *logFileInfo = [[DDLogFileInfo alloc] initWithFilePath:filePath];
-		
-		[unsortedLogFileInfos addObject:logFileInfo];
-	}
-	
-	return unsortedLogFileInfos;
-}
-
-/**
- * Just like the unsortedLogFilePaths method, but sorts the array.
- * The items in the array are sorted by modification date.
- * The first item in the array will be the most recently modified log file.
-**/
-- (NSArray *)sortedLogFilePaths
-{
-	NSArray *sortedLogFileInfos = [self sortedLogFileInfos];
-	
-	NSMutableArray *sortedLogFilePaths = [NSMutableArray arrayWithCapacity:[sortedLogFileInfos count]];
-	
-	for (DDLogFileInfo *logFileInfo in sortedLogFileInfos)
-	{
-		[sortedLogFilePaths addObject:[logFileInfo filePath]];
-	}
-	
-	return sortedLogFilePaths;
-}
-
-/**
- * Just like the unsortedLogFileNames method, but sorts the array.
- * The items in the array are sorted by modification date.
- * The first item in the array will be the most recently modified log file.
-**/
-- (NSArray *)sortedLogFileNames
-{
-	NSArray *sortedLogFileInfos = [self sortedLogFileInfos];
-	
-	NSMutableArray *sortedLogFileNames = [NSMutableArray arrayWithCapacity:[sortedLogFileInfos count]];
-	
-	for (DDLogFileInfo *logFileInfo in sortedLogFileInfos)
-	{
-		[sortedLogFileNames addObject:[logFileInfo fileName]];
-	}
-	
-	return sortedLogFileNames;
-}
-
-/**
- * Just like the unsortedLogFileInfos method, but sorts the array.
- * The items in the array are sorted by modification date.
- * The first item in the array will be the most recently modified log file.
-**/
-- (NSArray *)sortedLogFileInfos
-{
-	return [[self unsortedLogFileInfos] sortedArrayUsingSelector:@selector(reverseCompareByCreationDate:)];
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark Creation
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
- * Generates a short UUID suitable for use in the log file's name.
- * The result will have six characters, all in the hexadecimal set [0123456789ABCDEF].
-**/
-- (NSString *)generateShortUUID
-{
-	CFUUIDRef uuid = CFUUIDCreate(NULL);
-	
-	CFStringRef fullStr = CFUUIDCreateString(NULL, uuid);
-	NSString *result = (__bridge_transfer NSString *)CFStringCreateWithSubstring(NULL, fullStr, CFRangeMake(0, 6));
-	
-	CFRelease(fullStr);
-	CFRelease(uuid);
-	
-	return result;
-}
-
-/**
- * Generates a new unique log file path, and creates the corresponding log file.
-**/
-- (NSString *)createNewLogFile
-{
-	// Generate a random log file name, and create the file (if there isn't a collision)
-	
-	NSString *logsDirectory = [self logsDirectory];
-	do
-	{
-		NSString *fileName = [NSString stringWithFormat:@"log-%@.txt", [self generateShortUUID]];
-		
-		NSString *filePath = [logsDirectory stringByAppendingPathComponent:fileName];
-		
-		if (![[NSFileManager defaultManager] fileExistsAtPath:filePath])
-		{
-			NSLogVerbose(@"DDLogFileManagerDefault: Creating new log file: %@", fileName);
-			
-			[[NSFileManager defaultManager] createFileAtPath:filePath contents:nil attributes:nil];
-			
-			// Since we just created a new log file, we may need to delete some old log files
-			[self deleteOldLogFiles];
-			
-			return filePath;
-		}
-		
-	} while(YES);
-}
-
-@end
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark -
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-@implementation DDLogFileFormatterDefault
-
-- (id)init
-{
-	return [self initWithDateFormatter:nil];
-}
-
-- (id)initWithDateFormatter:(NSDateFormatter *)aDateFormatter
-{
-	if ((self = [super init]))
-	{
-		if (aDateFormatter)
-		{
-			dateFormatter = aDateFormatter;
-		}
-		else
-		{
-			dateFormatter = [[NSDateFormatter alloc] init];
-			[dateFormatter setFormatterBehavior:NSDateFormatterBehavior10_4]; // 10.4+ style
-			[dateFormatter setDateFormat:@"yyyy/MM/dd HH:mm:ss:SSS"];
-		}
-	}
-	return self;
-}
-
-- (NSString *)formatLogMessage:(DDLogMessage *)logMessage
-{
-	NSString *dateAndTime = [dateFormatter stringFromDate:(logMessage->timestamp)];
-	
-	return [NSString stringWithFormat:@"%@  %@", dateAndTime, logMessage->logMsg];
-}
-
-@end
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark -
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-@implementation DDFileLogger
-
-- (id)init
-{
-	DDLogFileManagerDefault *defaultLogFileManager = [[DDLogFileManagerDefault alloc] init];
-	
-	return [self initWithLogFileManager:defaultLogFileManager];
-}
-
-- (id)initWithLogFileManager:(id <DDLogFileManager>)aLogFileManager
-{
-	if ((self = [super init]))
-	{
-		maximumFileSize = DEFAULT_LOG_MAX_FILE_SIZE;
-		rollingFrequency = DEFAULT_LOG_ROLLING_FREQUENCY;
-		
-		logFileManager = aLogFileManager;
-		
-		formatter = [[DDLogFileFormatterDefault alloc] init];
-	}
-	return self;
-}
-
-- (void)dealloc
-{
-	[currentLogFileHandle synchronizeFile];
-	[currentLogFileHandle closeFile];
-	
-	if (rollingTimer)
-	{
-		dispatch_source_cancel(rollingTimer);
-		dispatch_release(rollingTimer);
-		rollingTimer = NULL;
-	}
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark Properties
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-@synthesize logFileManager;
-
-- (unsigned long long)maximumFileSize
-{
-	// The design of this method is taken from the DDAbstractLogger implementation.
-	// For extensive documentation please refer to the DDAbstractLogger implementation.
-	
-	// Note: The internal implementation should access the maximumFileSize variable directly,
-	// but if we forget to do this, then this method should at least work properly.
-	
-	dispatch_queue_t currentQueue = dispatch_get_current_queue();
-	if (currentQueue == loggerQueue)
-	{
-		return maximumFileSize;
-	}
-	else
-	{
-		dispatch_queue_t loggingQueue = [DDLog loggingQueue];
-		NSAssert(currentQueue != loggingQueue, @"Core architecture requirement failure");
-		
-		__block unsigned long long result;
-		
-		dispatch_sync(loggingQueue, ^{
-			dispatch_sync(loggerQueue, ^{
-				result = maximumFileSize;
-			});
-		});
-		
-		return result;
-	}
-}
-
-- (void)setMaximumFileSize:(unsigned long long)newMaximumFileSize
-{
-	// The design of this method is taken from the DDAbstractLogger implementation.
-	// For documentation please refer to the DDAbstractLogger implementation.
-	
-	dispatch_block_t block = ^{ @autoreleasepool {
-		
-		maximumFileSize = newMaximumFileSize;
-		[self maybeRollLogFileDueToSize];
-		
-	}};
-	
-	dispatch_queue_t currentQueue = dispatch_get_current_queue();
-	if (currentQueue == loggerQueue)
-	{
-		block();
-	}
-	else
-	{
-		dispatch_queue_t loggingQueue = [DDLog loggingQueue];
-		NSAssert(currentQueue != loggingQueue, @"Core architecture requirement failure");
-		
-		dispatch_async(loggingQueue, ^{
-			dispatch_async(loggerQueue, block);
-		});
-	}
-}
-
-- (NSTimeInterval)rollingFrequency
-{
-	// The design of this method is taken from the DDAbstractLogger implementation.
-	// For documentation please refer to the DDAbstractLogger implementation.
-	
-	// Note: The internal implementation should access the rollingFrequency variable directly,
-	// but if we forget to do this, then this method should at least work properly.
-	
-	dispatch_queue_t currentQueue = dispatch_get_current_queue();
-	if (currentQueue == loggerQueue)
-	{
-		return rollingFrequency;
-	}
-	else
-	{
-		dispatch_queue_t loggingQueue = [DDLog loggingQueue];
-		NSAssert(currentQueue != loggingQueue, @"Core architecture requirement failure");
-		
-		__block NSTimeInterval result;
-		
-		dispatch_sync(loggingQueue, ^{
-			dispatch_sync(loggerQueue, ^{
-				result = rollingFrequency;
-			});
-		});
-		
-		return result;
-	}
-}
-
-- (void)setRollingFrequency:(NSTimeInterval)newRollingFrequency
-{
-	// The design of this method is taken from the DDAbstractLogger implementation.
-	// For documentation please refer to the DDAbstractLogger implementation.
-		
-	dispatch_block_t block = ^{ @autoreleasepool {
-		
-		rollingFrequency = newRollingFrequency;
-		[self maybeRollLogFileDueToAge];
-		
-	}};
-	
-	dispatch_queue_t currentQueue = dispatch_get_current_queue();
-	if (currentQueue == loggerQueue)
-	{
-		block();
-	}
-	else
-	{
-		dispatch_queue_t loggingQueue = [DDLog loggingQueue];
-		NSAssert(currentQueue != loggingQueue, @"Core architecture requirement failure");
-		
-		dispatch_async(loggingQueue, ^{
-			dispatch_async(loggerQueue, block);
-		});
-	}
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark File Rolling
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-- (void)scheduleTimerToRollLogFileDueToAge
-{
-	if (rollingTimer)
-	{
-		dispatch_source_cancel(rollingTimer);
-		dispatch_release(rollingTimer);
-		rollingTimer = NULL;
-	}
-	
-	if (currentLogFileInfo == nil || rollingFrequency <= 0.0)
-	{
-		return;
-	}
-	
-	NSDate *logFileCreationDate = [currentLogFileInfo creationDate];
-	
-	NSTimeInterval ti = [logFileCreationDate timeIntervalSinceReferenceDate];
-	ti += rollingFrequency;
-	
-	NSDate *logFileRollingDate = [NSDate dateWithTimeIntervalSinceReferenceDate:ti];
-	
-	NSLogVerbose(@"DDFileLogger: scheduleTimerToRollLogFileDueToAge");
-	
-	NSLogVerbose(@"DDFileLogger: logFileCreationDate: %@", logFileCreationDate);
-	NSLogVerbose(@"DDFileLogger: logFileRollingDate : %@", logFileRollingDate);
-	
-	rollingTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, loggerQueue);
-	
-	dispatch_source_set_event_handler(rollingTimer, ^{ @autoreleasepool {
-		
-		[self maybeRollLogFileDueToAge];
-		
-	}});
-	
-	uint64_t delay = [logFileRollingDate timeIntervalSinceNow] * NSEC_PER_SEC;
-	dispatch_time_t fireTime = dispatch_time(DISPATCH_TIME_NOW, delay);
-	
-	dispatch_source_set_timer(rollingTimer, fireTime, DISPATCH_TIME_FOREVER, 1.0);
-	dispatch_resume(rollingTimer);
-}
-
-- (void)rollLogFile
-{
-	// This method is public.
-	// We need to execute the rolling on our logging thread/queue.
-	// 
-	// The design of this method is taken from the DDAbstractLogger implementation.
-	// For documentation please refer to the DDAbstractLogger implementation.
-	
-	dispatch_block_t block = ^{ @autoreleasepool {
-		
-		[self rollLogFileNow];
-	}};
-	
-	dispatch_queue_t currentQueue = dispatch_get_current_queue();
-	if (currentQueue == loggerQueue)
-	{
-		block();
-	}
-	else
-	{
-		dispatch_queue_t loggingQueue = [DDLog loggingQueue];
-		NSAssert(currentQueue != loggingQueue, @"Core architecture requirement failure");
-		
-		dispatch_async(loggingQueue, ^{
-			dispatch_async(loggerQueue, block);
-		});
-	}
-}
-
-- (void)rollLogFileNow
-{
-	NSLogVerbose(@"DDFileLogger: rollLogFileNow");
-	
-	
-	if (currentLogFileHandle == nil) return;
-	
-	[currentLogFileHandle synchronizeFile];
-	[currentLogFileHandle closeFile];
-	currentLogFileHandle = nil;
-	
-	currentLogFileInfo.isArchived = YES;
-	
-	if ([logFileManager respondsToSelector:@selector(didRollAndArchiveLogFile:)])
-	{
-		[logFileManager didRollAndArchiveLogFile:(currentLogFileInfo.filePath)];
-	}
-	
-	currentLogFileInfo = nil;
-	
-	if (rollingTimer)
-	{
-		dispatch_source_cancel(rollingTimer);
-		dispatch_release(rollingTimer);
-		rollingTimer = NULL;
-	}
-}
-
-- (void)maybeRollLogFileDueToAge
-{
-	if (rollingFrequency > 0.0 && currentLogFileInfo.age >= rollingFrequency)
-	{
-		NSLogVerbose(@"DDFileLogger: Rolling log file due to age...");
-		
-		[self rollLogFileNow];
-	}
-	else
-	{
-		[self scheduleTimerToRollLogFileDueToAge];
-	}
-}
-
-- (void)maybeRollLogFileDueToSize
-{
-	// This method is called from logMessage.
-	// Keep it FAST.
-	
-	// Note: Use direct access to maximumFileSize variable.
-	// We specifically wrote our own getter/setter method to allow us to do this (for performance reasons).
-	
-	if (maximumFileSize > 0)
-	{
-		unsigned long long fileSize = [currentLogFileHandle offsetInFile];
-		
-		if (fileSize >= maximumFileSize)
-		{
-			NSLogVerbose(@"DDFileLogger: Rolling log file due to size (%qu)...", fileSize);
-			
-			[self rollLogFileNow];
-		}
-	}
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark File Logging
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
- * Returns the log file that should be used.
- * If there is an existing log file that is suitable,
- * within the constraints of maximumFileSize and rollingFrequency, then it is returned.
- * 
- * Otherwise a new file is created and returned.
-**/
-- (DDLogFileInfo *)currentLogFileInfo
-{
-	if (currentLogFileInfo == nil)
-	{
-		NSArray *sortedLogFileInfos = [logFileManager sortedLogFileInfos];
-		
-		if ([sortedLogFileInfos count] > 0)
-		{
-			DDLogFileInfo *mostRecentLogFileInfo = [sortedLogFileInfos objectAtIndex:0];
-			
-			BOOL useExistingLogFile = YES;
-			BOOL shouldArchiveMostRecent = NO;
-			
-			if (mostRecentLogFileInfo.isArchived)
-			{
-				useExistingLogFile = NO;
-				shouldArchiveMostRecent = NO;
-			}
-			else if (maximumFileSize > 0 && mostRecentLogFileInfo.fileSize >= maximumFileSize)
-			{
-				useExistingLogFile = NO;
-				shouldArchiveMostRecent = YES;
-			}
-			else if (rollingFrequency > 0.0 && mostRecentLogFileInfo.age >= rollingFrequency)
-			{
-				useExistingLogFile = NO;
-				shouldArchiveMostRecent = YES;
-			}
-			
-			if (useExistingLogFile)
-			{
-				NSLogVerbose(@"DDFileLogger: Resuming logging with file %@", mostRecentLogFileInfo.fileName);
-				
-				currentLogFileInfo = mostRecentLogFileInfo;
-			}
-			else
-			{
-				if (shouldArchiveMostRecent)
-				{
-					mostRecentLogFileInfo.isArchived = YES;
-					
-					if ([logFileManager respondsToSelector:@selector(didArchiveLogFile:)])
-					{
-						[logFileManager didArchiveLogFile:(mostRecentLogFileInfo.filePath)];
-					}
-				}
-			}
-		}
-		
-		if (currentLogFileInfo == nil)
-		{
-			NSString *currentLogFilePath = [logFileManager createNewLogFile];
-			
-			currentLogFileInfo = [[DDLogFileInfo alloc] initWithFilePath:currentLogFilePath];
-		}
-	}
-	
-	return currentLogFileInfo;
-}
-
-- (NSFileHandle *)currentLogFileHandle
-{
-	if (currentLogFileHandle == nil)
-	{
-		NSString *logFilePath = [[self currentLogFileInfo] filePath];
-		
-		currentLogFileHandle = [NSFileHandle fileHandleForWritingAtPath:logFilePath];
-		[currentLogFileHandle seekToEndOfFile];
-		
-		if (currentLogFileHandle)
-		{
-			[self scheduleTimerToRollLogFileDueToAge];
-		}
-	}
-	
-	return currentLogFileHandle;
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark DDLogger Protocol
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-- (void)logMessage:(DDLogMessage *)logMessage
-{
-	NSString *logMsg = logMessage->logMsg;
-	
-	if (formatter)
-	{
-		logMsg = [formatter formatLogMessage:logMessage];
-	}
-	
-	if (logMsg)
-	{
-		if (![logMsg hasSuffix:@"\n"])
-		{
-			logMsg = [logMsg stringByAppendingString:@"\n"];
-		}
-		
-		NSData *logData = [logMsg dataUsingEncoding:NSUTF8StringEncoding];
-		
-		[[self currentLogFileHandle] writeData:logData];
-		
-		[self maybeRollLogFileDueToSize];
-	}
-}
-
-- (void)willRemoveLogger
-{
-	// If you override me be sure to invoke [super willRemoveLogger];
-	
-	[self rollLogFileNow];
-}
-
-- (NSString *)loggerName
-{
-	return @"cocoa.lumberjack.fileLogger";
-}
-
-@end
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark -
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-#if TARGET_IPHONE_SIMULATOR
-  #define XATTR_ARCHIVED_NAME  @"archived"
-#else
-  #define XATTR_ARCHIVED_NAME  @"lumberjack.log.archived"
-#endif
-
-@implementation DDLogFileInfo
-
-@synthesize filePath;
-
-@dynamic fileName;
-@dynamic fileAttributes;
-@dynamic creationDate;
-@dynamic modificationDate;
-@dynamic fileSize;
-@dynamic age;
-
-@dynamic isArchived;
-
-
-#pragma mark Lifecycle
-
-+ (id)logFileWithPath:(NSString *)aFilePath
-{
-	return [[DDLogFileInfo alloc] initWithFilePath:aFilePath];
-}
-
-- (id)initWithFilePath:(NSString *)aFilePath
-{
-	if ((self = [super init]))
-	{
-		filePath = [aFilePath copy];
-	}
-	return self;
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark Standard Info
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-- (NSDictionary *)fileAttributes
-{
-	if (fileAttributes == nil)
-	{
-		fileAttributes = [[NSFileManager defaultManager] attributesOfItemAtPath:filePath error:nil];
-	}
-	return fileAttributes;
-}
-
-- (NSString *)fileName
-{
-	if (fileName == nil)
-	{
-		fileName = [filePath lastPathComponent];
-	}
-	return fileName;
-}
-
-- (NSDate *)modificationDate
-{
-	if (modificationDate == nil)
-	{
-		modificationDate = [[self fileAttributes] objectForKey:NSFileModificationDate];
-	}
-	
-	return modificationDate;
-}
-
-- (NSDate *)creationDate
-{
-	if (creationDate == nil)
-	{
-	
-	#if TARGET_OS_IPHONE
-	
-		const char *path = [filePath UTF8String];
-		
-		struct attrlist attrList;
-		memset(&attrList, 0, sizeof(attrList));
-		attrList.bitmapcount = ATTR_BIT_MAP_COUNT;
-		attrList.commonattr = ATTR_CMN_CRTIME;
-		
-		struct {
-			u_int32_t attrBufferSizeInBytes;
-			struct timespec crtime;
-		} attrBuffer;
-		
-		int result = getattrlist(path, &attrList, &attrBuffer, sizeof(attrBuffer), 0);
-		if (result == 0)
-		{
-			double seconds = (double)(attrBuffer.crtime.tv_sec);
-			double nanos   = (double)(attrBuffer.crtime.tv_nsec);
-			
-			NSTimeInterval ti = seconds + (nanos / 1000000000.0);
-			
-			creationDate = [NSDate dateWithTimeIntervalSince1970:ti];
-		}
-		else
-		{
-			NSLogError(@"DDLogFileInfo: creationDate(%@): getattrlist result = %i", self.fileName, result);
-		}
-		
-	#else
-		
-		creationDate = [[self fileAttributes] objectForKey:NSFileCreationDate];
-		
-	#endif
-		
-	}
-	return creationDate;
-}
-
-- (unsigned long long)fileSize
-{
-	if (fileSize == 0)
-	{
-		fileSize = [[[self fileAttributes] objectForKey:NSFileSize] unsignedLongLongValue];
-	}
-	
-	return fileSize;
-}
-
-- (NSTimeInterval)age
-{
-	return [[self creationDate] timeIntervalSinceNow] * -1.0;
-}
-
-- (NSString *)description
-{
-	return [[NSDictionary dictionaryWithObjectsAndKeys:
-		self.filePath, @"filePath",
-		self.fileName, @"fileName",
-		self.fileAttributes, @"fileAttributes",
-		self.creationDate, @"creationDate",
-		self.modificationDate, @"modificationDate",
-		[NSNumber numberWithUnsignedLongLong:self.fileSize], @"fileSize",
-		[NSNumber numberWithDouble:self.age], @"age",
-		[NSNumber numberWithBool:self.isArchived], @"isArchived",
-	nil] description];
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark Archiving
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-- (BOOL)isArchived
-{
-	
-#if TARGET_IPHONE_SIMULATOR
-	
-	// Extended attributes don't work properly on the simulator.
-	// So we have to use a less attractive alternative.
-	// See full explanation in the header file.
-	
-	return [self hasExtensionAttributeWithName:XATTR_ARCHIVED_NAME];
-	
-#else
-	
-	return [self hasExtendedAttributeWithName:XATTR_ARCHIVED_NAME];
-	
-#endif
-}
-
-- (void)setIsArchived:(BOOL)flag
-{
-	
-#if TARGET_IPHONE_SIMULATOR
-	
-	// Extended attributes don't work properly on the simulator.
-	// So we have to use a less attractive alternative.
-	// See full explanation in the header file.
-	
-	if (flag)
-		[self addExtensionAttributeWithName:XATTR_ARCHIVED_NAME];
-	else
-		[self removeExtensionAttributeWithName:XATTR_ARCHIVED_NAME];
-	
-#else
-	
-	if (flag)
-		[self addExtendedAttributeWithName:XATTR_ARCHIVED_NAME];
-	else
-		[self removeExtendedAttributeWithName:XATTR_ARCHIVED_NAME];
-	
-#endif
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark Changes
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-- (void)reset
-{
-	fileName = nil;
-	fileAttributes = nil;
-	creationDate = nil;
-	modificationDate = nil;
-}
-
-- (void)renameFile:(NSString *)newFileName
-{
-	// This method is only used on the iPhone simulator, where normal extended attributes are broken.
-	// See full explanation in the header file.
-	
-	if (![newFileName isEqualToString:[self fileName]])
-	{
-		NSString *fileDir = [filePath stringByDeletingLastPathComponent];
-		
-		NSString *newFilePath = [fileDir stringByAppendingPathComponent:newFileName];
-		
-		NSLogVerbose(@"DDLogFileInfo: Renaming file: '%@' -> '%@'", self.fileName, newFileName);
-		
-		NSError *error = nil;
-		if (![[NSFileManager defaultManager] moveItemAtPath:filePath toPath:newFilePath error:&error])
-		{
-			NSLogError(@"DDLogFileInfo: Error renaming file (%@): %@", self.fileName, error);
-		}
-		
-		filePath = newFilePath;
-		[self reset];
-	}
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark Attribute Management
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-#if TARGET_IPHONE_SIMULATOR
-
-// Extended attributes don't work properly on the simulator.
-// So we have to use a less attractive alternative.
-// See full explanation in the header file.
-
-- (BOOL)hasExtensionAttributeWithName:(NSString *)attrName
-{
-	// This method is only used on the iPhone simulator, where normal extended attributes are broken.
-	// See full explanation in the header file.
-	
-	// Split the file name into components.
-	// 
-	// log-ABC123.archived.uploaded.txt
-	// 
-	// 0. log-ABC123
-	// 1. archived
-	// 2. uploaded
-	// 3. txt
-	// 
-	// So we want to search for the attrName in the components (ignoring the first and last array indexes).
-	
-	NSArray *components = [[self fileName] componentsSeparatedByString:@"."];
-	
-	// Watch out for file names without an extension
-	
-	NSUInteger count = [components count];
-	NSUInteger max = (count >= 2) ? count-1 : count;
-	
-	NSUInteger i;
-	for (i = 1; i < max; i++)
-	{
-		NSString *attr = [components objectAtIndex:i];
-		
-		if ([attrName isEqualToString:attr])
-		{
-			return YES;
-		}
-	}
-	
-	return NO;
-}
-
-- (void)addExtensionAttributeWithName:(NSString *)attrName
-{
-	// This method is only used on the iPhone simulator, where normal extended attributes are broken.
-	// See full explanation in the header file.
-	
-	if ([attrName length] == 0) return;
-	
-	// Example:
-	// attrName = "archived"
-	// 
-	// "log-ABC123.txt" -> "log-ABC123.archived.txt"
-	
-	NSArray *components = [[self fileName] componentsSeparatedByString:@"."];
-	
-	NSUInteger count = [components count];
-	
-	NSUInteger estimatedNewLength = [[self fileName] length] + [attrName length] + 1;
-	NSMutableString *newFileName = [NSMutableString stringWithCapacity:estimatedNewLength];
-	
-	if (count > 0)
-	{
-		[newFileName appendString:[components objectAtIndex:0]];
-	}
-	
-	NSString *lastExt = @"";
-	
-	NSUInteger i;
-	for (i = 1; i < count; i++)
-	{
-		NSString *attr = [components objectAtIndex:i];
-		if ([attr length] == 0)
-		{
-			continue;
-		}
-		
-		if ([attrName isEqualToString:attr])
-		{
-			// Extension attribute already exists in file name
-			return;
-		}
-		
-		if ([lastExt length] > 0)
-		{
-			[newFileName appendFormat:@".%@", lastExt];
-		}
-		
-		lastExt = attr;
-	}
-	
-	[newFileName appendFormat:@".%@", attrName];
-	
-	if ([lastExt length] > 0)
-	{
-		[newFileName appendFormat:@".%@", lastExt];
-	}
-	
-	[self renameFile:newFileName];
-}
-
-- (void)removeExtensionAttributeWithName:(NSString *)attrName
-{
-	// This method is only used on the iPhone simulator, where normal extended attributes are broken.
-	// See full explanation in the header file.
-	
-	if ([attrName length] == 0) return;
-	
-	// Example:
-	// attrName = "archived"
-	// 
-	// "log-ABC123.txt" -> "log-ABC123.archived.txt"
-	
-	NSArray *components = [[self fileName] componentsSeparatedByString:@"."];
-	
-	NSUInteger count = [components count];
-	
-	NSUInteger estimatedNewLength = [[self fileName] length];
-	NSMutableString *newFileName = [NSMutableString stringWithCapacity:estimatedNewLength];
-	
-	if (count > 0)
-	{
-		[newFileName appendString:[components objectAtIndex:0]];
-	}
-	
-	BOOL found = NO;
-	
-	NSUInteger i;
-	for (i = 1; i < count; i++)
-	{
-		NSString *attr = [components objectAtIndex:i];
-		
-		if ([attrName isEqualToString:attr])
-		{
-			found = YES;
-		}
-		else
-		{
-			[newFileName appendFormat:@".%@", attr];
-		}
-	}
-	
-	if (found)
-	{
-		[self renameFile:newFileName];
-	}
-}
-
-#else
-
-- (BOOL)hasExtendedAttributeWithName:(NSString *)attrName
-{
-	const char *path = [filePath UTF8String];
-	const char *name = [attrName UTF8String];
-	
-	ssize_t result = getxattr(path, name, NULL, 0, 0, 0);
-	
-	return (result >= 0);
-}
-
-- (void)addExtendedAttributeWithName:(NSString *)attrName
-{
-	const char *path = [filePath UTF8String];
-	const char *name = [attrName UTF8String];
-	
-	int result = setxattr(path, name, NULL, 0, 0, 0);
-	
-	if (result < 0)
-	{
-		NSLogError(@"DDLogFileInfo: setxattr(%@, %@): error = %i", attrName, self.fileName, result);
-	}
-}
-
-- (void)removeExtendedAttributeWithName:(NSString *)attrName
-{
-	const char *path = [filePath UTF8String];
-	const char *name = [attrName UTF8String];
-	
-	int result = removexattr(path, name, 0);
-	
-	if (result < 0 && errno != ENOATTR)
-	{
-		NSLogError(@"DDLogFileInfo: removexattr(%@, %@): error = %i", attrName, self.fileName, result);
-	}
-}
-
-#endif
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark Comparisons
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-- (BOOL)isEqual:(id)object
-{
-	if ([object isKindOfClass:[self class]])
-	{
-		DDLogFileInfo *another = (DDLogFileInfo *)object;
-		
-		return [filePath isEqualToString:[another filePath]];
-	}
-	
-	return NO;
-}
-
-- (NSComparisonResult)reverseCompareByCreationDate:(DDLogFileInfo *)another
-{
-	NSDate *us = [self creationDate];
-	NSDate *them = [another creationDate];
-	
-	NSComparisonResult result = [us compare:them];
-	
-	if (result == NSOrderedAscending)
-		return NSOrderedDescending;
-	
-	if (result == NSOrderedDescending)
-		return NSOrderedAscending;
-	
-	return NSOrderedSame;
-}
-
-- (NSComparisonResult)reverseCompareByModificationDate:(DDLogFileInfo *)another
-{
-	NSDate *us = [self modificationDate];
-	NSDate *them = [another modificationDate];
-	
-	NSComparisonResult result = [us compare:them];
-	
-	if (result == NSOrderedAscending)
-		return NSOrderedDescending;
-	
-	if (result == NSOrderedDescending)
-		return NSOrderedAscending;
-	
-	return NSOrderedSame;
-}
-
-@end