         }
         return keyPath.description(separator: keyPathSeparator)
     }
-
+    
 }
 
 
 // MARK: - Log Levels
 
 /**
-You can assign an *importance* or *severity* to an event corresponding to one of the following *log levels*:
-
-- **Critical:** Events that are unexpected and can cause serious problems. You would want to be called in the middle of the night to deal with these.
-- **Error:** Events that are unexpected and not handled by your software. Someone should tell you about these ASAP.
-- **Warning:** Events that are unexpected, but will probably not affect the runtime of your software. You would want to investigate these eventually.
-- **Info:** General events that document the software's lifecycle.
-- **Debug:** Events to give you an understanding about the flow through your software, mainly for debugging purposes.
-- **Verbose:** Detailed information about the environment to provide additional context when needed.
-
-The logger that handles the event has a log level as well. **If the event's log level is lower than the logger's, it will not be logged.**
-
-In addition to the log levels above, a logger can have one of the following log levels. Assigning these to events only makes sense in specific use cases.
-
-- **All:** All events will be logged.
-- **Off:** No events will be logged.
-*/
+ You can assign an *importance* or *severity* to an event corresponding to one of the following *log levels*:
+ 
+ - **Critical:** Events that are unexpected and can cause serious problems. You would want to be called in the middle of the night to deal with these.
+ - **Error:** Events that are unexpected and not handled by your software. Someone should tell you about these ASAP.
+ - **Warning:** Events that are unexpected, but will probably not affect the runtime of your software. You would want to investigate these eventually.
+ - **Info:** General events that document the software's lifecycle.
+ - **Debug:** Events to give you an understanding about the flow through your software, mainly for debugging purposes.
+ - **Verbose:** Detailed information about the environment to provide additional context when needed.
+ 
+ The logger that handles the event has a log level as well. **If the event's log level is lower than the logger's, it will not be logged.**
+ 
+ In addition to the log levels above, a logger can have one of the following log levels. Assigning these to events only makes sense in specific use cases.
+ 
+ - **All:** All events will be logged.
+ - **Off:** No events will be logged.
+ */
 public enum LogLevel: Int, CustomStringConvertible, Comparable {
-
+    
     case All = 0, Verbose, Debug, Info, Warning, Error, Critical, Off
-
+    
     public var description: String {
         switch self {
-            case .All: return "All"
-            case .Verbose: return "Verbose"
-            case .Debug: return "Debug"
-            case .Info: return "Info"
-            case .Warning: return "Warning"
-            case .Error: return "Error"
-            case .Critical: return "Critical"
-            case .Off: return "Off"
+        case .All: return "All"
+        case .Verbose: return "Verbose"
+        case .Debug: return "Debug"
+        case .Info: return "Info"
+        case .Warning: return "Warning"
+        case .Error: return "Error"
+        case .Critical: return "Critical"
+        case .Off: return "Off"
         }
     }
     

    
    // TODO: log "Tic..." message by default
    /**
    Log the given event and start tracking the time until the next call to `toc:`.

    - parameter message: The message to be logged, provided by an autoclosure for lazy evaluation (see `log:forLevel:`)
    - parameter logLevel: The event's log level (see `log:forLevel:`)
    - parameter timerKey: Provide as an identifier in nested calls to `tic:` and `toc:`.
    */
    public func tic<M>(@autoclosure(escaping) andLog message: () -> M, forLevel logLevel: LogLevel? = nil, timerKey: String? = nil, function: String = #function, file: String = #file, line: Int = #line)
    {
        if let timerKey = timerKey {
            startDates[timerKey] = NSDate()
        } else {
            defaultStartDate = NSDate()
        }
        self.log(message, forLevel: logLevel, function: function, file: file, line: line)
    }
    
    // TODO: log "...Toc" message by default
    /// When called after a preceding call to `tic:`, the elapsed time between both calls will be appended to the record. See `tic:` for documentation and usage of the `timerKey` parameter in nested calls to `tic:` and `toc:`.
    public func toc<M>(@autoclosure(escaping) andLog message: () -> M, forLevel logLevel: LogLevel? = nil, timerKey: String? = nil, function: String = #function, file: String = #file, line: Int = #line)
    {
        var startDate: NSDate?
        if let timerKey = timerKey {

            }
        }
    }
    
    
    // MARK: Logging
    
    /**
     Logs the event given by its `message` and additional information that is gathered automatically. The `logLevel` parameter in conjunction with the logger's `effectiveLogLevel` determines, if the event will be handled or ignored.
     
     - parameter message: The message to be logged, provided by an autoclosure. The closure will not be evaluated if the event is not going to be emitted, so it can contain expensive operations only needed for logging purposes.
     - parameter logLevel: If the event's log level is lower than the receiving logger's `effectiveLogLevel`, the event will not be logged. The event will always be logged, if no log level is provided for either the event or the logger's `effectiveLogLevel`.
     */
    public func log<M>(@autoclosure(escaping) message: () -> M, error: ErrorType? = nil, forLevel logLevel: LogLevel? = nil, function: String = #function, file: String = #file, line: Int = #line)
    {
        let event = Event(logger: self, message: message, error: error, logLevel: logLevel, date: NSDate(), elapsedTime: nil, function: function, file: file, line: line)
