RxSwift 클론하기

MyObservable.swift

//
//  MyObservable.swift
//  RxJavaExample
//
//  Created by Chiwon Song
//

import Foundation

class MyObservable<T> {
    private var valueMaker: ((@escaping (T) -> Void) -> Void)?

    private init(valueMaker: @escaping (_ receiver: @escaping (T) -> Void) -> Void) {
        self.valueMaker = valueMaker
    }
    
    static func create(_ maker: @escaping (_ receiver: @escaping (T) -> Void) -> Void) -> MyObservable<T> {
        return MyObservable(valueMaker: maker)
    }

    func subscribe(_ receiver: @escaping (T) -> Void) {
        guard let valueMaker = valueMaker else {
            fatalError("valueMaker is nil")
        }
        valueMaker(receiver)
    }
}

extension MyObservable {
    static func just(_ value: T) -> MyObservable<T> {
        return MyObservable<T> { receiver in
            DispatchQueue.global().async {
                receiver(value)
            }
        }
    }
}

extension MyObservable {
    static func from(_ value: [T]) -> MyObservable<T> {
        return MyObservable<T> { receiver in
            value.forEach { t in
                DispatchQueue.global().async {
                    receiver(t)
                }
            }
        }
    }
}

extension MyObservable {
    func filter(_ filter: @escaping (T) -> Bool) -> MyObservable<T> {
        return MyObservable<T> { receiver in
            self.subscribe { t in
                if filter(t) {
                    DispatchQueue.global().async {
                        receiver(t)
                    }
                }
            }
        }
    }
}

extension MyObservable {
    func map<U>(_ mapper: @escaping (T) -> U) -> MyObservable<U> {
        return MyObservable<U> { receiver in
            self.subscribe { t in
                DispatchQueue.global().async {
                    receiver(mapper(t))
                }
            }
        }
    }
}

extension MyObservable {
    func flatMap<U>(_ mapper: @escaping (T) -> MyObservable<U>) -> MyObservable<U> {
        return MyObservable<U> { receiver in
            self.subscribe { t in
                mapper(t).subscribe { u in
                    DispatchQueue.global().async {
                        receiver(u)
                    }
                }
            }
        }
    }
}

extension MyObservable {
    func filterNil<U>() -> MyObservable<U> where T == U? {
        return filter { $0 != nil }.map { $0! }
    }
}

extension MyObservable {
    func main() -> MyObservable<T> {
        return MyObservable<T> { receiver in
            self.subscribe { t in
                DispatchQueue.main.async {
                    receiver(t)
                }
            }
        }
    }
}