Verschiedene Typen JSON-Datei mit ObjectMapper

Question

Ich verwende AlamofireObjectMapper, um mit einem Back-End-Server zu kommunizieren. Das Ergebnis von einem der Anforderungen wird ein Array von Elementen, die zwei Werte enthalten:

• A „typeIdentifier“ angibt, welche Art von Daten des zweiten Wert („arbitraryData“ bezeichnet) ist von
• A „arbitraryData“ :
  • Wenn "typeIdentifier" enthält "X", arbitraryData vom Typ ArbitraryDataTypeX
  • Wenn "typeIdentifier" enthält "Y" ist, wird vom Typ arbitraryData ArbitraryDataTypeY

Die beiden ArbitraryDataType-Klassen teilen keine gemeinsamen Vorfahren (außer Mappable). Es könnte sogar ein primitiver Typ, ein Array, ein optionales usw. sein.

Wie kann ich AlamofireObjectMapper veranlassen, das Feld "arbiquiaryData" mit dem entsprechenden Typ zu analysieren.

Siehe folgende JSON-Datei:

{ 
    "arrayOfItems": [ 
     { 
      "typeIdentifier": "X", 
      "arbitraryData": 
       { 
        "value": "BLA", 
       } 
     }, 
     { 
      "typeIdentifier": "Y", 
      "arbitraryData": 
       { 
        "anotherValue": "BLUBB", 
       } 
     } 
    ] 
} 

Meine entsprechenden Swing-Datei sieht wie folgt aus:

class Item : Mapping { 
    var typeIdentifier = "X" 
    var arbitraryData: Mappable? = nil 

    init?(_ map: Map) { 
     self.init() 
     mapping(map) 
    } 

    func mapping(map: Map) { 
     typeIdentifier <- map["typeIdentifier"] 

     // THIS LINE CONTAINS MY QUESTION: HOW CAN I TELL OBJECTMAPPER, THAT, 
     // IF typeIdentifier CONTAINS "X", arbitraryData IS OF TYPE 
     // ArbitraryDataTypeX, AND IF "Y" arbitraryData IS OF TYPE 
     // ArbitraryDataTypeY? 
     arbitraryData <- map["arbitraryData"] 
    } 
} 

class ArbitraryDataTypeX : Mapping { 
    var value = "BLA" 

    init?(_ map: Map) { 
     self.init() 
     mapping(map) 
    } 

    func mapping(map: Map) { 
     value <- map["value"] 
    } 
} 

class ArbitraryDataTypeY : Mapping { 
    var anotherValue = "BLUBB" 

    init?(_ map: Map) { 
     self.init() 
     mapping(map) 
    } 

    func mapping(map: Map) { 
     anotherValue <- map["anotherValue"] 
    } 
} 

Hintergrundinformationen: Ich bin mit AlamofireObjectMapper mit einem Back-End-Server zu kommunizieren. Das Ergebnis einer der Anforderungen ist ein Array von Item. Der typeIdentifier-Mechanismus (in der Tat ist es ein wenig komplexer, aber lassen Sie uns das auslassen) wird vom Backend gegeben und kann nicht geändert werden.

Answer 1

Ok, fand ich eine Lösung (ich weiß nicht, warum ich es nicht von Anfang an gesehen haben):

// This is Item.map() 
func mapping(map: Map) { 
    typeIdentifier <- map["typeIdentifier"] 

    switch typeIdentifier { 
    case "X": 
     let x: X? 
     x <- map["arbitraryData"] 
     arbitraryData = x 
    case "Y": 
     let y: Y? 
     y <- map["arbitraryData"] 
     arbitraryData = y 
    default: 
     arbitraryData = nil 
    } 
}