DataRequest Class Reference

convertible
URLRequestConvertible value used to create URLRequests for this instance.
Declaration
Swift

public let convertible: URLRequestConvertible
data
Data read from the server so far.
Declaration
Swift

public var data: Data? { get }


                    
                    
                    validate(_:)

Validates the request, using the specified closure.

Note

If validation fails, subsequent calls to response handlers will have an associated error.

Declaration

Swift

@discardableResult
public func validate(_ validation: @escaping Validation) -> Self

Parameters


                                validation

Validation closure used to validate the response.

Return Value

The instance.

DataRequest / UploadRequest


                    
                    
                    publishResponse(using:on:)

Creates a DataResponsePublisher for this instance using the given ResponseSerializer and DispatchQueue.

Declaration

Swift

@available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *)
public func publishResponse<Serializer: ResponseSerializer, T>(using serializer: Serializer, on queue: DispatchQueue = .main) -> DataResponsePublisher<T>
    where Serializer.SerializedObject == T

Parameters

`serializer`	`ResponseSerializer` used to serialize response `Data`.
`queue`	`DispatchQueue` on which the `DataResponse` will be published. `.main` by default.

Return Value

The DataResponsePublisher.


                    
                    
                    publishData(queue:preprocessor:emptyResponseCodes:emptyRequestMethods:)

Creates a DataResponsePublisher for this instance and uses a DataResponseSerializer to serialize the response.

Declaration

Swift

@available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *)
public func publishData(queue: DispatchQueue = .main,
                        preprocessor: DataPreprocessor = DataResponseSerializer.defaultDataPreprocessor,
                        emptyResponseCodes: Set<Int> = DataResponseSerializer.defaultEmptyResponseCodes,
                        emptyRequestMethods: Set<HTTPMethod> = DataResponseSerializer.defaultEmptyRequestMethods) -> DataResponsePublisher<Data>

Parameters

`queue`	`DispatchQueue` on which the `DataResponse` will be published. `.main` by default.
`preprocessor`	`DataPreprocessor` which filters the `Data` before serialization. `PassthroughPreprocessor()` by default.
`emptyResponseCodes`	`Set<Int>` of HTTP status codes for which empty responses are allowed. `[204, 205]` by default.
`emptyRequestMethods`	`Set<HTTPMethod>` of `HTTPMethod`s for which empty responses are allowed, regardless of status code. `[.head]` by default.

Return Value

The DataResponsePublisher.


                    
                    
                    publishString(queue:preprocessor:encoding:emptyResponseCodes:emptyRequestMethods:)

Creates a DataResponsePublisher for this instance and uses a StringResponseSerializer to serialize the response.

Declaration

Swift

@available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *)
public func publishString(queue: DispatchQueue = .main,
                          preprocessor: DataPreprocessor = StringResponseSerializer.defaultDataPreprocessor,
                          encoding: String.Encoding? = nil,
                          emptyResponseCodes: Set<Int> = StringResponseSerializer.defaultEmptyResponseCodes,
                          emptyRequestMethods: Set<HTTPMethod> = StringResponseSerializer.defaultEmptyRequestMethods) -> DataResponsePublisher<String>

Parameters

`queue`	`DispatchQueue` on which the `DataResponse` will be published. `.main` by default.
`preprocessor`	`DataPreprocessor` which filters the `Data` before serialization. `PassthroughPreprocessor()` by default.
`encoding`	`String.Encoding` to parse the response. `nil` by default, in which case the encoding will be determined by the server response, falling back to the default HTTP character set, `ISO-8859-1`.
`emptyResponseCodes`	`Set<Int>` of HTTP status codes for which empty responses are allowed. `[204, 205]` by default.
`emptyRequestMethods`	`Set<HTTPMethod>` of `HTTPMethod`s for which empty responses are allowed, regardless of status code. `[.head]` by default.

Return Value

The DataResponsePublisher.


                    
                    
                    publishDecodable(type:queue:preprocessor:decoder:emptyResponseCodes:emptyResponseMethods:)

Undocumented

Declaration

Swift

