objectSerializer.swift

    public static func ObjectMapperSerializer<T: Mappable, E: APIError>(keyPath: String?, mapToObject object: T? = nil, typeOfError errorType: E.Type) -> ResponseSerializer<T, NSError> {
        return ResponseSerializer { request, response, data, error in
            guard error == nil else {
                return .Failure(error!)
            }
            
            guard let _ = data else {
                let failureReason = "Data could not be serialized. Input data was nil."
                let error = newError(.DataSerializationError, failureReason: failureReason)
                return .Failure(error)
            }
            
            guard let response = response else {
                return .Failure(defaultError())
            }
            
            let JSONResponseSerializer = Request.JSONResponseSerializer(options: .AllowFragments)
            let result = JSONResponseSerializer.serializeResponse(request, response, data, error)
            
            let JSONToMap: AnyObject?
            if let keyPath = keyPath where keyPath.isEmpty == false {
                JSONToMap = result.value?.valueForKeyPath(keyPath)
            } else {
                JSONToMap = result.value
            }
            
            switch response.statusCode {
            case 200..<400:
                break
            default:
                if let errorParsed = Mapper<E>().map(JSONToMap) {
                    let failureReason = errorParsed.message
                    let error = newError(.EndpointError, failureReason:
                        failureReason ?? DefaultErrorMessage)
                    return .Failure(error)
                }
            }
            
            if let object = object {
                Mapper<T>().map(JSONToMap, toObject: object)
                return .Success(object)
            } else if let parsedObject = Mapper<T>().map(JSONToMap){
                return .Success(parsedObject)
            }
            
            return .Failure(defaultError())
        }
    }
    
    public func responseObject<T: Mappable, E: APIError>(queue queue: dispatch_queue_t? = nil, keyPath: String? = nil, mapToObject object: T? = nil, typeOfError errorType: E.Type, completionHandler: Response<T, NSError> -> Void) -> Self {
        return response(queue: queue, responseSerializer: Request.ObjectMapperSerializer(keyPath, mapToObject: object, typeOfError: errorType), completionHandler: completionHandler)
    }