通用可解码，无需解码

Question

I am using a generic approach to decode JSONresponse generated by AlamoFire. My function is the following :

private func fetch<T: Swift.Decodable>(URLRequest: URLRequestConvertible) -> SignalProducer<T, NetworkError> {
    return Network.request(URLRequest)
        .attemptMap { JSON in
            do {
                let jsondata = try JSONSerialization.data(withJSONObject: JSON as! [String:Any], options: .prettyPrinted)
                return .success(try JSONDecoder().decode(T.self, from: jsondata))
            } catch let error {
                Logger.shared.error("Error while decoding a JSON", error: error as NSError, userInfo: ["json" : JSON,  "urlRequest" : URLRequest.urlRequest!.debugDescription])
                return .failure(.incorrectDataReturned)
            }
    }
}

For each of my request, I have created a struct that follows the Decodable protocol.

For one request, I do not want to decode the JSON because its structure is complex and because I just need to send it back in another request, I just want to save the response in a struct for instance like this one :

struct GenericResponse: Swift.Decodable {
    let data: Data
}

where data is the response. So, I just want to take the response and put it in a struct without further decoding.

Is it possible without braking the genericity of my function ? Is their a way to build a decoder that do not decode if T.self is of a certain type ?

Answer 1

If you want to avoid the decoding of a specific response, you can overload the fetch function to handle that case.

See the following example where the second fetch method is overloaded to save the response data inside a struct instead of going through the decoding process.

typealias JSON = [String: Any]

protocol RawResponse {
  init(data: Data)
}

// 1
func fetch<T: Decodable>(json: JSON) -> T? {
  guard let jsonData = try? JSONSerialization.data(withJSONObject: json, options: []),
    let response = try? JSONDecoder().decode(T.self, from: jsonData) else {
      return nil
  }
  return response
}

// 2
func fetch<T: RawResponse>(json: JSON) -> T? {
  guard let jsonData = try? JSONSerialization.data(withJSONObject: json, options: []) else {
    return nil
  }
  return T(data: jsonData)
}

With this overload, if a response struct conforms to RawResponse instead of Decodable (as we don't need to actually decode the data), the fetch overload is triggered.

struct UserResponse: Decodable {
  var username: String
}

let userJson: JSON = [
  "username": "someUser"
]
let user: UserResponse? = fetch(json: userJson) // call fetch #1
user?.username // someUser


struct GenericResponse: RawResponse {
  var data: Data
}

let notParsable: JSON = [
  "someKey": "someValue"
]
let rawData: GenericResponse? = fetch(json: notParsable) // call fetch #2
rawData?.data // 23 bytes

Answer 2

I dont really understand what you are trying to achieve. But I faced this situation where I needed to decode using Generics.

That is why I wrote a DecoderHelper class that enables me to decode Generic Array or Generic Object (depends on your JSON response).

Maybe it can inspire you, and you will find how to optimize it or understand your situation/issue.

final class DecoderHelper {

    static func decodeGenericObject<T: Decodable>(data: Data, completion : (Result<T, ErrorResult>) -> Void) {

        do {
            let decoder = JSONDecoder()
            let decodedData = try decoder.decode(T.self, from: data)
            completion(Result.success(decodedData))
        } catch {
            completion(Result.failure(.decoder(error: error)))
        }
    }

    static func decodeGenericArray<T: Decodable>(data: Data, completion : (Result<[T], ErrorResult>) -> Void) {

        do {
            let decoder = JSONDecoder()
            let decodedData = try decoder.decode([T].self, from: data)
            completion(Result.success(decodedData))
        } catch {
            completion(Result.failure(.decoder(error: error)))
        }
    }
}

PS: Why do you want to send it to an other request because "the JSON structure is too complex" ?

It's pretty simple to parse a JSON file now with the Codable protocol.

Give it a try and train yourself, now that I'm comfortable with it, I love parsing JSON.