├── README.md
├── BondExtensions.swift
├── RLMExtensions.swift
└── BRWrapper.swift


/README.md:
--------------------------------------------------------------------------------
1 | # Bond-Realm
2 | BondableRealm has migrated to https://github.com/Anvics/BondableRealm
3 | 


--------------------------------------------------------------------------------
/BondExtensions.swift:
--------------------------------------------------------------------------------
 1 | //
 2 | //  BondExtensions.swift
 3 | //  BondPlayground
 4 | //
 5 | //  Created by Nikita Arkhipov on 20.03.15.
 6 | //  Copyright (c) 2015 Anvix. All rights reserved.
 7 | //
 8 | 
 9 | import Foundation
10 | import Realm
11 | 
12 | func find<T where T:Equatable>(array: DynamicArray<T>, object: T) -> Int?{
13 |    for i in 0..<array.count{
14 |       if object == array[i] { return i }
15 |    }   
16 |    return nil
17 | }


--------------------------------------------------------------------------------
/RLMExtensions.swift:
--------------------------------------------------------------------------------
 1 | //
 2 | //  RLMExtensions.swift
 3 | //  BondPlayground
 4 | //
 5 | //  Created by Nikita Arkhipov on 20.03.15.
 6 | //  Copyright (c) 2015 Anvix. All rights reserved.
 7 | //
 8 | 
 9 | import Foundation
10 | import Realm
11 | 
12 | extension RLMRealm{
13 |    class func allObjects<T: RLMObject>(ofType: T.Type) -> [T]{
14 |       return T.allObjects()?.map { $0 as T } ?? []
15 |    }   
16 | }
17 | 
18 | extension RLMResults{   
19 |    func map<U>(transform: AnyObject -> U) -> [U]{
20 |       var array: [U] = []
21 |       for obj in self{
22 |          array.append(transform(obj))
23 |       }
24 |       return array
25 |    }
26 | }
27 | 
28 | extension RLMArray{   
29 |    func map<T>(transform: RLMObject -> T) -> [T]{
30 |       var array: [T] = []
31 |       for obj in self{
32 |          array.append(transform(obj))
33 |       }
34 |       return array
35 |    }
36 | }
37 | 
38 | 


