extension Observable {
public static func zip
(source1: O1, _ source2: O2, _ source3: O3, _ source4: O4, _ source5: O5, _ source6: O6, _ source7: O7, _ source8: O8, resultSelector: (O1.E, O2.E, O3.E, O4.E, O5.E, O6.E, O7.E, O8.E) throws -> E)
-> Observable
return Zip8(
source1: source1.asObservable(), source2: source2.asObservable(), source3: source3.asObservable(), source4: source4.asObservable(), source5: source5.asObservable(), source6: source6.asObservable(), source7: source7.asObservable(), source8: source8.asObservable(),
resultSelector: resultSelector
)
}
}
class ZipSink8_ : ZipSink {
typealias R = O.E
typealias Parent = Zip8
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)
var _values7: Queue = Queue(capacity: 2)
var _values8: Queue = Queue(capacity: 2)
init(parent: Parent, observer: O) {
_parent = parent
super.init(arity: 8, 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
case 6: return _values7.count > 0
case 7: return _values8.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 subscription7 = SingleAssignmentDisposable()
let subscription8 = 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)
let observer7 = ZipObserver(lock: _lock, parent: self, index: 6, setNextValue: { self._values7.enqueue($0) }, this: subscription7)
let observer8 = ZipObserver(lock: _lock, parent: self, index: 7, setNextValue: { self._values8.enqueue($0) }, this: subscription8)
subscription1.disposable = _parent.source1.subscribe(observer1)
subscription2.disposable = _parent.source2.subscribe(observer2)
subscription3.disposable = _p arent.source3.subscribe(observer3)
subscription4.disposable = _parent.source4.subscribe(observer4)
subscription5.disposable = _parent.source5.subscribe(observer5)
subscription6.disposable = _parent.source6.subscribe(observer6)
subscription7.disposable = _parent.source7.subscribe(observer7)
subscription8.disposable = _parent.source8.subscribe(observer8)
return CompositeDisposable(disposables: [
subscription1,
subscription2,
subscription3,
subscription4,
subscription5,
subscription6,
subscription7,
subscription8
])
}
override func getResult() throws -> R {
return try _parent._resultSelector(_values1.dequeue()!, _values2.dequeue()!, _values3.dequeue()!, _values4.dequeue()!, _values5.dequeue()!, _values6.dequeue()!, _values7.dequeue()!, _values8.dequeue()!)
}
}
class Zip8 : Producer {
typealias ResultSelector = (E1, E2, E3, E4, E5, E6, E7, E8) throws -> R
let source1: Observable
let source2: Observable
let source3: Observable
let source4: Observable
let source5: Observable
let source6: Observable
let source7: Observable
let source8: Observable
let _resultSelector: ResultSelector
init(source1: Observable, source2: Observable, source3: Observable, source4: Observable, source5: Observable, source6: Observable, source7: Observable, source8: Observable, resultSelector: ResultSelector) {
self.source1 = source1
self.source2 = source2
self.source3 = source3
self.source4 = source4
self.source5 = source5
self.source6 = source6
self.source7 = source7
self.source8 = source8
_resultSelector = resultSelector
}
override func run(observer: O) -> Disposable {
let sink = ZipSink8_(parent: self, observer: observer)
sink.disposable = sink.run()
return sink
}
}