motion-logger 0.1.0

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

@@ -0,0 +1,49 @@
+#import <Foundation/Foundation.h>
+
+#import "DDLog.h"
+
+/**
+ * Welcome to Cocoa Lumberjack!
+ * 
+ * The project page has a wealth of documentation if you have any questions.
+ * https://github.com/robbiehanson/CocoaLumberjack
+ * 
+ * If you're new to the project you may wish to read the "Getting Started" wiki.
+ * https://github.com/robbiehanson/CocoaLumberjack/wiki/GettingStarted
+ * 
+ * 
+ * This class provides a logger for Terminal output or Xcode console output,
+ * depending on where you are running your code.
+ * 
+ * As described in the "Getting Started" page,
+ * the traditional NSLog() function directs it's output to two places:
+ * 
+ * - Apple System Log (so it shows up in Console.app)
+ * - StdErr (if stderr is a TTY, so log statements show up in Xcode console)
+ * 
+ * To duplicate NSLog() functionality you can simply add this logger and an asl logger.
+ * However, if you instead choose to use file logging (for faster performance),
+ * you may choose to use only a file logger and a tty logger.
+**/
+
+@interface DDTTYLogger : DDAbstractLogger <DDLogger>
+{
+	BOOL isaTTY;
+	
+	NSDateFormatter *dateFormatter;
+	
+	char *app; // Not null terminated
+	char *pid; // Not null terminated
+	
+	size_t appLen;
+	size_t pidLen;
+}
+
++ (DDTTYLogger *)sharedInstance;
+
+// Inherited from DDAbstractLogger
+
+// - (id <DDLogFormatter>)logFormatter;
+// - (void)setLogFormatter:(id <DDLogFormatter>)formatter;
+
+@end

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

@@ -0,0 +1,186 @@
+#import "DDTTYLogger.h"
+
+#import <unistd.h>
+#import <sys/uio.h>
+
+/**
+ * Welcome to Cocoa Lumberjack!
+ * 
+ * The project page has a wealth of documentation if you have any questions.
+ * https://github.com/robbiehanson/CocoaLumberjack
+ * 
+ * If you're new to the project you may wish to read the "Getting Started" wiki.
+ * https://github.com/robbiehanson/CocoaLumberjack/wiki/GettingStarted
+**/
+
+#if ! __has_feature(objc_arc)
+#warning This file must be compiled with ARC. Use -fobjc-arc flag (or convert project to ARC).
+#endif
+
+
+@implementation DDTTYLogger
+
+static DDTTYLogger *sharedInstance;
+
+/**
+ * The runtime sends initialize to each class in a program exactly one time just before the class,
+ * or any class that inherits from it, is sent its first message from within the program. (Thus the
+ * method may never be invoked if the class is not used.) The runtime sends the initialize message to
+ * classes in a thread-safe manner. Superclasses receive this message before their subclasses.
+ *
+ * This method may also be called directly (assumably by accident), hence the safety mechanism.
+**/
++ (void)initialize
+{
+	static BOOL initialized = NO;
+	if (!initialized)
+	{
+		initialized = YES;
+		
+		sharedInstance = [[DDTTYLogger alloc] init];
+	}
+}
+
++ (DDTTYLogger *)sharedInstance
+{
+	return sharedInstance;
+}
+
+- (id)init
+{
+	if (sharedInstance != nil)
+	{
+		return nil;
+	}
+	
+	if ((self = [super init]))
+	{
+		isaTTY = isatty(STDERR_FILENO);
+		
+		if (isaTTY)
+		{
+			dateFormatter = [[NSDateFormatter alloc] init];
+			[dateFormatter setFormatterBehavior:NSDateFormatterBehavior10_4];
+			[dateFormatter setDateFormat:@"yyyy-MM-dd HH:mm:ss:SSS"];
+			
+			// Initialze 'app' variable (char *)
+			
+			NSString *appNStr = [[NSProcessInfo processInfo] processName];
+			const char *appCStr = [appNStr UTF8String];
+			
+			appLen = strlen(appCStr);
+			
+			app = (char *)malloc(appLen);
+			strncpy(app, appCStr, appLen); // Not null terminated
+			
+			// Initialize 'pid' variable (char *)
+			
+			NSString *pidNStr = [NSString stringWithFormat:@"%i", (int)getpid()];
+			const char *pidCStr = [pidNStr UTF8String];
+			
+			pidLen = strlen(pidCStr);
+			
+			pid = (char *)malloc(pidLen);
+			strncpy(pid, pidCStr, pidLen); // Not null terminated
+		}
+	}
+	return self;
+}
+
+- (void)logMessage:(DDLogMessage *)logMessage
+{
+	if (!isaTTY) return;
+	
+	NSString *logMsg = logMessage->logMsg;
+	BOOL isFormatted = NO;
+	
+	if (formatter)
+	{
+		logMsg = [formatter formatLogMessage:logMessage];
+		isFormatted = logMsg != logMessage->logMsg;
+	}
+	
+	if (logMsg)
+	{
+		const char *msg = [logMsg UTF8String];
+		size_t msgLen = strlen(msg);
+		
+		if (isFormatted)
+		{
+			struct iovec v[2];
+			
+			v[0].iov_base = (char *)msg;
+			v[0].iov_len = msgLen;
+			
+			v[1].iov_base = "\n";
+			v[1].iov_len = (msg[msgLen] == '\n') ? 0 : 1;
+			
+			writev(STDERR_FILENO, v, 2);
+		}
+		else
+		{
+			// The following is a highly optimized verion of file output to std err.
+			
+			// ts = timestamp
+			
+			NSString *tsNStr = [dateFormatter stringFromDate:(logMessage->timestamp)];
+			
+			const char *tsCStr = [tsNStr UTF8String];
+			size_t tsLen = strlen(tsCStr);
+			
+			// tid = thread id
+			// 
+			// How many characters do we need for the thread id?
+			// logMessage->machThreadID is of type mach_port_t, which is an unsigned int.
+			// 
+			// 1 hex char = 4 bits
+			// 8 hex chars for 32 bit, plus ending '\0' = 9
+			
+			char tidCStr[9];
+			int tidLen = snprintf(tidCStr, 9, "%x", logMessage->machThreadID);
+			
+			// Here is our format: "%s %s[%i:%s] %s", timestamp, appName, processID, threadID, logMsg
+			
+			struct iovec v[10];
+			
+			v[0].iov_base = (char *)tsCStr;
+			v[0].iov_len = tsLen;
+			
+			v[1].iov_base = " ";
+			v[1].iov_len = 1;
+			
+			v[2].iov_base = app;
+			v[2].iov_len = appLen;
+			
+			v[3].iov_base = "[";
+			v[3].iov_len = 1;
+			
+			v[4].iov_base = pid;
+			v[4].iov_len = pidLen;
+			
+			v[5].iov_base = ":";
+			v[5].iov_len = 1;
+			
+			v[6].iov_base = tidCStr;
+			v[6].iov_len = MIN((size_t)8, tidLen); // snprintf doesn't return what you might think
+			
+			v[7].iov_base = "] ";
+			v[7].iov_len = 2;
+			
+			v[8].iov_base = (char *)msg;
+			v[8].iov_len = msgLen;
+			
+			v[9].iov_base = "\n";
+			v[9].iov_len = (msg[msgLen] == '\n') ? 0 : 1;
+			
+			writev(STDERR_FILENO, v, 10);
+		}
+	}
+}
+
+- (NSString *)loggerName
+{
+	return @"cocoa.lumberjack.ttyLogger";
+}
+
+@end

