0001    // Request.swift
0002    //
0003    // Copyright (c) 2014–2016 Alamofire Software Foundation (http://alamofire.org/)
0004    //
0005    // Permission is hereby granted, free of charge, to any person obtaining a copy
0006    // of this software and associated documentation files (the "Software"), to deal
0007    // in the Software without restriction, including without limitation the rights
0008    // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
0009    // copies of the Software, and to permit persons to whom the Software is
0010    // furnished to do so, subject to the following conditions:
0011    //
0012    // The above copyright notice and this permission notice shall be included in
0013    // all copies or substantial portions of the Software.
0014    //
0015    // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
0016    // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
0017    // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
0018    // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
0019    // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
0020    // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
0021    // THE SOFTWARE.
0022    
0023    import Foundation
0024    
0025    /**
0026        Responsible for sending a request and receiving the response and associated data from the server, as well as 
0027        managing its underlying `NSURLSessionTask`.
0028    */
0029    public class Request
Alamofire.swift:124
    -> Request
Alamofire.swift:144
public func request(URLRequest: URLRequestConvertible) -> Request {
Alamofire.swift:167
    -> Request
Alamofire.swift:180
public func upload(URLRequest: URLRequestConvertible, file: NSURL) -> Request {
Alamofire.swift:201
    -> Request
Alamofire.swift:214
public func upload(URLRequest: URLRequestConvertible, data: NSData) -> Request {
Alamofire.swift:235
    -> Request
Alamofire.swift:248
public func upload(URLRequest: URLRequestConvertible, stream: NSInputStream) -> Request {
Alamofire.swift:328
    destination: Request.DownloadFileDestination)
Alamofire.swift:329
    -> Request
Alamofire.swift:349
public func download(URLRequest: URLRequestConvertible, destination: Request.DownloadFileDestination) -> Request {
Alamofire.swift:349
public func download(URLRequest: URLRequestConvertible, destination: Request.DownloadFileDestination) -> Request {
Alamofire.swift:366
public func download(resumeData data: NSData, destination: Request.DownloadFileDestination) -> Request {
Alamofire.swift:366
public func download(resumeData data: NSData, destination: Request.DownloadFileDestination) -> Request {
Download.swift:31
    private func download(downloadable: Downloadable, destination: Request.DownloadFileDestination) -> Request {
Download.swift:31
    private func download(downloadable: Downloadable, destination: Request.DownloadFileDestination) -> Request {
Download.swift:45
        let request = Request(session: session, task: downloadTask)
Download.swift:47
        if let downloadDelegate = request.delegate as? Request.DownloadTaskDelegate {
Download.swift:85
        destination: Request.DownloadFileDestination)
Download.swift:86
        -> Request
Download.swift:104
    public func download(URLRequest: URLRequestConvertible, destination: Request.DownloadFileDestination) -> Request {
Download.swift:104
    public func download(URLRequest: URLRequestConvertible, destination: Request.DownloadFileDestination) -> Request {
Download.swift:122
    public func download(resumeData: NSData, destination: Request.DownloadFileDestination) -> Request {
Download.swift:122
    public func download(resumeData: NSData, destination: Request.DownloadFileDestination) -> Request {
Download.swift:129
extension Request {
Manager.swift:186
        -> Request
Manager.swift:202
    public func request(URLRequest: URLRequestConvertible) -> Request {
Manager.swift:206
        let request = Request(session: session, task: dataTask)
Manager.swift:222
        private var subdelegates: [Int: Request.TaskDelegate] = [:]
Manager.swift:227
                var subdelegate: Request.TaskDelegate?
Manager.swift:430
            } else if let delegate = self[task] as? Request.UploadTaskDelegate {
Manager.swift:518
                let downloadDelegate = Request.DownloadTaskDelegate(task: downloadTask)
Manager.swift:533
            } else if let delegate = self[dataTask] as? Request.DataTaskDelegate {
Manager.swift:559
            } else if let delegate = self[dataTask] as? Request.DataTaskDelegate {
Manager.swift:602
            } else if let delegate = self[downloadTask] as? Request.DownloadTaskDelegate {
Manager.swift:628
            } else if let delegate = self[downloadTask] as? Request.DownloadTaskDelegate {
Manager.swift:659
            } else if let delegate = self[downloadTask] as? Request.DownloadTaskDelegate {
Request.swift:440
extension Request: CustomStringConvertible {
Request.swift:467
extension Request: CustomDebugStringConvertible {
ResponseSerialization.swift:74
extension Request {
ResponseSerialization.swift:149
extension Request {
ResponseSerialization.swift:180
        return response(responseSerializer: Request.dataResponseSerializer(), completionHandler: completionHandler)
ResponseSerialization.swift:186
extension Request {
ResponseSerialization.swift:248
            responseSerializer: Request.stringResponseSerializer(encoding: encoding),
ResponseSerialization.swift:256
extension Request {
ResponseSerialization.swift:304
            responseSerializer: Request.JSONResponseSerializer(options: options),
ResponseSerialization.swift:312
extension Request {
ResponseSerialization.swift:362
            responseSerializer: Request.propertyListResponseSerializer(options: options),
Stream.swift:34
    private func stream(streamable: Streamable) -> Request {
Stream.swift:48
        let request = Request(session: session, task: streamTask)
Stream.swift:67
    public func stream(hostName hostName: String, port: Int) -> Request {
Stream.swift:78
    public func stream(netService netService: NSNetService) -> Request {
Upload.swift:32
    private func upload(uploadable: Uploadable) -> Request {
Upload.swift:53
        let request = Request(session: session, task: uploadTask)
Upload.swift:82
    public func upload(URLRequest: URLRequestConvertible, file: NSURL) -> Request {
Upload.swift:103
        -> Request
Upload.swift:121
    public func upload(URLRequest: URLRequestConvertible, data: NSData) -> Request {
Upload.swift:142
        -> Request
Upload.swift:161
    public func upload(URLRequest: URLRequestConvertible, stream: NSInputStream) -> Request {
Upload.swift:182
        -> Request
Upload.swift:204
        case Success(request: Request, streamingFromDisk: Bool, streamFileURL: NSURL?)
Upload.swift:339
extension Request {
Validation.swift:25
extension Request {
 {
0030    
0031        // MARK: - Properties
0032    
0033        /// The delegate for the underlying task.
0034        public let delegate
Download.swift:47
        if let downloadDelegate = request.delegate as? Request.DownloadTaskDelegate {
Download.swift:53
        delegate[request.delegate.task] = request.delegate
Download.swift:53
        delegate[request.delegate.task] = request.delegate
Download.swift:166
        if let delegate = delegate as? DownloadTaskDelegate {
Manager.swift:207
        delegate[request.delegate.task] = request.delegate
Manager.swift:207
        delegate[request.delegate.task] = request.delegate
Request.swift:37
    public var task: NSURLSessionTask { return delegate.task }
Request.swift:49
    public var progress: NSProgress { return delegate.progress }
Request.swift:61
            delegate = UploadTaskDelegate(task: task)
Request.swift:63
            delegate = DataTaskDelegate(task: task)
Request.swift:65
            delegate = DownloadTaskDelegate(task: task)
Request.swift:67
            delegate = TaskDelegate(task: task)
Request.swift:70
        delegate.queue.addOperationWithBlock { self.endTime = CFAbsoluteTimeGetCurrent() }
Request.swift:103
        delegate.credential = credential
Request.swift:124
        if let uploadDelegate = delegate as? UploadTaskDelegate {
Request.swift:126
        } else if let dataDelegate = delegate as? DataTaskDelegate {
Request.swift:128
        } else if let downloadDelegate = delegate as? DownloadTaskDelegate {
Request.swift:147
        if let dataDelegate = delegate as? DataTaskDelegate {
Request.swift:179
            downloadDelegate = delegate as? DownloadTaskDelegate,
Request.swift:497
                if let credential = delegate.credential {
ResponseSerialization.swift:89
        delegate.queue.addOperationWithBlock {
ResponseSerialization.swift:91
                completionHandler(self.request, self.response, self.delegate.data, self.delegate.error)
ResponseSerialization.swift:91
                completionHandler(self.request, self.response, self.delegate.data, self.delegate.error)
ResponseSerialization.swift:114
        delegate.queue.addOperationWithBlock {
ResponseSerialization.swift:118
                self.delegate.data,
ResponseSerialization.swift:119
                self.delegate.error
ResponseSerialization.swift:123
            let initialResponseTime = self.delegate.initialResponseTime ?? requestCompletedTime
ResponseSerialization.swift:135
                data: self.delegate.data,
Stream.swift:50
        delegate[request.delegate.task] = request.delegate
Stream.swift:50
        delegate[request.delegate.task] = request.delegate
Upload.swift:56
            request.delegate.taskNeedNewBodyStream = { _, _ in
Upload.swift:61
        delegate[request.delegate.task] = request.delegate
Upload.swift:61
        delegate[request.delegate.task] = request.delegate
Validation.swift:54
        delegate.queue.addOperationWithBlock {
Validation.swift:56
                response = self.response where self.delegate.error == nil,
Validation.swift:59
                self.delegate.error = error
Validation.swift:133
            guard let validData = self.delegate.data where validData.length > 0 else { return .Success }
: TaskDelegate
0035    
0036        /// The underlying task.
0037        public var task
Request.swift:43
    public var request: NSURLRequest? { return task.originalRequest }
Request.swift:46
    public var response: NSHTTPURLResponse? { return task.response as? NSHTTPURLResponse }
Request.swift:162
        task.resume()
Request.swift:163
        NSNotificationCenter.defaultCenter().postNotificationName(Notifications.Task.DidResume, object: task)
Request.swift:170
        task.suspend()
Request.swift:171
        NSNotificationCenter.defaultCenter().postNotificationName(Notifications.Task.DidSuspend, object: task)
Request.swift:186
            task.cancel()
Request.swift:189
        NSNotificationCenter.defaultCenter().postNotificationName(Notifications.Task.DidCancel, object: task)
: NSURLSessionTask { return delegate.task }
0038    
0039        /// The session belonging to the underlying task.
0040        public let session
Request.swift:57
        self.session = session
Request.swift:483
        if let credentialStorage = self.session.configuration.URLCredentialStorage {
Request.swift:503
        if session.configuration.HTTPShouldSetCookies {
Request.swift:505
                cookieStorage = session.configuration.HTTPCookieStorage,
Request.swift:524
        if let additionalHeaders = session.configuration.HTTPAdditionalHeaders {
: NSURLSession
0041    
0042        /// The request sent or to be sent to the server.
0043        public var request
Request.swift:449
        if let HTTPMethod = request?.HTTPMethod {
Request.swift:453
        if let URLString = request?.URL?.absoluteString {
Request.swift:472
            request = self.request,
ResponseSerialization.swift:91
                completionHandler(self.request, self.response, self.delegate.data, self.delegate.error)
ResponseSerialization.swift:116
                self.request,
ResponseSerialization.swift:133
                request: self.request,
Validation.swift:57
                case let .Failure(error) = validation(self.request, response)
Validation.swift:180
            if let accept = request?.valueForHTTPHeaderField("Accept") {
: NSURLRequest? { return task.originalRequest }
0044    
0045        /// The response received from the server, if any.
0046        public var response
Request.swift:457
        if let response = response {
ResponseSerialization.swift:91
                completionHandler(self.request, self.response, self.delegate.data, self.delegate.error)
ResponseSerialization.swift:117
                self.response,
ResponseSerialization.swift:134
                response: self.response,
Validation.swift:56
                response = self.response where self.delegate.error == nil,
: NSHTTPURLResponse? { return task.response as? NSHTTPURLResponse }
0047    
0048        /// The progress of the request lifecycle.
0049        public var progress: NSProgress { return delegate.progress }
0050    
0051        var startTime
Request.swift:160
        if startTime == nil { startTime = CFAbsoluteTimeGetCurrent() }
Request.swift:160
        if startTime == nil { startTime = CFAbsoluteTimeGetCurrent() }
ResponseSerialization.swift:126
                requestStartTime: self.startTime ?? CFAbsoluteTimeGetCurrent(),
: CFAbsoluteTime?
0052        var endTime
Request.swift:70
        delegate.queue.addOperationWithBlock { self.endTime = CFAbsoluteTimeGetCurrent() }
ResponseSerialization.swift:122
            let requestCompletedTime = self.endTime ?? CFAbsoluteTimeGetCurrent()
: CFAbsoluteTime?
0053    
0054        // MARK: - Lifecycle
0055    
0056        init
Download.swift:45
        let request = Request(session: session, task: downloadTask)
Manager.swift:206
        let request = Request(session: session, task: dataTask)
Stream.swift:48
        let request = Request(session: session, task: streamTask)
Upload.swift:53
        let request = Request(session: session, task: uploadTask)
(session: NSURLSession, task: NSURLSessionTask) {
0057            self.session = session
0058    
0059            switch task {
0060            case is NSURLSessionUploadTask:
0061                delegate = UploadTaskDelegate(task: task)
0062            case is NSURLSessionDataTask:
0063                delegate = DataTaskDelegate(task: task)
0064            case is NSURLSessionDownloadTask:
0065                delegate = DownloadTaskDelegate(task: task)
0066            default:
0067                delegate = TaskDelegate(task: task)
0068            }
0069    
0070            delegate.queue.addOperationWithBlock { self.endTime = CFAbsoluteTimeGetCurrent() }
0071        }
0072    
0073        // MARK: - Authentication
0074    
0075        /**
0076            Associates an HTTP Basic credential with the request.
0077    
0078            - parameter user:        The user.
0079            - parameter password:    The password.
0080            - parameter persistence: The URL credential persistence. `.ForSession` by default.
0081    
0082            - returns: The request.
0083        */
0084        public func authenticate(
0085            user user: String,
0086            password: String,
0087            persistence: NSURLCredentialPersistence = .ForSession)
0088            -> Self
0089        {
0090            let credential = NSURLCredential(user: user, password: password, persistence: persistence)
0091    
0092            return authenticate(usingCredential: credential)
0093        }
0094    
0095        /**
0096            Associates a specified credential with the request.
0097    
0098            - parameter credential: The credential.
0099    
0100            - returns: The request.
0101        */
0102        public func authenticate
Request.swift:92
        return authenticate(usingCredential: credential)
(usingCredential credential: NSURLCredential) -> Self {
0103            delegate.credential = credential
0104    
0105            return self
0106        }
0107    
0108        // MARK: - Progress
0109    
0110        /**
0111            Sets a closure to be called periodically during the lifecycle of the request as data is written to or read 
0112            from the server.
0113    
0114            - For uploads, the progress closure returns the bytes written, total bytes written, and total bytes expected 
0115              to write.
0116            - For downloads and data tasks, the progress closure returns the bytes read, total bytes read, and total bytes 
0117              expected to read.
0118    
0119            - parameter closure: The code to be executed periodically during the lifecycle of the request.
0120    
0121            - returns: The request.
0122        */
0123        public func progress(closure: ((Int64, Int64, Int64) -> Void)? = nil) -> Self {
0124            if let uploadDelegate = delegate as? UploadTaskDelegate {
0125                uploadDelegate.uploadProgress = closure
0126            } else if let dataDelegate = delegate as? DataTaskDelegate {
0127                dataDelegate.dataProgress = closure
0128            } else if let downloadDelegate = delegate as? DownloadTaskDelegate {
0129                downloadDelegate.downloadProgress = closure
0130            }
0131    
0132            return self
0133        }
0134    
0135        /**
0136            Sets a closure to be called periodically during the lifecycle of the request as data is read from the server.
0137    
0138            This closure returns the bytes most recently received from the server, not including data from previous calls. 
0139            If this closure is set, data will only be available within this closure, and will not be saved elsewhere. It is 
0140            also important to note that the `response` closure will be called with nil `responseData`.
0141    
0142            - parameter closure: The code to be executed periodically during the lifecycle of the request.
0143    
0144            - returns: The request.
0145        */
0146        public func stream(closure: (NSData -> Void)? = nil) -> Self {
0147            if let dataDelegate = delegate as? DataTaskDelegate {
0148                dataDelegate.dataStream = closure
0149            }
0150    
0151            return self
0152        }
0153    
0154        // MARK: - State
0155    
0156        /**
0157            Resumes the request.
0158        */
0159        public func resume
Download.swift:56
            request.resume()
Manager.swift:210
            request.resume()
Stream.swift:53
            request.resume()
Upload.swift:64
            request.resume()
() {
0160            if startTime == nil { startTime = CFAbsoluteTimeGetCurrent() }
0161    
0162            task.resume()
0163            NSNotificationCenter.defaultCenter().postNotificationName(Notifications.Task.DidResume, object: task)
0164        }
0165    
0166        /**
0167            Suspends the request.
0168        */
0169        public func suspend() {
0170            task.suspend()
0171            NSNotificationCenter.defaultCenter().postNotificationName(Notifications.Task.DidSuspend, object: task)
0172        }
0173    
0174        /**
0175            Cancels the request.
0176        */
0177        public func cancel() {
0178            if let
0179                downloadDelegate = delegate as? DownloadTaskDelegate,
0180                downloadTask = downloadDelegate.downloadTask
0181            {
0182                downloadTask.cancelByProducingResumeData { data in
0183                    downloadDelegate.resumeData = data
0184                }
0185            } else {
0186                task.cancel()
0187            }
0188    
0189            NSNotificationCenter.defaultCenter().postNotificationName(Notifications.Task.DidCancel, object: task)
0190        }
0191    
0192        // MARK: - TaskDelegate
0193    
0194        /**
0195            The task delegate is responsible for handling all delegate callbacks for the underlying task as well as 
0196            executing all operations attached to the serial operation queue upon task completion.
0197        */
0198        public class TaskDelegate
Download.swift:175
    class DownloadTaskDelegate: TaskDelegate, NSURLSessionDownloadDelegate {
Manager.swift:222
        private var subdelegates: [Int: Request.TaskDelegate] = [:]
Manager.swift:227
                var subdelegate: Request.TaskDelegate?
Request.swift:34
    public let delegate: TaskDelegate
Request.swift:67
            delegate = TaskDelegate(task: task)
Request.swift:337
    class DataTaskDelegate: TaskDelegate, NSURLSessionDataDelegate {
: NSObject {
0199    
0200            /// The serial operation queue used to execute all operations after the task completes.
0201            public let queue
Request.swift:70
        delegate.queue.addOperationWithBlock { self.endTime = CFAbsoluteTimeGetCurrent() }
Request.swift:215
            self.queue = {
Request.swift:229
            queue.cancelAllOperations()
Request.swift:230
            queue.suspended = false
Request.swift:330
                queue.suspended = false
ResponseSerialization.swift:89
        delegate.queue.addOperationWithBlock {
ResponseSerialization.swift:114
        delegate.queue.addOperationWithBlock {
Validation.swift:54
        delegate.queue.addOperationWithBlock {
: NSOperationQueue
0202    
0203            let task
Download.swift:53
        delegate[request.delegate.task] = request.delegate
Download.swift:176
        var downloadTask: NSURLSessionDownloadTask? { return task as? NSURLSessionDownloadTask }
Manager.swift:207
        delegate[request.delegate.task] = request.delegate
Request.swift:37
    public var task: NSURLSessionTask { return delegate.task }
Request.swift:213
            self.task = task
Request.swift:338
        var dataTask: NSURLSessionDataTask? { return task as? NSURLSessionDataTask }
Stream.swift:50
        delegate[request.delegate.task] = request.delegate
Upload.swift:61
        delegate[request.delegate.task] = request.delegate
Upload.swift:344
        var uploadTask: NSURLSessionUploadTask? { return task as? NSURLSessionUploadTask }
: NSURLSessionTask
0204            let progress
Download.swift:225
                progress.totalUnitCount = totalBytesExpectedToWrite
Download.swift:226
                progress.completedUnitCount = totalBytesWritten
Download.swift:241
                progress.totalUnitCount = expectedTotalBytes
Download.swift:242
                progress.completedUnitCount = fileOffset
Request.swift:49
    public var progress: NSProgress { return delegate.progress }
Request.swift:214
            self.progress = NSProgress(totalUnitCount: 0)
Request.swift:410
                progress.totalUnitCount = totalBytesExpected
Request.swift:411
                progress.completedUnitCount = totalBytesReceived
Upload.swift:367
                progress.totalUnitCount = totalBytesExpectedToSend
Upload.swift:368
                progress.completedUnitCount = totalBytesSent
: NSProgress
0205    
0206            var data
ResponseSerialization.swift:91
                completionHandler(self.request, self.response, self.delegate.data, self.delegate.error)
ResponseSerialization.swift:118
                self.delegate.data,
ResponseSerialization.swift:135
                data: self.delegate.data,
Validation.swift:133
            guard let validData = self.delegate.data where validData.length > 0 else { return .Success }
: NSData? { return nil }
0207            var error
Download.swift:202
                    self.error = error as NSError
Request.swift:319
                    self.error = error
ResponseSerialization.swift:91
                completionHandler(self.request, self.response, self.delegate.data, self.delegate.error)
ResponseSerialization.swift:119
                self.delegate.error
Validation.swift:56
                response = self.response where self.delegate.error == nil,
Validation.swift:59
                self.delegate.error = error
: NSError?
0208    
0209            var initialResponseTime
Download.swift:214
            if initialResponseTime == nil { initialResponseTime = CFAbsoluteTimeGetCurrent() }
Download.swift:214
            if initialResponseTime == nil { initialResponseTime = CFAbsoluteTimeGetCurrent() }
Request.swift:396
            if initialResponseTime == nil { initialResponseTime = CFAbsoluteTimeGetCurrent() }
Request.swift:396
            if initialResponseTime == nil { initialResponseTime = CFAbsoluteTimeGetCurrent() }
ResponseSerialization.swift:123
            let initialResponseTime = self.delegate.initialResponseTime ?? requestCompletedTime
Upload.swift:362
            if initialResponseTime == nil { initialResponseTime = CFAbsoluteTimeGetCurrent() }
Upload.swift:362
            if initialResponseTime == nil { initialResponseTime = CFAbsoluteTimeGetCurrent() }
: CFAbsoluteTime?
0210            var credential
Request.swift:103
        delegate.credential = credential
Request.swift:289
                    credential = self.credential ?? session.configuration.URLCredentialStorage?.defaultCredentialForProtectionSpace(challenge.protectionSpace)
Request.swift:497
                if let credential = delegate.credential {
: NSURLCredential?
0211    
0212            init
Request.swift:67
            delegate = TaskDelegate(task: task)
Request.swift:356
            super.init(task: task)
(task: NSURLSessionTask) {
0213                self.task = task
0214                self.progress = NSProgress(totalUnitCount: 0)
0215                self.queue = {
0216                    let operationQueue = NSOperationQueue()
0217                    operationQueue.maxConcurrentOperationCount = 1
0218                    operationQueue.suspended = true
0219    
0220                    if #available(OSX 10.10, *) {
0221                        operationQueue.qualityOfService = NSQualityOfService.Utility
0222                    }
0223    
0224                    return operationQueue
0225                }()
0226            }
0227    
0228            deinit {
0229                queue.cancelAllOperations()
0230                queue.suspended = false
0231            }
0232    
0233            // MARK: - NSURLSessionTaskDelegate
0234    
0235            // MARK: Override Closures
0236    
0237            var taskWillPerformHTTPRedirection
Request.swift:253
            if let taskWillPerformHTTPRedirection = taskWillPerformHTTPRedirection {
: ((NSURLSession, NSURLSessionTask, NSHTTPURLResponse, NSURLRequest) -> NSURLRequest?)?
0238            var taskDidReceiveChallenge
Request.swift:269
            if let taskDidReceiveChallenge = taskDidReceiveChallenge {
: ((NSURLSession, NSURLSessionTask, NSURLAuthenticationChallenge) -> (NSURLSessionAuthChallengeDisposition, NSURLCredential?))?
0239            var taskNeedNewBodyStream
Request.swift:307
            if let taskNeedNewBodyStream = taskNeedNewBodyStream {
Upload.swift:56
            request.delegate.taskNeedNewBodyStream = { _, _ in
: ((NSURLSession, NSURLSessionTask) -> NSInputStream?)?
0240            var taskDidCompleteWithError
Request.swift:315
            if let taskDidCompleteWithError = taskDidCompleteWithError {
: ((NSURLSession, NSURLSessionTask, NSError?) -> Void)?
0241    
0242            // MARK: Delegate Methods
0243    
0244            func URLSession(
0245                session: NSURLSession,
0246                task: NSURLSessionTask,
0247                willPerformHTTPRedirection response: NSHTTPURLResponse,
0248                newRequest request: NSURLRequest,
0249                completionHandler: ((NSURLRequest?) -> Void))
0250            {
0251                var redirectRequest: NSURLRequest? = request
0252    
0253                if let taskWillPerformHTTPRedirection = taskWillPerformHTTPRedirection {
0254                    redirectRequest = taskWillPerformHTTPRedirection(session, task, response, request)
0255                }
0256    
0257                completionHandler(redirectRequest)
0258            }
0259    
0260            func URLSession
Manager.swift:382
                delegate.URLSession(
(
0261                session: NSURLSession,
0262                task: NSURLSessionTask,
0263                didReceiveChallenge challenge: NSURLAuthenticationChallenge,
0264                completionHandler: ((NSURLSessionAuthChallengeDisposition, NSURLCredential?) -> Void))
0265            {
0266                var disposition: NSURLSessionAuthChallengeDisposition = .PerformDefaultHandling
0267                var credential: NSURLCredential?
0268    
0269                if let taskDidReceiveChallenge = taskDidReceiveChallenge {
0270                    (disposition, credential) = taskDidReceiveChallenge(session, task, challenge)
0271                } else if challenge.protectionSpace.authenticationMethod == NSURLAuthenticationMethodServerTrust {
0272                    let host = challenge.protectionSpace.host
0273    
0274                    if let
0275                        serverTrustPolicy = session.serverTrustPolicyManager?.serverTrustPolicyForHost(host),
0276                        serverTrust = challenge.protectionSpace.serverTrust
0277                    {
0278                        if serverTrustPolicy.evaluateServerTrust(serverTrust, isValidForHost: host) {
0279                            disposition = .UseCredential
0280                            credential = NSURLCredential(forTrust: serverTrust)
0281                        } else {
0282                            disposition = .CancelAuthenticationChallenge
0283                        }
0284                    }
0285                } else {
0286                    if challenge.previousFailureCount > 0 {
0287                        disposition = .CancelAuthenticationChallenge
0288                    } else {
0289                        credential = self.credential ?? session.configuration.URLCredentialStorage?.defaultCredentialForProtectionSpace(challenge.protectionSpace)
0290    
0291                        if credential != nil {
0292                            disposition = .UseCredential
0293                        }
0294                    }
0295                }
0296    
0297                completionHandler(disposition, credential)
0298            }
0299    
0300            func URLSession
Manager.swift:408
                delegate.URLSession(session, task: task, needNewBodyStream: completionHandler)
(
0301                session: NSURLSession,
0302                task: NSURLSessionTask,
0303                needNewBodyStream completionHandler: ((NSInputStream?) -> Void))
0304            {
0305                var bodyStream: NSInputStream?
0306    
0307                if let taskNeedNewBodyStream = taskNeedNewBodyStream {
0308                    bodyStream = taskNeedNewBodyStream(session, task)
0309                }
0310    
0311                completionHandler(bodyStream)
0312            }
0313    
0314            func URLSession
Manager.swift:452
                delegate.URLSession(session, task: task, didCompleteWithError: error)
(session: NSURLSession, task: NSURLSessionTask, didCompleteWithError error: NSError?) {
0315                if let taskDidCompleteWithError = taskDidCompleteWithError {
0316                    taskDidCompleteWithError(session, task, error)
0317                } else {
0318                    if let error = error {
0319                        self.error = error
0320    
0321                        if let
0322                            downloadDelegate = self as? DownloadTaskDelegate,
0323                            userInfo = error.userInfo as? [String: AnyObject],
0324                            resumeData = userInfo[NSURLSessionDownloadTaskResumeData] as? NSData
0325                        {
0326                            downloadDelegate.resumeData = resumeData
0327                        }
0328                    }
0329    
0330                    queue.suspended = false
0331                }
0332            }
0333        }
0334    
0335        // MARK: - DataTaskDelegate
0336    
0337        class DataTaskDelegate
Manager.swift:533
            } else if let delegate = self[dataTask] as? Request.DataTaskDelegate {
Manager.swift:559
            } else if let delegate = self[dataTask] as? Request.DataTaskDelegate {
Request.swift:63
            delegate = DataTaskDelegate(task: task)
Request.swift:126
        } else if let dataDelegate = delegate as? DataTaskDelegate {
Request.swift:147
        if let dataDelegate = delegate as? DataTaskDelegate {
Upload.swift:343
    class UploadTaskDelegate: DataTaskDelegate {
: TaskDelegate, NSURLSessionDataDelegate {
0338            var dataTask: NSURLSessionDataTask? { return task as? NSURLSessionDataTask }
0339    
0340            private var totalBytesReceived
Request.swift:407
                totalBytesReceived += data.length
Request.swift:411
                progress.completedUnitCount = totalBytesReceived
Request.swift:415
                    totalBytesReceived: totalBytesReceived,
: Int64 = 0
0341            private var mutableData
Request.swift:346
                return mutableData
Request.swift:355
            mutableData = NSMutableData()
Request.swift:404
                    mutableData.appendData(data)
: NSMutableData
0342            override var data: NSData? {
0343                if dataStream != nil {
0344                    return nil
0345                } else {
0346                    return mutableData
0347                }
0348            }
0349    
0350            private var expectedContentLength
Request.swift:378
            expectedContentLength = response.expectedContentLength
: Int64?
0351            private var dataProgress
Request.swift:127
            dataDelegate.dataProgress = closure
Request.swift:413
                dataProgress?(
: ((bytesReceived: Int64, totalBytesReceived: Int64, totalBytesExpectedToReceive: Int64) -> Void)?
0352            private var dataStream
Request.swift:148
            dataDelegate.dataStream = closure
Request.swift:343
            if dataStream != nil {
Request.swift:401
                if let dataStream = dataStream {
: ((data: NSData) -> Void)?
0353    
0354            override init
Request.swift:63
            delegate = DataTaskDelegate(task: task)
(task: NSURLSessionTask) {
0355                mutableData = NSMutableData()
0356                super.init(task: task)
0357            }
0358    
0359            // MARK: - NSURLSessionDataDelegate
0360    
0361            // MARK: Override Closures
0362    
0363            var dataTaskDidReceiveResponse
Request.swift:380
            if let dataTaskDidReceiveResponse = dataTaskDidReceiveResponse {
: ((NSURLSession, NSURLSessionDataTask, NSURLResponse) -> NSURLSessionResponseDisposition)?
0364            var dataTaskDidBecomeDownloadTask
Request.swift:392
            dataTaskDidBecomeDownloadTask?(session, dataTask, downloadTask)
: ((NSURLSession, NSURLSessionDataTask, NSURLSessionDownloadTask) -> Void)?
0365            var dataTaskDidReceiveData
Request.swift:398
            if let dataTaskDidReceiveData = dataTaskDidReceiveData {
: ((NSURLSession, NSURLSessionDataTask, NSData) -> Void)?
0366            var dataTaskWillCacheResponse
Request.swift:429
            if let dataTaskWillCacheResponse = dataTaskWillCacheResponse {
: ((NSURLSession, NSURLSessionDataTask, NSCachedURLResponse) -> NSCachedURLResponse?)?
0367    
0368            // MARK: Delegate Methods
0369    
0370            func URLSession(
0371                session: NSURLSession,
0372                dataTask: NSURLSessionDataTask,
0373                didReceiveResponse response: NSURLResponse,
0374                completionHandler: (NSURLSessionResponseDisposition -> Void))
0375            {
0376                var disposition: NSURLSessionResponseDisposition = .Allow
0377    
0378                expectedContentLength = response.expectedContentLength
0379    
0380                if let dataTaskDidReceiveResponse = dataTaskDidReceiveResponse {
0381                    disposition = dataTaskDidReceiveResponse(session, dataTask, response)
0382                }
0383    
0384                completionHandler(disposition)
0385            }
0386    
0387            func URLSession(
0388                session: NSURLSession,
0389                dataTask: NSURLSessionDataTask,
0390                didBecomeDownloadTask downloadTask: NSURLSessionDownloadTask)
0391            {
0392                dataTaskDidBecomeDownloadTask?(session, dataTask, downloadTask)
0393            }
0394    
0395            func URLSession
Manager.swift:534
                delegate.URLSession(session, dataTask: dataTask, didReceiveData: data)
(session: NSURLSession, dataTask: NSURLSessionDataTask, didReceiveData data: NSData) {
0396                if initialResponseTime == nil { initialResponseTime = CFAbsoluteTimeGetCurrent() }
0397    
0398                if let dataTaskDidReceiveData = dataTaskDidReceiveData {
0399                    dataTaskDidReceiveData(session, dataTask, data)
0400                } else {
0401                    if let dataStream = dataStream {
0402                        dataStream(data: data)
0403                    } else {
0404                        mutableData.appendData(data)
0405                    }
0406    
0407                    totalBytesReceived += data.length
0408                    let totalBytesExpected = dataTask.response?.expectedContentLength ?? NSURLSessionTransferSizeUnknown
0409    
0410                    progress.totalUnitCount = totalBytesExpected
0411                    progress.completedUnitCount = totalBytesReceived
0412    
0413                    dataProgress?(
0414                        bytesReceived: Int64(data.length),
0415                        totalBytesReceived: totalBytesReceived,
0416                        totalBytesExpectedToReceive: totalBytesExpected
0417                    )
0418                }
0419            }
0420    
0421            func URLSession
Manager.swift:560
                delegate.URLSession(
(
0422                session: NSURLSession,
0423                dataTask: NSURLSessionDataTask,
0424                willCacheResponse proposedResponse: NSCachedURLResponse,
0425                completionHandler: ((NSCachedURLResponse?) -> Void))
0426            {
0427                var cachedResponse: NSCachedURLResponse? = proposedResponse
0428    
0429                if let dataTaskWillCacheResponse = dataTaskWillCacheResponse {
0430                    cachedResponse = dataTaskWillCacheResponse(session, dataTask, proposedResponse)
0431                }
0432    
0433                completionHandler(cachedResponse)
0434            }
0435        }
0436    }
0437    
0438    // MARK: - CustomStringConvertible
0439    
0440    extension Request: CustomStringConvertible {
0441    
0442        /**
0443            The textual representation used when written to an output stream, which includes the HTTP method and URL, as 
0444            well as the response status code if a response has been received.
0445        */
0446        public var description: String {
0447            var components: [String] = []
0448    
0449            if let HTTPMethod = request?.HTTPMethod {
0450                components.append(HTTPMethod)
0451            }
0452    
0453            if let URLString = request?.URL?.absoluteString {
0454                components.append(URLString)
0455            }
0456    
0457            if let response = response {
0458                components.append("(\(response.statusCode))")
0459            }
0460    
0461            return components.joinWithSeparator(" ")
0462        }
0463    }
0464    
0465    // MARK: - CustomDebugStringConvertible
0466    
0467    extension Request: CustomDebugStringConvertible {
0468        func cURLRepresentation
Request.swift:550
        return cURLRepresentation()
() -> String {
0469            var components = ["$ curl -i"]
0470    
0471            guard let
0472                request = self.request,
0473                URL = request.URL,
0474                host = URL.host
0475            else {
0476                return "$ curl command could not be created"
0477            }
0478    
0479            if let HTTPMethod = request.HTTPMethod where HTTPMethod != "GET" {
0480                components.append("-X \(HTTPMethod)")
0481            }
0482    
0483            if let credentialStorage = self.session.configuration.URLCredentialStorage {
0484                let protectionSpace = NSURLProtectionSpace(
0485                    host: host,
0486                    port: URL.port?.integerValue ?? 0,
0487                    `protocol`: URL.scheme,
0488                    realm: host,
0489                    authenticationMethod: NSURLAuthenticationMethodHTTPBasic
0490                )
0491    
0492                if let credentials = credentialStorage.credentialsForProtectionSpace(protectionSpace)?.values {
0493                    for credential in credentials {
0494                        components.append("-u \(credential.user!):\(credential.password!)")
0495                    }
0496                } else {
0497                    if let credential = delegate.credential {
0498                        components.append("-u \(credential.user!):\(credential.password!)")
0499                    }
0500                }
0501            }
0502    
0503            if session.configuration.HTTPShouldSetCookies {
0504                if let
0505                    cookieStorage = session.configuration.HTTPCookieStorage,
0506                    cookies = cookieStorage.cookiesForURL(URL) where !cookies.isEmpty
0507                {
0508                    let string = cookies.reduce("") { $0 + "\($1.name)=\($1.value ?? String());" }
0509                    components.append("-b \"\(string.substringToIndex(string.endIndex.predecessor()))\"")
0510                }
0511            }
0512    
0513            if let headerFields = request.allHTTPHeaderFields {
0514                for (field, value) in headerFields {
0515                    switch field {
0516                    case "Cookie":
0517                        continue
0518                    default:
0519                        components.append("-H \"\(field): \(value)\"")
0520                    }
0521                }
0522            }
0523    
0524            if let additionalHeaders = session.configuration.HTTPAdditionalHeaders {
0525                for (field, value) in additionalHeaders {
0526                    switch field {
0527                    case "Cookie":
0528                        continue
0529                    default:
0530                        components.append("-H \"\(field): \(value)\"")
0531                    }
0532                }
0533            }
0534    
0535            if let
0536                HTTPBodyData = request.HTTPBody,
0537                HTTPBody = String(data: HTTPBodyData, encoding: NSUTF8StringEncoding)
0538            {
0539                let escapedBody = HTTPBody.stringByReplacingOccurrencesOfString("\"", withString: "\\\"")
0540                components.append("-d \"\(escapedBody)\"")
0541            }
0542    
0543            components.append("\"\(URL.absoluteString)\"")
0544    
0545            return components.joinWithSeparator(" \\\n\t")
0546        }
0547    
0548        /// The textual representation used when written to an output stream, in the form of a cURL command.
0549        public var debugDescription: String {
0550            return cURLRepresentation()
0551        }
0552    }
0553