Cfrtjryk

I recently started Swift and iOS development. After checking this cool tutorial for writing a small library for 2-way binding between views and data model, I decided to improve and simplify binding part. So I wrote a small observer/binder classes (based on idea on mentioned post, observer class is almost identical) to simplify binding. It works as expected, but since I'm new to iOS and Swift, I want someone to check if there is any crucial problems with my binding class. Here are classes:

class Observable<Object> {

    typealias ObservableDelegate = (Object)->Void



    var value: Object? {

        didSet {

            if let value = value {

                notify(newValue: value)

            }

        }

    }



    private var observers = [ObservableDelegate]()



    public init(_ value: Object? = nil) {

        self.value = value

    }



    func addObserver(_ delegate: @escaping ObservableDelegate) {

        observers.append(delegate)

    }



    private func notify(newValue value: Object) {

        for delegate in observers {

            delegate(value)

        }

    }

}



class ViewBindings {

    private class BindingEventHandler: NSObject {

        typealias BindingEventHandlerDelegate = () -> Void



        let target: BindingEventHandlerDelegate



        init(_ delegate: @escaping BindingEventHandlerDelegate) {

            target = delegate

            super.init()

        }



        @IBAction func valueChanged() {

            self.target()

        }

    }



    private var bindings = [BindingEventHandler]()



    func bind<KeyRoot,Value>(_ obj: NSObject, from: ReferenceWritableKeyPath<KeyRoot,Value>, to: Observable<Value>) where Value: Equatable {

        observeBind(obj, from: from, to: to)



        if let control = obj as? UIControl {

            let handler = BindingEventHandler {

                [weak obj, weak to] in

                if let _to = to {

                    if let val = (obj as? KeyRoot)?[keyPath: from], _to.value != val {

                        _to.value = val

                    }

                }

            }



            bindings.append(handler)

            control.addTarget(handler, action: #selector(BindingEventHandler.valueChanged), for: [.editingChanged, .valueChanged])

        }

    }



    func observeBind<KeyRoot,Value>(_ obj: NSObject, from: ReferenceWritableKeyPath<KeyRoot,Value>, to: Observable<Value>) where Value: Equatable {

        to.addObserver {

            value in

            DispatchQueue.main.async {

                [weak obj] in

                (obj as? KeyRoot)?[keyPath: from] = value

            }

        }

    }

}

And here is a simple use of my ViewBindings class:

class ViewController: UIViewController {

    @IBOutlet weak var textfield: UITextField!

    @IBOutlet weak var label: UILabel!



    let v1 = Observable<String?>()

    let binds = ViewBindings()



    override func viewDidLoad() {

        super.viewDidLoad()



        binds.bind(textfield, from: UITextField.text, to: v1)

        binds.bind(label, from: UILabel.text, to: v1)

    }



    @IBAction func btnpressed(_ sender: Any) {

        v1.value = "hello"

    }

}

Improvements in comparison with original post

1. In original implementation, you needed to extend control classes to conform to Bindable protocol, but it is not needed here.


2. You can add multiple bindings for 1 control easily here (currently bind one time and observeBind multiple times.

I have not added methods for removing binding yet, but what do you think about usability of current class using KeyPath? any obvious problem with this class?