Relationship vs RxCoreData about rxcoredata HOT 9 OPEN

public struct Parrent {
    var id: String
    var name: String
    var kids: Set<Kid> = Set<Kid>()

    init(id: String, name: String, kids: Set<Kid>) {
        self.id = id
        self.name = name
        self.kids = kids
    }
}
extension Parrent: Equatable {}
public func == (lhs: Parrent, rhs: Parrent) -> Bool {
    return lhs.id == rhs.id
}
extension Parrent: Persistable {  
    public typealias T = NSManagedObject
    
    public static var entityName: String {
        return "Parrent"
    }
    
    public static var primaryAttributeName: String {
        return "id"
    }
    
    
    public init(entity: T) {
        self.id = entity.value(forKey: "id") as! String
        self.name = entity.value(forKey: "neme") as! String
        let kidsEntitySet = entity.value(forKey: "kids") as! Set<Kid.T>
        self.kids = Set<Kid>(kidsEntitySet.map { kidEntity in
            Kid(entity: kidEntity)
        })
    }
    
    public func update(_ entity: T) {
        entity.setValue(self.id, forKey: "id")
        let etityArray: Array<Kid.T>! = self.kids.map { kid in
            //he you have to use your own instance of managedObjectContext, this wont compile for you otherwise everithing should work
            let emptyEntity = coreDataStack.managedObjectContext.rx.getOrCreateEntity(for: kid)
            kid.update(emptyEntity)
            return emptyEntity
        }
        entity.setValue(Set<Kid.T>(etityArray), forKey: "kids")
        do {
            try entity.managedObjectContext?.save()
        } catch let e {
            print(e)
        }
    }
}

extension Parrent: IdentifiableType {
    
    public typealias Identity = String
    public var identity: Identity { return id }
}

public struct Kid {
    var id: String
    var name: String
    
    init(id: String, name: String) {
        self.id = id
        self.name = name
    }
}

public func == (lhs: Kid, rhs: Kid) -> Bool {
    return lhs.id == rhs.id
}

extension Kid: Equatable {}

extension Kid: Hashable {
    public var hashValue: Int {
        return self.id.hashValue
    }
}

extension Kid: IdentifiableType {
    
    public typealias Identity = String
    public var identity: Identity { return id }
}

extension Kid: Persistable {
    
    public typealias T = NSManagedObject
    
    public static var entityName: String {
        return "Parrent"
    }
    public static var primaryAttributeName: String {
        return "id"
    }
    public init(entity: T) {
        self.id = entity.value(forKey: "id") as! String
        self.name = entity.value(forKey: "neme") as! String
    }
    public func update(_ entity: T) {
        entity.setValue(self.id, forKey: "id")
        entity.setValue(self.name, forKey: "name")
        do {
            try entity.managedObjectContext?.save()
        } catch let e {
            print(e)
        }
    }
}
public extension Reactive where Base: NSManagedObjectContext {
    public func create<E: Persistable>(_ type: E.Type = E.self) -> E.T {
        return NSEntityDescription.insertNewObject(forEntityName: E.entityName, into: self.base) as! E.T
    }
    
    public func get<P: Persistable>(_ persistable: P) throws -> P.T? {
        let fetchRequest: NSFetchRequest<P.T> = NSFetchRequest(entityName: P.entityName)
        fetchRequest.predicate = NSPredicate(format: "%K = %@", P.primaryAttributeName, persistable.identity)
        let result = (try self.base.execute(fetchRequest)) as! NSAsynchronousFetchResult<P.T>
        return result.finalResult?.first
    }
    
    public func getOrCreateEntity<K: Persistable>(for persistable: K) -> K.T {
        if let reusedEntity = try? self.get(persistable), reusedEntity != nil {
            return reusedEntity!
        } else {
            return self.create(K.self)
        }
    }
}