@_disfavoredOverload
public func publishDecodable<T: Decodable>(type: T.Type = T.self,
                                           queue: DispatchQueue = .main,
                                           preprocessor: DataPreprocessor = DecodableResponseSerializer<T>.defaultDataPreprocessor,
                                           decoder: DataDecoder = JSONDecoder(),
                                           emptyResponseCodes: Set<Int> = DecodableResponseSerializer<T>.defaultEmptyResponseCodes,
                                           emptyResponseMethods: Set<HTTPMethod> = DecodableResponseSerializer<T>.defaultEmptyRequestMethods) -> DataResponsePublisher<T>


                    
                    
                    publishDecodable(type:queue:preprocessor:decoder:emptyResponseCodes:emptyRequestMethods:)

Creates a DataResponsePublisher for this instance and uses a DecodableResponseSerializer to serialize the response.

Declaration

Swift

@available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *)
public func publishDecodable<T: Decodable>(type: T.Type = T.self,
                                           queue: DispatchQueue = .main,
                                           preprocessor: DataPreprocessor = DecodableResponseSerializer<T>.defaultDataPreprocessor,
                                           decoder: DataDecoder = JSONDecoder(),
                                           emptyResponseCodes: Set<Int> = DecodableResponseSerializer<T>.defaultEmptyResponseCodes,
                                           emptyRequestMethods: Set<HTTPMethod> = DecodableResponseSerializer<T>.defaultEmptyRequestMethods) -> DataResponsePublisher<T>

Parameters

`type`	`Decodable` type to which to decode response `Data`. Inferred from the context by default.
`queue`	`DispatchQueue` on which the `DataResponse` will be published. `.main` by default.
`preprocessor`	`DataPreprocessor` which filters the `Data` before serialization. `PassthroughPreprocessor()` by default.
`decoder`	`DataDecoder` instance used to decode response `Data`. `JSONDecoder()` by default.
`emptyResponseCodes`	`Set<Int>` of HTTP status codes for which empty responses are allowed. `[204, 205]` by default.
`emptyRequestMethods`	`Set<HTTPMethod>` of `HTTPMethod`s for which empty responses are allowed, regardless of status code. `[.head]` by default.

Return Value

The DataResponsePublisher.

publishUnserialized(queue:)
Creates a DataResponsePublisher for this instance which does not serialize the response before publishing.
- queue: DispatchQueue on which the DataResponse will be published. .main by default.
Declaration
Swift

@available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *) public func publishUnserialized(queue: DispatchQueue = .main) -> DataResponsePublisher<Data?>
Return Value

The DataResponsePublisher.

DataTask


                    
                    
                    serializingData(automaticallyCancelling:dataPreprocessor:emptyResponseCodes:emptyRequestMethods:)

Creates a DataTask to await a Data value.

Declaration

Swift

public func serializingData(automaticallyCancelling shouldAutomaticallyCancel: Bool = false,
                            dataPreprocessor: DataPreprocessor = DataResponseSerializer.defaultDataPreprocessor,
                            emptyResponseCodes: Set<Int> = DataResponseSerializer.defaultEmptyResponseCodes,
                            emptyRequestMethods: Set<HTTPMethod> = DataResponseSerializer.defaultEmptyRequestMethods) -> DataTask<Data>

Parameters

`shouldAutomaticallyCancel`	`Bool` determining whether or not the request should be cancelled when the enclosing async context is cancelled. Only applies to `DataTask`‘s async properties. `false` by default.
`dataPreprocessor`	`DataPreprocessor` which processes the received `Data` before completion.
`emptyResponseCodes`	HTTP response codes for which empty responses are allowed. `[204, 205]` by default.
`emptyRequestMethods`	`HTTPMethod`s for which empty responses are always valid. `[.head]` by default.

Return Value

The DataTask.


                    
                    
                    serializingDecodable(_:automaticallyCancelling:dataPreprocessor:decoder:emptyResponseCodes:emptyRequestMethods:)

Creates a DataTask to await serialization of a Decodable value.

Declaration

Swift

public func serializingDecodable<Value: Decodable>(_ type: Value.Type = Value.self,
                                                   automaticallyCancelling shouldAutomaticallyCancel: Bool = false,
                                                   dataPreprocessor: DataPreprocessor = DecodableResponseSerializer<Value>.defaultDataPreprocessor,
                                                   decoder: DataDecoder = JSONDecoder(),
                                                   emptyResponseCodes: Set<Int> = DecodableResponseSerializer<Value>.defaultEmptyResponseCodes,
                                                   emptyRequestMethods: Set<HTTPMethod> = DecodableResponseSerializer<Value>.defaultEmptyRequestMethods) -> DataTask<Value>