data/vendor/Pods/CocoaLumberjack/README.markdown

@@ -0,0 +1,37 @@
+### Lumberjack is Fast & Simple, yet Powerful & Flexible.
+
+It is similar in concept to other popular logging frameworks such as log4j, yet is designed specifically for Objective-C, and takes advantage of features such as multi-threading, grand central dispatch (if available), lockless atomic operations, and the dynamic nature of the Objective-C runtime.
+
+### Lumberjack is Fast
+
+In most cases it is an order of magnitude faster than NSLog.
+
+### Lumberjack is Simple
+
+It takes as little as a single line of code to configure lumberjack when your application launches. Then simply replace your NSLog statements with DDLog statements and that's about it. (And the DDLog macros have the exact same format and syntax as NSLog, so it's super easy.)
+
+### Lumberjack is Powerful:
+
+One log statement can be sent to multiple loggers, meaning you can log to a file and the console simultaneously. Want more? Create your own loggers (it's easy) and send your log statements over the network. Or to a database or distributed file system. The sky is the limit.
+
+### Lumberjack is Flexible:
+
+Configure your logging however you want. Change log levels per file (perfect for debugging). Change log levels per logger (verbose console, but concise log file). Change log levels per xcode configuration (verbose debug, but concise release). Have your log statements compiled out of the release build. Customize the number of log levels for your application. Add your own fine-grained logging. Dynamically change log levels during runtime. Choose how & when you want your log files to be rolled. Upload your log files to a central server. Compress archived log files to save disk space...
+
+<br/>
+This framework is for you if:
+
+-   You're looking for a way to track down that impossible-to-reproduce bug that keeps popping up in the field.
+-   You're frustrated with the super short console log on the iPhone.
+-   You're looking to take your application to the next level in terms of support and stability.
+-   You're looking for an enterprise level logging solution for your application (Mac or iPhone).
+
+<br/>
+**[Get started using Lumberjack](https://github.com/robbiehanson/CocoaLumberjack/wiki/GettingStarted)**<br/>
+**[Learn more about Lumberjack](https://github.com/robbiehanson/CocoaLumberjack/wiki)**<br/>
+
+<br/>
+Can't find the answer to your question in any of the [wiki](https://github.com/robbiehanson/CocoaLumberjack/wiki) articles? Try the **[mailing list](http://groups.google.com/group/cocoalumberjack)**.
+<br/>
+<br/>
+Love the project? Wanna buy me a coffee? (or a beer :D) [![donation](http://www.paypal.com/en_US/i/btn/btn_donate_SM.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=RW6R9U4ZWWZ8C)

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

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

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

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