Recursive function to replace json objects - swift

Question

I have this json file:
[
{
"person": {
"#id": "value1",
"name": "Mattia"
},
"person1": {
"#ref": "value1"
},
"subPersons": [
{
"#id": "value2",
"name": "Luca",
"key": {
"#ref": "value1"
}
},
{
"#ref": "value1"
},
{
"#id": "value3",
"subsubPersons": [
{
"again": {
"#ref": "value2"
}
}
]
}
],
"key": {
"subKey": {
"#ref": "value1"
}
}
}
]
I need to map all objects that contains a #id so replace all #ref values with related #id values mapped. I'd like to obtain this:
[
{
"person": {
"#id": "value1",
"name": "Mattia"
},
"person1": {
"#id": "value1",
"name": "Mattia"
},
"subPersons": [
{
"#id": "value2",
"name": "Luca",
"key": {
"#id": "value1",
"name": "Mattia"
}
},
{
"#id": "value1",
"name": "Mattia"
},
{
"#id": "value3",
"subsubPersons": [
{
"again": {
"#id": "value2",
"name": "Luca",
"key": {
"#id": "value1",
"name": "Mattia"
}
}
}
]
}
],
"key": {
"subKey": {
"#id": "value1",
"name": "Mattia"
}
}
}
]
I'm using this class to replace values:
import UIKit
import Alamofire
import AlamofireObjectMapper
import ObjectMapper
import SwiftyJSON
import SwiftDate
import Async
class FindAndReplace {
var ids = Dictionary<String, JSON>()
var dictChanged = Dictionary<String, JSON>()
var isDictInit: Bool = false
/*
* Find and Replace
*/
func findAndReplace (json: JSON) -> JSON {
findJSOGids(json)
let replaced = replaceJSOGrefs(json, ids: ids)
return replaced
}
/*
* Find "#id" keys and map values related
*/
func findJSOGids (value: JSON) {
for (key, subJson): (String, JSON) in value {
if (key == "#id") {
let mValueForKey = value[key].stringValue
ids[mValueForKey] = value
}
if (subJson.type == Type.Dictionary || subJson.type == Type.Array) {
findJSOGids(subJson)
}
}
}
/*
* Replace "#ref" keys with fields mapped in ids
*/
func replaceJSOGrefs (var value: JSON, var ids: Dictionary<String, JSON>) -> JSON {
if (value.type == Type.Dictionary) {
var result = Dictionary<String, JSON> ()
for (key, subJson): (String, JSON) in value {
if (key == "#ref") {
let mValueForKey = value[key].stringValue
var isReplaced = false
while (isReplaced == false) {
for (idKey, _): (String, JSON) in ids[mValueForKey]! {
if (idKey == "#ref") {
print("found a #ref in dictionary")
let dictValueReplaced = replaceJSOGrefs(ids[mValueForKey]!, ids: ids)
ids.updateValue(dictValueReplaced, forKey: mValueForKey)
}
}
}
return ids[mValueForKey]!
} else {
result[key] = replaceJSOGrefs(subJson, ids: ids)
}
}
return JSON(result)
} else if (value.type == Type.Array) {
var result = [JSON]()
for (_, subJson): (String, JSON) in value {
result.append(replaceJSOGrefs(subJson, ids: ids))
}
return JSON(result)
} else {
return value
}
}
}
It works but it misses some #ref values.
Can someone please help me?
Thanks in advance.
Edit
I'm using ObjectMapper to map objects.

Answer 1

I think that find-replace approach won't be as efficient since you'll have to do many passes on your data (until you can't find any #ref strings).
You should probably leverage the fact that your JSON models reference types semantics (as oppose to value types) and parse it as such, keeping #ref in the parsed objects as faulted references. Every object you parse you should add in the cache that can be referenced by #id. Then in the second pass you'll go through your cache rewiring each reference to using the cache you just built as a lookup table.
If every model implements following protocol
protocol RefObject {
func updateReferences(using cache: [String: RefObject])
}
you can implement it per-model to have a custom rewiring logic per each model class. Here are few examples of such model classes:
For a wildcard represented by just {"#ref": "xxx"} in JSON I'd create a pointer class that would simply point to the referred object.
class Pointer: RefObject {
let referredId: String
var referred: RefObject!
init(referedId: String) {
self.referredId = referredId
}
func updateReferences(using cache: [String : RefObject]) {
self.referred = cache[referredId]
}
}
For a person you can implement something similar to
class Person: RefObject {
let id: String
let name: String
var otherId: String?
var other: Person?
init(id: String, name: String, otherId: String?) {
self.id = id
self.name = name
self.otherId = otherId
}
func updateReferences(using cache: [String : RefObject]) {
other = otherId.flatMap{ cache[$0] as? Person }
}
}
(this assumes that person can have {"id": "xx", "name": "xx", "other": {"#ref": "xx"}} where "other" is other is optional
This is a general approach and not a particular implementation, but it would be very domain specific depending on your needs.
Update there is a similar protocol called JSON API (misleading name IMO, but it utilizes the same approach of referencing JSON objects by id). Here is an implementation in Swift: https://github.com/wvteijlingen/spine it might be worth checking it out