Parameters

`type`	`Decodable` type to decode from response data.
`shouldAutomaticallyCancel`	`Bool` determining whether or not the request should be cancelled when the enclosing async context is cancelled. Only applies to `DataTask`‘s async properties. `false` by default.
`dataPreprocessor`	`DataPreprocessor` which processes the received `Data` before calling the serializer. `PassthroughPreprocessor()` by default.
`decoder`	`DataDecoder` to use to decode the response. `JSONDecoder()` by default.
`emptyResponseCodes`	HTTP status codes for which empty responses are always valid. `[204, 205]` by default.
`emptyRequestMethods`	`HTTPMethod`s for which empty responses are always valid. `[.head]` by default.

Return Value

The DataTask.


                    
                    
                    serializingString(automaticallyCancelling:dataPreprocessor:encoding:emptyResponseCodes:emptyRequestMethods:)

Creates a DataTask to await serialization of a String value.

Declaration

Swift

public func serializingString(automaticallyCancelling shouldAutomaticallyCancel: Bool = false,
                              dataPreprocessor: DataPreprocessor = StringResponseSerializer.defaultDataPreprocessor,
                              encoding: String.Encoding? = nil,
                              emptyResponseCodes: Set<Int> = StringResponseSerializer.defaultEmptyResponseCodes,
                              emptyRequestMethods: Set<HTTPMethod> = StringResponseSerializer.defaultEmptyRequestMethods) -> DataTask<String>

Parameters

`shouldAutomaticallyCancel`	`Bool` determining whether or not the request should be cancelled when the enclosing async context is cancelled. Only applies to `DataTask`‘s async properties. `false` by default.
`dataPreprocessor`	`DataPreprocessor` which processes the received `Data` before calling the serializer. `PassthroughPreprocessor()` by default.
`encoding`	`String.Encoding` to use during serialization. Defaults to `nil`, in which case the encoding will be determined from the server response, falling back to the default HTTP character set, `ISO-8859-1`.
`emptyResponseCodes`	HTTP status codes for which empty responses are always valid. `[204, 205]` by default.
`emptyRequestMethods`	`HTTPMethod`s for which empty responses are always valid. `[.head]` by default.

Return Value

The DataTask.


                    
                    
                    serializingResponse(using:automaticallyCancelling:)

Creates a DataTask to await serialization using the provided ResponseSerializer instance.

Declaration

Swift

public func serializingResponse<Serializer: ResponseSerializer>(using serializer: Serializer,
                                                                automaticallyCancelling shouldAutomaticallyCancel: Bool = false)
    -> DataTask<Serializer.SerializedObject>

Parameters

`serializer`	`ResponseSerializer` responsible for serializing the request, response, and data.
`shouldAutomaticallyCancel`	`Bool` determining whether or not the request should be cancelled when the enclosing async context is cancelled. Only applies to `DataTask`‘s async properties. `false` by default.

Return Value

The DataTask.


                    
                    
                    serializingResponse(using:automaticallyCancelling:)

Creates a DataTask to await serialization using the provided DataResponseSerializerProtocol instance.

Declaration

Swift

public func serializingResponse<Serializer: DataResponseSerializerProtocol>(using serializer: Serializer,
                                                                            automaticallyCancelling shouldAutomaticallyCancel: Bool = false)
    -> DataTask<Serializer.SerializedObject>

Parameters

`serializer`	`DataResponseSerializerProtocol` responsible for serializing the request, response, and data.
`shouldAutomaticallyCancel`	`Bool` determining whether or not the request should be cancelled when the enclosing async context is cancelled. Only applies to `DataTask`‘s async properties. `false` by default.

Return Value

The DataTask.

Default


                    
                    
                    response(queue:completionHandler:)

Adds a handler to be called once the request has finished.

Declaration

Swift

@discardableResult
public func response(queue: DispatchQueue = .main, completionHandler: @escaping (AFDataResponse<Data?>) -> Void) -> Self

Parameters

`queue`	The queue on which the completion handler is dispatched. `.main` by default.
`completionHandler`	The code to be executed once the request has finished.

Return Value

