map 解析
Observable.of(1, 2, 3)
.map {
$0 * $0
}
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
Map.swift
extension ObservableType
public func map<R>(_ transform: @escaping (E) throws -> R)
-> Observable<R> {
return self.asObservable().composeMap(transform)
}
Observable.swift
public class Observable<Element> : ObservableType
public func asObservable() -> Observable<E> {
return self
}
Observable.swift
public class Observable<Element> : ObservableType
internal func composeMap<R>(_ transform: @escaping (Element) throws -> R) -> Observable<R> {
return _map(source: self, transform: transform)
}
//纯函数
internal func _map<Element, R>(source: Observable<Element>, transform: @escaping (Element) throws -> R) -> Observable<R> {
return Map(source: source, transform: transform)
}
final fileprivate class Map<SourceType, ResultType>: Producer<ResultType>
init(source: Observable<SourceType>, transform: @escaping Transform) {
_source = source
_transform = transform
#if TRACE_RESOURCES
let _ = AtomicIncrement(&_numberOfMapOperators)
#endif
}
----------------------
.subscribe(onNext: {
print($0)
}
extension ObservableType
public func subscribe(onNext: ((E) -> Void)? = nil, onError: ((Swift.Error) -> Void)? = nil, onCompleted: (() -> Void)? = nil, onDisposed: (() -> Void)? = nil)
class Producer<Element> : Observable<Element>
override func subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == Element
return CurrentThreadScheduler.instance.schedule(()) { _ in
let disposer = SinkDisposer()
let sinkAndSubscription = self.run(observer, cancel: disposer)
disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)
return disposer
}
final fileprivate class Map<SourceType, ResultType>: Producer<ResultType>
override func run<O: ObserverType>(_ observer: O, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where O.E == ResultType {
let sink = MapSink(transform: _transform, observer: observer, cancel: cancel)
let subscription = _source.subscribe(sink)
return (sink: sink, subscription: subscription)
}
class Producer<Element> : Observable<Element>
override func subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == Element {
if !CurrentThreadScheduler.isScheduleRequired {
// The returned disposable needs to release all references once it was disposed.
let disposer = SinkDisposer()
let sinkAndSubscription = run(observer, cancel: disposer)
disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)
return disposer
}
final fileprivate class MapSink<SourceType, O : ObserverType> : Sink<O>, ObserverType
init(transform: @escaping Transform, observer: O, cancel: Cancelable) {
_transform = transform
super.init(observer: observer, cancel: cancel)
}
-----------------------------
map {
$0 * $0
}
final fileprivate class ObservableSequenceSink<S: Sequence, O: ObserverType> : Sink<O> where S.Iterator.Element == O.E
func run() -> Disposable {
return _parent._scheduler.scheduleRecursive((_parent._elements.makeIterator(), _parent._elements)) { (iterator, recurse) in
var mutableIterator = iterator
if let next = mutableIterator.0.next() {
self.forwardOn(.next(next))
recurse(mutableIterator)
}
else {
self.forwardOn(.completed)
self.dispose()
}
}
}
class Sink<O : ObserverType> : Disposable
final func forwardOn(_ event: Event<O.E>) {
#if DEBUG
_synchronizationTracker.register(synchronizationErrorMessage: .default)
defer { _synchronizationTracker.unregister() }
#endif
if _disposed {
return
}
_observer.on(event)
}
final fileprivate class MapSink<SourceType, O : ObserverType> : Sink<O>, ObserverType
func on(_ event: Event<SourceType>) {
switch event {
case .next(let element):
do {
let mappedElement = try _transform(element)
forwardOn(.next(mappedElement))
}
catch let e {
forwardOn(.error(e))
dispose()
}
case .error(let error):
forwardOn(.error(error))
dispose()
case .completed:
forwardOn(.completed)
dispose()
}
}
$0 * $0
---------------------------
print($0)
final fileprivate class MapSink<SourceType, O : ObserverType> : Sink<O>, ObserverType
func on(_ event: Event<SourceType>) {
switch event {
case .next(let element):
do {
let mappedElement = try _transform(element)
forwardOn(.next(mappedElement))
}
catch let e {
forwardOn(.error(e))
dispose()
}
case .error(let error):
forwardOn(.error(error))
dispose()
case .completed:
forwardOn(.completed)
dispose()
}
}
class Sink<O : ObserverType> : Disposable
final func forwardOn(_ event: Event<O.E>) {
#if DEBUG
_synchronizationTracker.register(synchronizationErrorMessage: .default)
defer { _synchronizationTracker.unregister() }
#endif
if _disposed {
return
}
_observer.on(event)
}
class ObserverBase<ElementType> : Disposable, ObserverType
func on(_ event: Event<E>) {
switch event {
case .next:
if _isStopped == 0 {
onCore(event)
}
case .error, .completed:
if AtomicCompareAndSwap(0, 1, &_isStopped) {
onCore(event)
}
}
}
final class AnonymousObserver<ElementType> : ObserverBase<ElementType>
override func onCore(_ event: Event<Element>) {
return _eventHandler(event)
}
extension ObservableType
public func subscribe(onNext: ((E) -> Void)? = nil, onError: ((Swift.Error) -> Void)? = nil, onCompleted: (() -> Void)? = nil, onDisposed: (() -> Void)? = nil)
let observer = AnonymousObserver<E> { event in
synchronizationTracker.register(synchronizationErrorMessage: .default)
defer { synchronizationTracker.unregister() }
switch event {
case .next(let value):
onNext?(value)
case .error(let error):
if let onError = onError {
onError(error)
}
else {
Hooks.defaultErrorHandler(callStack, error)
}
disposable.dispose()
case .completed:
onCompleted?()
disposable.dispose()
}
}
print($0)
