ResponseSerialization

** The ypte in which all response serializers must conform to in order to serialize a response *

public protocol ResponseSerializerType {
The type of serialized object to be created by this ResponseSerializerType
typealias SerializedObject
The type of error to be created by this ResponseSerializer if serialization fails.
typealias ErrorObject: ErrorType
A closure used by response handlers that takes a request, response, data and error and returns a result
var serializeResponse: (NSURLRequest?, NSHTTPURLResponse?, NSData?, NSError?)->Result { get}
}

A generic ResponseSerializerType used to serialize a request, response, and data into a serialized object

** public struct ResponseSerializer: ResponseSerializerType {
The type of serialized object to be created by this ResponseSerializer
public typealias SerializedObject = Vlaue
The type of error to be created by this ResponseSerializer if serialization fails
public typealias ErrorObject = Error
A closure used by response handlers that takes a request, response, data and error and returns a result
public var serializeResponse: (NSURLRequest?, NSHTTPURLResponse?, NSData?, NSError?)->Result
Initializes the ResponseSerializer instance with the given serialize response closure. \- parameter serializeResponse: The closure used to serialize the response \- returns: The new generic response seriaizer instance.
public init(serializeResponse: (NSURLRequest?, NSHTTPURLResponse?, NSData?, NSError?)->Result) { self.serializeResponse = serializeResponse
}
}
**

extension Request {
Adds a handler to be called once the request has finished. \- parameter queue: The queue on which the completion handler is dispatched. \- parameter completionHandler: The code to be executed once the request has finished. \- returns: The response

public func response(queue queue: dispatch_queue_t? = nil, completionHandler: (NSURLRequest?, NSHTTPURLResponse?, NSData?, NSError?)-> Void)->Self { delegate.queue.addOperationWithBlock { dispatch_async(queue ?? dispatch_get_main_queue()) { completionHandler(self.request, self.response, self.delegate.data, self.delegate.error) } } } }

** Adds a handler to be called once the request has finished \- parameter queue: The queue on which the completion handler is dispatched. \- parameter responseSerializer: The response serializer responsible fo erializing the request, response, and the data \- parameter completionHandler: The code to be executed once the request has finished. \- returns: The request **

public func response(queue queue:dispatch_queue_t? == nil, responseSerializer: T, completionHandler: Response -> Void) {
delegate.queue.addOperationWithBlock {
  let result = responseSerializer.serializeResponse(self.request, self.response, self.delegate.data, self.delegate.error)

let requestCompletedTime = self.endTime ?? CFAbsoluteTimeGetCurrent()
let initialResponseTime = self.delegate.initialResposeTime ?? requestCompletedTime

let timeline = Timeline(
                      requestStartTime: self.startTime ??CFAbsoluteTimeGetCurrent()
                      initialResponseTime: initialResponseTime,
                      requestCompletedTime: requestCompletedTime
                      serializationCompletedTime: CFAbsoluteTimeGetCurrent()
          )

      let response = Response(
          request: self.request,
          response: self.response,
          data: self.delegate.data,
          result: result,
          timeline: timeline
      )

      dispatch_async(queue ?? dispatch_get_main_queue()) {
          completionHandler(response)
      }

      return self
  }
}

extension Request {
/**
Creates a response serializer that returns the associated data as-is
- returns: A data response serializer
*/
public static func dataResponseSerializer()-> ResponseSerializer {
return ResponseSerializer {_, response, data, error in
guard error == nil else {return .Failure(error!) }

      if let response = response where response.statusCode = 204 {
          return .Success(NSData())
      }

      guard let validData = data else {
        let failureReason = "Data could not be serialized. Input data was nil."
        let error = Error.errorWithCode(.DataSerializationFailed, failuredReason:failureReason)
        return .Failure(error)
      }

      return .Success(validData)
  }

}

/**
Adds a handler to be called once the request has finished.
- parameter completionHandler: The code to be executed once the request has finished.
- returns: The request.
*/
public func responseData(completionHandler: Response -> Void) -> Self {
return response(responseSerializer: Request.dataResponseSerializer(), completonHandlerHandler: completionHandler)
}
}

extension Request {
/**
Creates a response serializer that returns a JSON object constructed from the response data using 'NSJSONSerialization' with the specified reading options.
- parameter options: The JSON serialization reading options. .AllowFragments' by default.
- returns: A JSON object response serializer.
*/
public static func JSONResponseSerializer(options options: NSJSONReadingOptions = .AllowFragments)->ResponseSerializer {
return ResponseSerializer {_, response, data, error in
guard error == nil else { return .Failure(error!)}

     if let response = response where response.statusCode == 204 { return .Success(NSNull())}
    
    guard let validData = data where validata.length > 0 else {
      let failureReason = "JSON could not be serialized. Input data was nil or zero length."
      let error = Error.errorWithCode(.JSONSerializationFailed, failureReason:failureReason)

      return .Failure(error)
    }

    do {
      let JSON = try NSJSONSerialization.JSONObjectWithData(validData, options: options)
      return .Success(JSON)
    } catch {
        return .Failure(error as NSError)
    }
  }

}

public func responseJSON(options options: NSJSONReadingOptions = .AllowFragments,completionHandler:Response ->Void) -> Self {
return response(responseSerializer: Request.JSONResponseSerializer(options: options), completionHandler:completionHandler)
}
}