The request.


                    
                    
                    response(queue:responseSerializer:completionHandler:)

Adds a handler to be called once the request has finished.

Declaration

Swift

@discardableResult
public func response<Serializer: DataResponseSerializerProtocol>(queue: DispatchQueue = .main,
                                                                 responseSerializer: Serializer,
                                                                 completionHandler: @escaping (AFDataResponse<Serializer.SerializedObject>) -> Void)
    -> Self

Parameters

`queue`	The queue on which the completion handler is dispatched. `.main` by default
`responseSerializer`	The response serializer responsible for serializing the request, response, and data.
`completionHandler`	The code to be executed once the request has finished.

Return Value

The request.


                    
                    
                    response(queue:responseSerializer:completionHandler:)

Adds a handler to be called once the request has finished.

Declaration

Swift

@discardableResult
public func response<Serializer: ResponseSerializer>(queue: DispatchQueue = .main,
                                                     responseSerializer: Serializer,
                                                     completionHandler: @escaping (AFDataResponse<Serializer.SerializedObject>) -> Void)
    -> Self

Parameters

`queue`	The queue on which the completion handler is dispatched. `.main` by default
`responseSerializer`	The response serializer responsible for serializing the request, response, and data.
`completionHandler`	The code to be executed once the request has finished.

Return Value

The request.

Data


                    
                    
                    responseData(queue:dataPreprocessor:emptyResponseCodes:emptyRequestMethods:completionHandler:)

Adds a handler using a DataResponseSerializer to be called once the request has finished.

Declaration

Swift

@discardableResult
public func responseData(queue: DispatchQueue = .main,
                         dataPreprocessor: DataPreprocessor = DataResponseSerializer.defaultDataPreprocessor,
                         emptyResponseCodes: Set<Int> = DataResponseSerializer.defaultEmptyResponseCodes,
                         emptyRequestMethods: Set<HTTPMethod> = DataResponseSerializer.defaultEmptyRequestMethods,
                         completionHandler: @escaping (AFDataResponse<Data>) -> Void) -> Self

Parameters

`queue`	The queue on which the completion handler is called. `.main` by default.
`dataPreprocessor`	`DataPreprocessor` which processes the received `Data` before calling the `completionHandler`. `PassthroughPreprocessor()` by default.
`emptyResponseCodes`	HTTP status codes for which empty responses are always valid. `[204, 205]` by default.
`emptyRequestMethods`	`HTTPMethod`s for which empty responses are always valid. `[.head]` by default.
`completionHandler`	A closure to be executed once the request has finished.

Return Value

The request.

String


                    
                    
                    responseString(queue:dataPreprocessor:encoding:emptyResponseCodes:emptyRequestMethods:completionHandler:)

Adds a handler using a StringResponseSerializer to be called once the request has finished.

Declaration

Swift

@discardableResult
public func responseString(queue: DispatchQueue = .main,
                           dataPreprocessor: DataPreprocessor = StringResponseSerializer.defaultDataPreprocessor,
                           encoding: String.Encoding? = nil,
                           emptyResponseCodes: Set<Int> = StringResponseSerializer.defaultEmptyResponseCodes,
                           emptyRequestMethods: Set<HTTPMethod> = StringResponseSerializer.defaultEmptyRequestMethods,
                           completionHandler: @escaping (AFDataResponse<String>) -> Void) -> Self

Parameters

`queue`	The queue on which the completion handler is dispatched. `.main` by default.
`dataPreprocessor`	`DataPreprocessor` which processes the received `Data` before calling the `completionHandler`. `PassthroughPreprocessor()` by default.
`encoding`	The string encoding. Defaults to `nil`, in which case the encoding will be determined from the server response, falling back to the default HTTP character set, `ISO-8859-1`.
`emptyResponseCodes`	HTTP status codes for which empty responses are always valid. `[204, 205]` by default.
`emptyRequestMethods`	`HTTPMethod`s for which empty responses are always valid. `[.head]` by default.
`completionHandler`	A closure to be executed once the request has finished.

Return Value

The request.

JSON


                    
                    
                    responseJSON(queue:dataPreprocessor:emptyResponseCodes:emptyRequestMethods:options:completionHandler:)

Adds a handler using a JSONResponseSerializer to be called once the request has finished.

Declaration

Swift

