iOS ObjectMapper incremental updating - ios

Question

I have a problem with my project, when my App starts, the configuration is automatically updated from the server, the json from server like this:
{
"version":1
"config":
{
"key1": {xxx}
"key2": {xxx}
"key3": {xxx}
"key4": {xxx}
"key5": {xxx}
"key6": {xxx}
}
And I use the ObjectMapper to convert json to model, like this:
struct GlobalConfig: Mappable {
var version = 0
var key1: [String: [LocalizedText]]?
var key2: [RouteObject]?
var key3: UrlConfig?
var key4: [String: [String: [[String: Any]]]]?
var key5: DegreeInfoList?
var key6: [String: String]?
init?(map: Map) { }
mutating func mapping(map: Map) {
version <- map["version"]
key1 <- map["key1"]
key2 <- map["key2"]
key3 <- map["key3"]
key4 <- map["key4"]
key5 <- map["key5"]
key6 <- map["key6"]
}
Now there is a problem, when the json from server is large, it will consume a lot of traffic. In fact, some configurations do not need to be updated. So the json from server will like this:
{
"version":2
"config":
{
"key1": {xxx}
"key2": {xxx}
}
It means key1 and key2 will be updated, key3, key4, key5 and key6 keep the old values.
How to handle the JSON?

Answer 1

I don't understand what's the Mapper object is. It can be done with Codable.
You can do like this to update your local config with incoming config.
struct GlobalConfig: Codable {
var version = 0
var key1: [String: [LocalizedText]]?
var key2: [RouteObject]?
var key3: UrlConfig?
var key4: [String: [String: [[String: Any]]]]?
var key5: DegreeInfoList?
var key6: [String: String]?
mutating func combine(with config: GlobalConfig) {
if let k = config.key1 { key1 = k }
if let k = config.key2 { key2 = k }
...
}
}
class App {
var config: GlobalConfig
func receiveConfig(newConfig: GlobalConfig) {
config.combine(with: newConfig)
}
}
Edited :
In response to comment, here a possible solution for 'deep' combine.
Very roughly :
extension Dictionary {
func combine(with dictionary: Dictionary) {
}
}
extension Array {
func combine(with array: Array) {
}
}
protocol Combinable: Codable {
func combine(with object: Self)
}
struct GlobalConfig: Combinable {
var version = 0
var key1: [String: [LocalizedText]]?
var key2: [RouteObject]?
mutating func combine(with config: GlobalConfig) {
if let k = config.key1 { key1.combine(with: k) }
if let k = config.key2 { key2.combine(with: k) }
...
}
}
This is another subject, but types like [String: [String: [[String: Any]]]] should be avoided.
It is hard to read, debug, and combine ;)
I think it is better to use structured sub-models. Much safer, scalable and 'documentable'.
struct GlobalConfig: Codable {
...
// Old format: var key4: [String: [String: [[String: Any]]]]?
var key4: MegaSettings?
...
}
struct MegaSettings: Combinable {
struct ScreenOptions: Combinable {
var options: [String: Any]
}
struct DisplayOptions: Combinable {
struct DeviceDisplayOptions {
var screen: [ScreenOptions]
}
var optionsPerDevice: [String: DeviceDisplayOptions]
}
var displayOptions: [String: DisplayOptions]
}