zip6运算

extension Observable {
    public static func zip
    (source1: O1, _ source2: O2, _ source3: O3, _ source4: O4, _ source5: O5, _ source6: O6, resultSelector: (O1.E, O2.E, O3.E, O4.E, O5.E, O6.E) throws -> E)
    -> Observable {
        return Zip6(
            source1: source1.asObservable(), source2: source2.asObservable(), source3: source3.asObservable(), source4: source4.asObservable(), source5: source5.asObservable(), source6: source6.asObservable(),
            resultSelector: resultSelector
        )
    }
}

class ZipSink6_ : ZipSink {
    typealias R = O.E
    typealias Parent = Zip6

    let _parent: Parent

    var _values1: Queue = Queue(capacity: 2)
    var _values2: Queue = Queue(capacity: 2)
    var _values3: Queue = Queue(capacity: 2)
    var _values4: Queue = Queue(capacity: 2)
    var _values5: Queue = Queue(capacity: 2)
    var _values6: Queue = Queue(capacity: 2)

    init(parent: Parent, observer: O) {
        _parent = parent
        super.init(arity: 6, observer: observer)
    }

    override func hasElements(index: Int) -> Bool {
        switch (index) {
        case 0: return _values1.count > 0
        case 1: return _values2.count > 0
        case 2: return _values3.count > 0
        case 3: return _values4.count > 0
        case 4: return _values5.count > 0
        case 5: return _values6.count > 0

        default:
            rxFatalError("Unhandled case (Function)")
        }

        return false
    }

    func run() -> Disposable {
        let subscription1 = SingleAssignmentDisposable()
        let subscription2 = SingleAssignmentDisposable()
        let subscription3 = SingleAssignmentDisposable()
        let subscription4 = SingleAssignmentDisposable()
        let subscription5 = SingleAssignmentDisposable()
        let subscription6 = SingleAssignmentDisposable()

        let observer1 = ZipObserver(lock: _lock, parent: self, index: 0, setNextValue: { self._values1.enqueue($0) }, this: subscription1)
        let observer2 = ZipObserver(lock: _lock, parent: self, index: 1, setNextValue: { self._values2.enqueue($0) }, this: subscription2)
        let observer3 = ZipObserver(lock: _lock, parent: self, index: 2, setNextValue: { self._values3.enqueue($0) }, this: subscription3)
        let observer4 = ZipObserver(lock: _lock, parent: self, index: 3, setNextValue: { self._values4.enqueue($0) }, this: subscription4)
        let observer5 = ZipObserver(lock: _lock, parent: self, index: 4, setNextValue: { self._values5.enqueue($0) }, this: subscription5)
        let observer6 = ZipObserver(lock: _lock, parent: self, index: 5, setNextValue: { self._values6.enqueue($0) }, this: subscription6)

        subscription1.disposable = _parent.source1.subscribe(observer1)
        subscription2.disposable = _parent.source2.subscribe(observer2)
        subscription3.disposable = _parent.source3.subscribe(observer3)
       subscription4.disposable = _parent.source4.subscribe(observer4)
        subscription5.disposable = _parent.source5.subscribe(observer5)
        subscription6.disposable = _parent.source6.subscribe(observer6)

        return CompositeDisposable(disposables: [
           subscription1,
           subscription2,
           subscription3,
           subscription4,
           subscription5,
           subscription6
        ])
    }

    override func getResult() throws -> R {
        return try _parent._resultSelector(_values1.dequeue()!, _values2.dequeue()!, _values3.dequeue()!, _values4.dequeue()!, _values5.dequeue()!, _values6.dequeue()!)
    }
}

class Zip6 : Producer {
    typealias ResultSelector = (E1, E2, E3, E4, E5, E6) throws -> R

    let source1: Observable
    let source2: Observable
    let source3: Observable
    let source4: Observable
    let source5: Observable
    let source6: Observable

    let _resultSelector: ResultSelector

    init(source1: Observable, source2: Observable, source3: Observable, source4: Observable, source5: Observable, source6: Observable, resultSelector: ResultSelector) {
        self.source1 = source1
        self.source2 = source2
        self.source3 = source3
        self.source4 = source4
        self.source5 = source5
        self.source6 = source6

        _resultSelector = resultSelector
    }

    override func run(observer: O) -> Disposable {
        let sink = ZipSink6_(parent: self, observer: observer)
        sink.disposable = sink.run()
        return sink
    }
}