@available(*, deprecated, message: "responseJSON deprecated and will be removed in Alamofire 6. Use responseDecodable instead.")
@discardableResult
public func responseJSON(queue: DispatchQueue = .main,
                         dataPreprocessor: DataPreprocessor = JSONResponseSerializer.defaultDataPreprocessor,
                         emptyResponseCodes: Set<Int> = JSONResponseSerializer.defaultEmptyResponseCodes,
                         emptyRequestMethods: Set<HTTPMethod> = JSONResponseSerializer.defaultEmptyRequestMethods,
                         options: JSONSerialization.ReadingOptions = .allowFragments,
                         completionHandler: @escaping (AFDataResponse<Any>) -> Void) -> Self

Parameters

`queue`	The queue on which the completion handler is dispatched. `.main` by default.
`dataPreprocessor`	`DataPreprocessor` which processes the received `Data` before calling the `completionHandler`. `PassthroughPreprocessor()` by default.
`emptyResponseCodes`	HTTP status codes for which empty responses are always valid. `[204, 205]` by default.
`emptyRequestMethods`	`HTTPMethod`s for which empty responses are always valid. `[.head]` by default.
`options`	`JSONSerialization.ReadingOptions` used when parsing the response. `.allowFragments` by default.
`completionHandler`	A closure to be executed once the request has finished.

Return Value

The request.

Decodable


                    
                    
                    responseDecodable(of:queue:dataPreprocessor:decoder:emptyResponseCodes:emptyRequestMethods:completionHandler:)

Adds a handler using a DecodableResponseSerializer to be called once the request has finished.

Declaration

Swift

@discardableResult
public func responseDecodable<T: Decodable>(of type: T.Type = T.self,
                                            queue: DispatchQueue = .main,
                                            dataPreprocessor: DataPreprocessor = DecodableResponseSerializer<T>.defaultDataPreprocessor,
                                            decoder: DataDecoder = JSONDecoder(),
                                            emptyResponseCodes: Set<Int> = DecodableResponseSerializer<T>.defaultEmptyResponseCodes,
                                            emptyRequestMethods: Set<HTTPMethod> = DecodableResponseSerializer<T>.defaultEmptyRequestMethods,
                                            completionHandler: @escaping (AFDataResponse<T>) -> Void) -> Self

Parameters

`type`	`Decodable` type to decode from response data.
`queue`	The queue on which the completion handler is dispatched. `.main` by default.
`dataPreprocessor`	`DataPreprocessor` which processes the received `Data` before calling the `completionHandler`. `PassthroughPreprocessor()` by default.
`decoder`	`DataDecoder` to use to decode the response. `JSONDecoder()` by default.
`emptyResponseCodes`	HTTP status codes for which empty responses are always valid. `[204, 205]` by default.
`emptyRequestMethods`	`HTTPMethod`s for which empty responses are always valid. `[.head]` by default.
`completionHandler`	A closure to be executed once the request has finished.

Return Value

The request.

Validation
A closure used to validate a request that takes a URL request, a URL response and data, and returns whether the request was valid.
Declaration
Swift

public typealias Validation = (URLRequest?, HTTPURLResponse, Data?) -> ValidationResult


                    
                    
                    validate(statusCode:)

Validates that the response has a status code in the specified sequence.

If validation fails, subsequent calls to response handlers will have an associated error.

Declaration

Swift

@discardableResult
public func validate<S>(statusCode acceptableStatusCodes: S) -> Self where S : Sequence, S.Element == Int

Parameters


                                acceptableStatusCodes

Sequence of acceptable response status codes.

Return Value

The instance.


                    
                    
                    validate(contentType:)

Validates that the response has a content type in the specified sequence.

If validation fails, subsequent calls to response handlers will have an associated error.

Declaration

Swift

@discardableResult
public func validate<S>(contentType acceptableContentTypes: @autoclosure @escaping () -> S) -> Self where S : Sequence, S.Element == String

Parameters


                                contentType

The acceptable content types, which may specify wildcard types and/or subtypes.

Return Value

The request.

validate()
Validates that the response has a status code in the default acceptable range of 200…299, and that the content type matches any specified in the Accept HTTP header field.

If validation fails, subsequent calls to response handlers will have an associated error.
Declaration
Swift

@discardableResult public func validate() -> Self
Return Value

The request.