ComplexValue

Decode the encoded data from the Decoder object and insantiate a new ComplexValue object from it.

Encode the object instance

open func encodeComplexValueExample() throws -> Void {
let provider = OnlineODataProvider(serviceName: "TripPinService",
    serviceRoot: "http://services.odata.org/TripPinRESTierService/")
let service = TripPinServiceProxy(provider: provider)

let query = DataQuery()
let complexValueToBeEncoded = try service.fetchPeople(matching: query).first?.addressInfo.first //get a ComplexValue
// Encode the EntityValue with JSONEncoder (other encoder exists such as PropertyListEncoder)
let encoder = JSONEncoder()
if let encodedComplexValue = try? encoder.encode(complexValueToBeEncoded!) {
    if let json = String(data: encodedComplexValue, encoding: .utf8){
        print(json)
     }
    // Decoding
    // JSONDecoder is used, but other decoders are available, such as PropertyListDecoder
    let decoder = JSONDecoder()
    // Add typeInfo to the decoder
    decoder.userInfo[CSDLDocument.csdlInfoKey] = service.metadata
    //Decode
    let decodedComplexValue = try? decoder.decode(ComplexValue.self, from: encodedComplexValue)
}
}

Example of encode/decode of a ComplexValue using dynamic API

open func encodeComplexValueExample() throws -> Void {
    let provider = OnlineODataProvider(serviceName: "TripPinService",
        serviceRoot: "http://services.odata.org/TripPinRESTierService/")
    let service = TripPinServiceProxy(provider: provider)

    // Explicitly load metadata, then it must be cached manually.
    // The reason is, that type infos will not be implicitly encoded, but it will be needed at the encoding.
        // The dataservice's metadata contains all such type infos, so metadata will be first loaded then cached.
        service.serviceOptions.csdlOptions = ( service.serviceOptions.csdlOptions |
         CSDLOption.retainResolvedText | CSDLOption.retainOriginalText )
        try service.loadMetadata()
        let metadataCachedAsString = service.metadata.originalText! //

       // Get the entity to be encoded by dynamic API
        let peopleEntitySet = service.entitySet(withName: "People")
        let query = DataQuery().from(peopleEntitySet)
        let entityValue = try service.executeQuery(query).entityList().first()
        let personEntityType = service.metadata.entityType(withName: "Microsoft.OData.Service.Sample.TrippinInMemory.Models.Person")
        let propType = personEntityType.property(withName: "AddressInfo")
       let complexValueToBeEncoded = propType.complexList(from: entityValue).first() //get a ComplexValue

        // Encode the EntityValue with JSONEncoder (other encoder exists such as PropertyListEncoder)
        let encoder = JSONEncoder()
        if let encodedComplexValue = try? encoder.encode(complexValueToBeEncoded) {
         if let json = String(data: encodedComplexValue, encoding: .utf8){
             print(json) // Check
        }

         // Decoding
         // JSONDecoder is used, but other decoders are available, such as PropertyListDecoder
        let decoder = JSONDecoder()

         // Get type infos from cached metadata parsing it to CSDLDocument
         let parser: CSDLParser = CSDLParser()
         parser.csdlOptions = (CSDLOption.processMixedVersions | CSDLOption.retainOriginalText |
             CSDLOption.resolveUndefinedTerms)
         var csdlDocument: CSDLDocument = parser.parseInProxy(metadataCachedAsString, url: "")

         // Add typeInfo to the decoder
        decoder.userInfo[CSDLDocument.csdlInfoKey] = csdlDocument

         // Decode
         let decodedComplexValue = try? decoder.decode(ComplexValue.self, from: encodedComplexValue)
        }
}

Construct a new complex value. This constructor is intended for use by custom complex value subclasses. Use ofType for regular construction.

The complex type metadata for this value (dataType cast to ComplexType).

Copy structural/dynamic property values from source complex value into this complex value.

Data type with a DataType.code of DataType.COMPLEX_VALUE.

Construct a new complex value of the specified type.

Contains the original values for all structural properties of this complex value. Used by DataService.updateEntity to determine the changed properties for PATCH requests.

The complex type metadata for this value (dataType cast to StructureType).

Convert this data value to a string. If the dataType is defined by XML Schema Part 2: Datatypes, then the corresponding lexical format is used. JSON format is used for structured values (arrays and objects).

Data type code of the wrapped value, equivalent to dataType.code.