--------------------------------------------------------------------------------
/BRWrapper.swift:
--------------------------------------------------------------------------------
  1 | //
  2 | //  BRWrapper.swift
  3 | //  BondPlayground
  4 | //
  5 | //  Created by Nikita Arkhipov on 20.03.15.
  6 | //  Copyright (c) 2015 Anvix. All rights reserved.
  7 | //
  8 | 
  9 | import Foundation
 10 | import Realm
 11 | 
 12 | protocol BRWrappable{
 13 |    init()
 14 |    init(realmModel: RLMObject)
 15 |    
 16 |    var backingModel: RLMObject! { get }
 17 |    class func realmModelType() -> RLMObject.Type
 18 | }
 19 | 
 20 | class BRWrapper: BRWrappable {
 21 |    
 22 |    let backingModel: RLMObject!
 23 |    private let realm = RLMRealm.defaultRealm()
 24 |    private let bonds = NSMutableArray()
 25 |    
 26 |    required init() {
 27 |       let T = self.dynamicType.realmModelType()
 28 |       backingModel = T()
 29 |       realm.beginWriteTransaction()
 30 |       realm.addObject(self.backingModel)
 31 |       realm.commitWriteTransaction()
 32 |       createBonds()
 33 |    }
 34 |    
 35 |    required init(realmModel: RLMObject){
 36 |       self.backingModel = realmModel
 37 |       createBonds()
 38 |    }
 39 |    
 40 |    final func createBondFrom<T>(from: Dynamic<T>, toModelKeyPath keyPath: String){
 41 |       createBondFrom(from,
 42 |          toModelKeyPath: keyPath,
 43 |          toRealmTransform: { $0 as NSObject },
 44 |          fromRealmTransform: { $0 as T })
 45 |    }
 46 | 
 47 |    final func createObjectBondFrom<T: BRWrappable>(from: Dynamic<T!>, toModelKeyPath keyPath: String){
 48 |       createBondFrom(from,
 49 |          toModelKeyPath: keyPath,
 50 |          toRealmTransform: { $0.backingModel },
 51 |          fromRealmTransform: { T(realmModel: $0 as RLMObject) })
 52 |    }
 53 | 
 54 |    final func createBondFrom<T>(from: Dynamic<T>, toModelKeyPath keyPath: String, toRealmTransform: T -> AnyObject, fromRealmTransform: AnyObject -> T){
 55 |       from.value = fromRealmTransform(backingModel.valueForKeyPath(keyPath)!)
 56 |       let bond = Bond<T>() { [unowned self] value in
 57 |          self.realm.beginWriteTransaction()
 58 |          self.backingModel.setValue(toRealmTransform(value), forKey: keyPath)
 59 |          self.realm.commitWriteTransaction()
 60 |       }
 61 |       from ->| bond
 62 |       bonds.addObject(bond)
 63 |    }
 64 |    
 65 |    final func staticObjectBondFor<T: BRWrappable>(type: T.Type, modelKeyPath keyPath: String) -> T{
 66 |       let model = backingModel.valueForKey(keyPath) as RLMObject
 67 |       return T(realmModel: model)
 68 |    }
 69 | 
 70 |    final func createArrayBondFrom<T: BRWrappable>(from: DynamicArray<T>, toModelKeyPath keyPath: String){
 71 |       createArrayBondFrom(from,
 72 |          toModelKeyPath: keyPath,
 73 |          toRealmTransform: { $0.backingModel },
 74 |          fromRealmTransform: { T(realmModel: $0) })
 75 |    }
 76 |    
 77 |    final func createArrayBondFrom<T>(from: DynamicArray<T>, toModelKeyPath keyPath: String, toRealmTransform: T -> RLMObject, fromRealmTransform: RLMObject -> T){
 78 |       let rlmarray = backingModel.valueForKey(keyPath) as RLMArray
 79 |       from.append(rlmarray.map(fromRealmTransform))
 80 |       
 81 |       let bond = ArrayBond<T>()
 82 |       bond.insertListener = { [unowned self] array, indices in
 83 |          self.realm.beginWriteTransaction()
 84 |          for index in indices.reverse(){
 85 |             rlmarray.addObject(toRealmTransform(array[index]))
 86 |          }
 87 |          self.realm.commitWriteTransaction()
 88 |       }
 89 |       
 90 |       bond.removeListener = { [unowned self] _, indices, _ in
 91 |          self.realm.beginWriteTransaction()
 92 |          for index in indices.reverse(){
 93 |             rlmarray.removeObjectAtIndex(UInt(index))
 94 |          }
 95 |          self.realm.commitWriteTransaction()
 96 |       }
 97 | 
 98 |       from ->| bond
 99 |       bonds.addObject(bond)
100 |    }
101 |    
102 |    func delete(){
103 |       realm.beginWriteTransaction()
104 |       realm.deleteObject(backingModel)
105 |       realm.commitWriteTransaction()
106 |    }
107 | 
108 |    //MARK: - Implement
109 |    class func realmModelType() -> RLMObject.Type{ fatalError("realmModelType() should be implemented in supreclass") }
110 |    func createBonds(){ fatalError("createBonds() should be implemented in supreclass") }
111 | }
112 | 
113 | extension RLMRealm{
114 |    class func allBondedObjects<T: BRWrappable>(ofType: T.Type) -> [T]{
115 |       return T.realmModelType().allObjects().map { T(realmModel: $0 as RLMObject) }
116 |    }
117 | }
118 | 
119 | func DynamicArrayFromAllObjectsOf<T: BRWrappable>(ofType: T.Type) -> DynamicArray<T>{
120 |    return DynamicArray(RLMRealm.allBondedObjects(ofType))
121 | }
122 | 
123 | 


--------------------------------------------------------------------------------