ReactiveX/RxSwift
1
1
Fork 0
mirror of https://github.com/ReactiveX/RxSwift.git synced 2024-10-04 05:57:23 +03:00
Code Issues Projects Releases Wiki Activity

Moves public interface in the same file as implementation and adds final fileprivate modifiers.

Browse Source
This commit is contained in:
Krunoslav Zaher 2017-04-29 16:06:31 +02:00
parent f86e0b983a
commit 4fd80ac0b5
No known key found for this signature in database
GPG Key ID: 74BC718B68EA3842
87 changed files with 1962 additions and 2246 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
.jazzy.yml
View File

@ -52,7 +52,6 @@ custom_categories:
children:
- AddRef
- Amb
- AnonymousObservable
- AsMaybe
- AsSingle
- Buffer
@ -62,6 +61,7 @@ custom_categories:
- CombineLatest
- Concat
- ConnectableObservable
- Create
- Debounce
- Debug
- DefaultIfEmpty
@ -84,12 +84,10 @@ custom_categories:
- Multicast
- Never
- ObserveOn
- ObserveOnSerialDispatchQueue
- Optional
- Producer
- Range
- Reduce
- RefCount
- Repeat
- RetryWhen
- Sample
@ -120,17 +118,6 @@ custom_categories:
- Zip+arity
- Zip+Collection
- Zip
- name: RxSwift/Observables
children:
- Observable+Aggregate
- Observable+Binding
- Observable+Concurrency
- Observable+Creation
- Observable+Debug
- Observable+Multiple
- Observable+Single
- Observable+StandardSequenceOperators
- Observable+Time
- name: RxSwift/Observers
children:
- AnonymousObserver

130
Rx.xcodeproj/project.pbxproj
View File

@ -166,14 +166,10 @@
C8093D261B8A72BE0088E94D /* Multicast.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C7E1B8A72BE0088E94D /* Multicast.swift */; };
C8093D291B8A72BE0088E94D /* ObserveOn.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C801B8A72BE0088E94D /* ObserveOn.swift */; };
C8093D2A1B8A72BE0088E94D /* ObserveOn.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C801B8A72BE0088E94D /* ObserveOn.swift */; };
C8093D2B1B8A72BE0088E94D /* ObserveOnSerialDispatchQueue.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C811B8A72BE0088E94D /* ObserveOnSerialDispatchQueue.swift */; };
C8093D2C1B8A72BE0088E94D /* ObserveOnSerialDispatchQueue.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C811B8A72BE0088E94D /* ObserveOnSerialDispatchQueue.swift */; };
C8093D2F1B8A72BE0088E94D /* Producer.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C831B8A72BE0088E94D /* Producer.swift */; };
C8093D301B8A72BE0088E94D /* Producer.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C831B8A72BE0088E94D /* Producer.swift */; };
C8093D311B8A72BE0088E94D /* Reduce.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C841B8A72BE0088E94D /* Reduce.swift */; };
C8093D321B8A72BE0088E94D /* Reduce.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C841B8A72BE0088E94D /* Reduce.swift */; };
C8093D331B8A72BE0088E94D /* RefCount.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C851B8A72BE0088E94D /* RefCount.swift */; };
C8093D341B8A72BE0088E94D /* RefCount.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C851B8A72BE0088E94D /* RefCount.swift */; };
C8093D351B8A72BE0088E94D /* Sample.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C861B8A72BE0088E94D /* Sample.swift */; };
C8093D361B8A72BE0088E94D /* Sample.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C861B8A72BE0088E94D /* Sample.swift */; };
C8093D371B8A72BE0088E94D /* Scan.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C871B8A72BE0088E94D /* Scan.swift */; };
@ -202,24 +198,6 @@
C8093D4E1B8A72BE0088E94D /* Zip+arity.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C921B8A72BE0088E94D /* Zip+arity.swift */; };
C8093D511B8A72BE0088E94D /* Zip.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C941B8A72BE0088E94D /* Zip.swift */; };
C8093D521B8A72BE0088E94D /* Zip.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C941B8A72BE0088E94D /* Zip.swift */; };
C8093D531B8A72BE0088E94D /* Observable+Aggregate.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C951B8A72BE0088E94D /* Observable+Aggregate.swift */; };
C8093D541B8A72BE0088E94D /* Observable+Aggregate.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C951B8A72BE0088E94D /* Observable+Aggregate.swift */; };
C8093D551B8A72BE0088E94D /* Observable+Binding.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C961B8A72BE0088E94D /* Observable+Binding.swift */; };
C8093D561B8A72BE0088E94D /* Observable+Binding.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C961B8A72BE0088E94D /* Observable+Binding.swift */; };
C8093D571B8A72BE0088E94D /* Observable+Concurrency.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C971B8A72BE0088E94D /* Observable+Concurrency.swift */; };
C8093D581B8A72BE0088E94D /* Observable+Concurrency.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C971B8A72BE0088E94D /* Observable+Concurrency.swift */; };
C8093D591B8A72BE0088E94D /* Observable+Creation.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C981B8A72BE0088E94D /* Observable+Creation.swift */; };
C8093D5A1B8A72BE0088E94D /* Observable+Creation.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C981B8A72BE0088E94D /* Observable+Creation.swift */; };
C8093D5B1B8A72BE0088E94D /* Observable+Debug.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C991B8A72BE0088E94D /* Observable+Debug.swift */; };
C8093D5C1B8A72BE0088E94D /* Observable+Debug.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C991B8A72BE0088E94D /* Observable+Debug.swift */; };
C8093D5D1B8A72BE0088E94D /* Observable+Multiple.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C9A1B8A72BE0088E94D /* Observable+Multiple.swift */; };
C8093D5E1B8A72BE0088E94D /* Observable+Multiple.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C9A1B8A72BE0088E94D /* Observable+Multiple.swift */; };
C8093D5F1B8A72BE0088E94D /* Observable+Single.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C9B1B8A72BE0088E94D /* Observable+Single.swift */; };
C8093D601B8A72BE0088E94D /* Observable+Single.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C9B1B8A72BE0088E94D /* Observable+Single.swift */; };
C8093D611B8A72BE0088E94D /* Observable+StandardSequenceOperators.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C9C1B8A72BE0088E94D /* Observable+StandardSequenceOperators.swift */; };
C8093D621B8A72BE0088E94D /* Observable+StandardSequenceOperators.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C9C1B8A72BE0088E94D /* Observable+StandardSequenceOperators.swift */; };
C8093D631B8A72BE0088E94D /* Observable+Time.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C9D1B8A72BE0088E94D /* Observable+Time.swift */; };
C8093D641B8A72BE0088E94D /* Observable+Time.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C9D1B8A72BE0088E94D /* Observable+Time.swift */; };
C8093D651B8A72BE0088E94D /* ObservableType.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C9E1B8A72BE0088E94D /* ObservableType.swift */; };
C8093D661B8A72BE0088E94D /* ObservableType.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C9E1B8A72BE0088E94D /* ObservableType.swift */; };
C8093D691B8A72BE0088E94D /* AnyObserver.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093CA01B8A72BE0088E94D /* AnyObserver.swift */; };
@ -974,8 +952,8 @@
C8C3DA0D1B93959F004D233E /* Never.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8C3DA0B1B93959F004D233E /* Never.swift */; };
C8C3DA0F1B939767004D233E /* CurrentThreadScheduler.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8C3DA0E1B939767004D233E /* CurrentThreadScheduler.swift */; };
C8C3DA101B939767004D233E /* CurrentThreadScheduler.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8C3DA0E1B939767004D233E /* CurrentThreadScheduler.swift */; };
C8C3DA121B93A3EA004D233E /* AnonymousObservable.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8C3DA111B93A3EA004D233E /* AnonymousObservable.swift */; };
C8C3DA131B93A3EA004D233E /* AnonymousObservable.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8C3DA111B93A3EA004D233E /* AnonymousObservable.swift */; };
C8C3DA121B93A3EA004D233E /* Create.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8C3DA111B93A3EA004D233E /* Create.swift */; };
C8C3DA131B93A3EA004D233E /* Create.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8C3DA111B93A3EA004D233E /* Create.swift */; };
C8C4F15D1DE9CAEE00003FA7 /* UIBarButtonItem+RxTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8C4F15C1DE9CAEE00003FA7 /* UIBarButtonItem+RxTests.swift */; };
C8C4F15F1DE9CC5B00003FA7 /* UISwitch+RxTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8C4F15E1DE9CC5B00003FA7 /* UISwitch+RxTests.swift */; };
C8C4F1611DE9CD1600003FA7 /* UILabel+RxTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8C4F1601DE9CD1600003FA7 /* UILabel+RxTests.swift */; };
@ -1033,7 +1011,6 @@
C8F03F4F1DBBAE9400AECC4C /* DispatchQueue+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8F03F4E1DBBAE9400AECC4C /* DispatchQueue+Extensions.swift */; };
C8F03F501DBBAE9400AECC4C /* DispatchQueue+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8F03F4E1DBBAE9400AECC4C /* DispatchQueue+Extensions.swift */; };
C8F03F511DBBAE9400AECC4C /* DispatchQueue+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8F03F4E1DBBAE9400AECC4C /* DispatchQueue+Extensions.swift */; };
C8F0BF921BBBFB8B001B112F /* Observable+Creation.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C981B8A72BE0088E94D /* Observable+Creation.swift */; };
C8F0BF931BBBFB8B001B112F /* ConnectableObservableType.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C4D1B8A72BE0088E94D /* ConnectableObservableType.swift */; };
C8F0BF941BBBFB8B001B112F /* Just.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8C3DA021B9390C4004D233E /* Just.swift */; };
C8F0BF951BBBFB8B001B112F /* NopDisposable.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C5C1B8A72BE0088E94D /* NopDisposable.swift */; };
@ -1054,17 +1031,13 @@
C8F0BFA51BBBFB8B001B112F /* Deferred.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C761B8A72BE0088E94D /* Deferred.swift */; };
C8F0BFA61BBBFB8B001B112F /* ReplaySubject.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093CC01B8A72BE0088E94D /* ReplaySubject.swift */; };
C8F0BFA71BBBFB8B001B112F /* Zip+Collection.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8C3D9FD1B935EDF004D233E /* Zip+Collection.swift */; };
C8F0BFA81BBBFB8B001B112F /* Observable+Time.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C9D1B8A72BE0088E94D /* Observable+Time.swift */; };
C8F0BFA91BBBFB8B001B112F /* ObservableType+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C671B8A72BE0088E94D /* ObservableType+Extensions.swift */; };
C8F0BFAA1BBBFB8B001B112F /* Throttle.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C901B8A72BE0088E94D /* Throttle.swift */; };
C8F0BFAC1BBBFB8B001B112F /* Catch.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C6E1B8A72BE0088E94D /* Catch.swift */; };
C8F0BFAD1BBBFB8B001B112F /* CombineLatest.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C711B8A72BE0088E94D /* CombineLatest.swift */; };
C8F0BFAE1BBBFB8B001B112F /* Observable+Multiple.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C9A1B8A72BE0088E94D /* Observable+Multiple.swift */; };
C8F0BFAF1BBBFB8B001B112F /* ObserverBase.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093CA61B8A72BE0088E94D /* ObserverBase.swift */; };
C8F0BFB01BBBFB8B001B112F /* ConnectableObservable.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C741B8A72BE0088E94D /* ConnectableObservable.swift */; };
C8F0BFB11BBBFB8B001B112F /* Observable+StandardSequenceOperators.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C9C1B8A72BE0088E94D /* Observable+StandardSequenceOperators.swift */; };
C8F0BFB21BBBFB8B001B112F /* DistinctUntilChanged.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C781B8A72BE0088E94D /* DistinctUntilChanged.swift */; };
C8F0BFB31BBBFB8B001B112F /* Observable+Binding.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C961B8A72BE0088E94D /* Observable+Binding.swift */; };
C8F0BFB41BBBFB8B001B112F /* TailRecursiveSink.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093CA91B8A72BE0088E94D /* TailRecursiveSink.swift */; };
C8F0BFB51BBBFB8B001B112F /* AsyncLock.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C4B1B8A72BE0088E94D /* AsyncLock.swift */; };
C8F0BFB61BBBFB8B001B112F /* BinaryDisposable.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C551B8A72BE0088E94D /* BinaryDisposable.swift */; };
@ -1075,8 +1048,6 @@
C8F0BFBC1BBBFB8B001B112F /* Rx.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093CAF1B8A72BE0088E94D /* Rx.swift */; };
C8F0BFBD1BBBFB8B001B112F /* CombineLatest+Collection.swift in Sources */ = {isa = PBXBuildFile; fileRef = C80D342D1B9245A40014629D /* CombineLatest+Collection.swift */; };
C8F0BFBE1BBBFB8B001B112F /* SubjectType.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093CC11B8A72BE0088E94D /* SubjectType.swift */; };
C8F0BFBF1BBBFB8B001B112F /* Observable+Debug.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C991B8A72BE0088E94D /* Observable+Debug.swift */; };
C8F0BFC01BBBFB8B001B112F /* Observable+Concurrency.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C971B8A72BE0088E94D /* Observable+Concurrency.swift */; };
C8F0BFC11BBBFB8B001B112F /* AnonymousObserver.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093CA21B8A72BE0088E94D /* AnonymousObserver.swift */; };
C8F0BFC21BBBFB8B001B112F /* PublishSubject.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093CBF1B8A72BE0088E94D /* PublishSubject.swift */; };
C8F0BFC31BBBFB8B001B112F /* Merge.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C7D1B8A72BE0088E94D /* Merge.swift */; };
@ -1087,7 +1058,7 @@
C8F0BFC91BBBFB8B001B112F /* DisposeBag.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C581B8A72BE0088E94D /* DisposeBag.swift */; };
C8F0BFCA1BBBFB8B001B112F /* RecursiveScheduler.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093CB91B8A72BE0088E94D /* RecursiveScheduler.swift */; };
C8F0BFCB1BBBFB8B001B112F /* Scan.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C871B8A72BE0088E94D /* Scan.swift */; };
C8F0BFCD1BBBFB8B001B112F /* AnonymousObservable.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8C3DA111B93A3EA004D233E /* AnonymousObservable.swift */; };
C8F0BFCD1BBBFB8B001B112F /* Create.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8C3DA111B93A3EA004D233E /* Create.swift */; };
C8F0BFCF1BBBFB8B001B112F /* DisposeBase.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C591B8A72BE0088E94D /* DisposeBase.swift */; };
C8F0BFD01BBBFB8B001B112F /* AnonymousDisposable.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C541B8A72BE0088E94D /* AnonymousDisposable.swift */; };
C8F0BFD11BBBFB8B001B112F /* ConcurrentDispatchQueueScheduler.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093CB51B8A72BE0088E94D /* ConcurrentDispatchQueueScheduler.swift */; };
@ -1097,15 +1068,12 @@
C8F0BFD51BBBFB8B001B112F /* Range.swift in Sources */ = {isa = PBXBuildFile; fileRef = C86409FB1BA593F500D3C4E8 /* Range.swift */; };
C8F0BFD61BBBFB8B001B112F /* Map.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C7C1B8A72BE0088E94D /* Map.swift */; };
C8F0BFD81BBBFB8B001B112F /* ObservableType.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C9E1B8A72BE0088E94D /* ObservableType.swift */; };
C8F0BFD91BBBFB8B001B112F /* Observable+Aggregate.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C951B8A72BE0088E94D /* Observable+Aggregate.swift */; };
C8F0BFDA1BBBFB8B001B112F /* ObserveOnSerialDispatchQueue.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C811B8A72BE0088E94D /* ObserveOnSerialDispatchQueue.swift */; };
C8F0BFDB1BBBFB8B001B112F /* StartWith.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C8A1B8A72BE0088E94D /* StartWith.swift */; };
C8F0BFDC1BBBFB8B001B112F /* Buffer.swift in Sources */ = {isa = PBXBuildFile; fileRef = C821DBA11BA4DCAB008F3809 /* Buffer.swift */; };
C8F0BFDD1BBBFB8B001B112F /* TakeWhile.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C8F1B8A72BE0088E94D /* TakeWhile.swift */; };
C8F0BFDE1BBBFB8B001B112F /* Amb.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C6B1B8A72BE0088E94D /* Amb.swift */; };
C8F0BFDF1BBBFB8B001B112F /* Do.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C791B8A72BE0088E94D /* Do.swift */; };
C8F0BFE01BBBFB8B001B112F /* SerialDispatchQueueScheduler.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093CBC1B8A72BE0088E94D /* SerialDispatchQueueScheduler.swift */; };
C8F0BFE11BBBFB8B001B112F /* RefCount.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C851B8A72BE0088E94D /* RefCount.swift */; };
C8F0BFE21BBBFB8B001B112F /* Concat.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C721B8A72BE0088E94D /* Concat.swift */; };
C8F0BFE31BBBFB8B001B112F /* Lock.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C4C1B8A72BE0088E94D /* Lock.swift */; };
C8F0BFE41BBBFB8B001B112F /* Take.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C8D1B8A72BE0088E94D /* Take.swift */; };
@ -1118,7 +1086,6 @@
C8F0BFED1BBBFB8B001B112F /* Cancelable.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C491B8A72BE0088E94D /* Cancelable.swift */; };
C8F0BFEE1BBBFB8B001B112F /* ScheduledDisposable.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C5D1B8A72BE0088E94D /* ScheduledDisposable.swift */; };
C8F0BFEF1BBBFB8B001B112F /* Filter.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C7A1B8A72BE0088E94D /* Filter.swift */; };
C8F0BFF01BBBFB8B001B112F /* Observable+Single.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C9B1B8A72BE0088E94D /* Observable+Single.swift */; };
C8F0BFF11BBBFB8B001B112F /* CompositeDisposable.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C571B8A72BE0088E94D /* CompositeDisposable.swift */; };
C8F0BFF21BBBFB8B001B112F /* ObserverType.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093CAB1B8A72BE0088E94D /* ObserverType.swift */; };
C8F0BFF31BBBFB8B001B112F /* SubscribeOn.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C8B1B8A72BE0088E94D /* SubscribeOn.swift */; };
@ -1285,7 +1252,7 @@
D2EBEAF91BB9B6B2003A27DC /* SerialDisposable.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C5F1B8A72BE0088E94D /* SerialDisposable.swift */; };
D2EBEAFA1BB9B6B2003A27DC /* SingleAssignmentDisposable.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C601B8A72BE0088E94D /* SingleAssignmentDisposable.swift */; };
D2EBEAFC1BB9B6BA003A27DC /* Amb.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C6B1B8A72BE0088E94D /* Amb.swift */; };
D2EBEAFD1BB9B6BA003A27DC /* AnonymousObservable.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8C3DA111B93A3EA004D233E /* AnonymousObservable.swift */; };
D2EBEAFD1BB9B6BA003A27DC /* Create.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8C3DA111B93A3EA004D233E /* Create.swift */; };
D2EBEAFF1BB9B6BA003A27DC /* Buffer.swift in Sources */ = {isa = PBXBuildFile; fileRef = C821DBA11BA4DCAB008F3809 /* Buffer.swift */; };
D2EBEB001BB9B6BA003A27DC /* Catch.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C6E1B8A72BE0088E94D /* Catch.swift */; };
D2EBEB011BB9B6BA003A27DC /* CombineLatest.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C711B8A72BE0088E94D /* CombineLatest.swift */; };
@ -1308,11 +1275,9 @@
D2EBEB131BB9B6C1003A27DC /* Multicast.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C7E1B8A72BE0088E94D /* Multicast.swift */; };
D2EBEB141BB9B6C1003A27DC /* Never.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8C3DA0B1B93959F004D233E /* Never.swift */; };
D2EBEB151BB9B6C1003A27DC /* ObserveOn.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C801B8A72BE0088E94D /* ObserveOn.swift */; };
D2EBEB161BB9B6C1003A27DC /* ObserveOnSerialDispatchQueue.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C811B8A72BE0088E94D /* ObserveOnSerialDispatchQueue.swift */; };
D2EBEB171BB9B6C1003A27DC /* Producer.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C831B8A72BE0088E94D /* Producer.swift */; };
D2EBEB181BB9B6C1003A27DC /* Range.swift in Sources */ = {isa = PBXBuildFile; fileRef = C86409FB1BA593F500D3C4E8 /* Range.swift */; };
D2EBEB191BB9B6C1003A27DC /* Reduce.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C841B8A72BE0088E94D /* Reduce.swift */; };
D2EBEB1A1BB9B6C1003A27DC /* RefCount.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C851B8A72BE0088E94D /* RefCount.swift */; };
D2EBEB1B1BB9B6C1003A27DC /* Repeat.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8640A021BA5B12A00D3C4E8 /* Repeat.swift */; };
D2EBEB1C1BB9B6C1003A27DC /* Sample.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C861B8A72BE0088E94D /* Sample.swift */; };
D2EBEB1D1BB9B6C1003A27DC /* Scan.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C871B8A72BE0088E94D /* Scan.swift */; };
@ -1329,15 +1294,6 @@
D2EBEB281BB9B6C1003A27DC /* Zip.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C941B8A72BE0088E94D /* Zip.swift */; };
D2EBEB291BB9B6C1003A27DC /* Zip+arity.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C921B8A72BE0088E94D /* Zip+arity.swift */; };
D2EBEB2A1BB9B6C5003A27DC /* Zip+Collection.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8C3D9FD1B935EDF004D233E /* Zip+Collection.swift */; };
D2EBEB2B1BB9B6CA003A27DC /* Observable+Aggregate.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C951B8A72BE0088E94D /* Observable+Aggregate.swift */; };
D2EBEB2C1BB9B6CA003A27DC /* Observable+Binding.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C961B8A72BE0088E94D /* Observable+Binding.swift */; };
D2EBEB2D1BB9B6CA003A27DC /* Observable+Concurrency.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C971B8A72BE0088E94D /* Observable+Concurrency.swift */; };
D2EBEB2E1BB9B6CA003A27DC /* Observable+Creation.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C981B8A72BE0088E94D /* Observable+Creation.swift */; };
D2EBEB2F1BB9B6CA003A27DC /* Observable+Debug.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C991B8A72BE0088E94D /* Observable+Debug.swift */; };
D2EBEB301BB9B6CA003A27DC /* Observable+Multiple.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C9A1B8A72BE0088E94D /* Observable+Multiple.swift */; };
D2EBEB311BB9B6CA003A27DC /* Observable+Single.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C9B1B8A72BE0088E94D /* Observable+Single.swift */; };
D2EBEB321BB9B6CA003A27DC /* Observable+StandardSequenceOperators.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C9C1B8A72BE0088E94D /* Observable+StandardSequenceOperators.swift */; };
D2EBEB331BB9B6CA003A27DC /* Observable+Time.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093C9D1B8A72BE0088E94D /* Observable+Time.swift */; };
D2EBEB341BB9B6D2003A27DC /* AnonymousObserver.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093CA21B8A72BE0088E94D /* AnonymousObserver.swift */; };
D2EBEB351BB9B6D2003A27DC /* ObserverBase.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093CA61B8A72BE0088E94D /* ObserverBase.swift */; };
D2EBEB361BB9B6D2003A27DC /* TailRecursiveSink.swift in Sources */ = {isa = PBXBuildFile; fileRef = C8093CA91B8A72BE0088E94D /* TailRecursiveSink.swift */; };
@ -1670,10 +1626,8 @@
C8093C7D1B8A72BE0088E94D /* Merge.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Merge.swift; sourceTree = "<group>"; };
C8093C7E1B8A72BE0088E94D /* Multicast.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Multicast.swift; sourceTree = "<group>"; };
C8093C801B8A72BE0088E94D /* ObserveOn.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = ObserveOn.swift; sourceTree = "<group>"; };
C8093C811B8A72BE0088E94D /* ObserveOnSerialDispatchQueue.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = ObserveOnSerialDispatchQueue.swift; sourceTree = "<group>"; };
C8093C831B8A72BE0088E94D /* Producer.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Producer.swift; sourceTree = "<group>"; };
C8093C841B8A72BE0088E94D /* Reduce.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Reduce.swift; sourceTree = "<group>"; };
C8093C851B8A72BE0088E94D /* RefCount.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = RefCount.swift; sourceTree = "<group>"; };
C8093C861B8A72BE0088E94D /* Sample.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Sample.swift; sourceTree = "<group>"; };
C8093C871B8A72BE0088E94D /* Scan.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Scan.swift; sourceTree = "<group>"; };
C8093C881B8A72BE0088E94D /* Sink.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Sink.swift; sourceTree = "<group>"; };
@ -1689,15 +1643,6 @@
C8093C921B8A72BE0088E94D /* Zip+arity.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "Zip+arity.swift"; sourceTree = "<group>"; };
C8093C931B8A72BE0088E94D /* Zip+arity.tt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = "Zip+arity.tt"; sourceTree = "<group>"; };
C8093C941B8A72BE0088E94D /* Zip.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Zip.swift; sourceTree = "<group>"; };
C8093C951B8A72BE0088E94D /* Observable+Aggregate.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "Observable+Aggregate.swift"; sourceTree = "<group>"; };
C8093C961B8A72BE0088E94D /* Observable+Binding.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "Observable+Binding.swift"; sourceTree = "<group>"; };
C8093C971B8A72BE0088E94D /* Observable+Concurrency.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "Observable+Concurrency.swift"; sourceTree = "<group>"; };
C8093C981B8A72BE0088E94D /* Observable+Creation.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; lineEnding = 0; path = "Observable+Creation.swift"; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.swift; };
C8093C991B8A72BE0088E94D /* Observable+Debug.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "Observable+Debug.swift"; sourceTree = "<group>"; };
C8093C9A1B8A72BE0088E94D /* Observable+Multiple.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "Observable+Multiple.swift"; sourceTree = "<group>"; };
C8093C9B1B8A72BE0088E94D /* Observable+Single.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "Observable+Single.swift"; sourceTree = "<group>"; };
C8093C9C1B8A72BE0088E94D /* Observable+StandardSequenceOperators.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "Observable+StandardSequenceOperators.swift"; sourceTree = "<group>"; };
C8093C9D1B8A72BE0088E94D /* Observable+Time.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "Observable+Time.swift"; sourceTree = "<group>"; };
C8093C9E1B8A72BE0088E94D /* ObservableType.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = ObservableType.swift; sourceTree = "<group>"; };
C8093CA01B8A72BE0088E94D /* AnyObserver.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; lineEnding = 0; path = AnyObserver.swift; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.swift; };
C8093CA21B8A72BE0088E94D /* AnonymousObserver.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = AnonymousObserver.swift; sourceTree = "<group>"; };
@ -1982,7 +1927,7 @@
C8C3DA081B93941E004D233E /* Error.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Error.swift; sourceTree = "<group>"; };
C8C3DA0B1B93959F004D233E /* Never.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Never.swift; sourceTree = "<group>"; };
C8C3DA0E1B939767004D233E /* CurrentThreadScheduler.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; lineEnding = 0; path = CurrentThreadScheduler.swift; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.swift; };
C8C3DA111B93A3EA004D233E /* AnonymousObservable.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; lineEnding = 0; path = AnonymousObservable.swift; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.swift; };
C8C3DA111B93A3EA004D233E /* Create.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; lineEnding = 0; path = Create.swift; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.swift; };
C8C4F15C1DE9CAEE00003FA7 /* UIBarButtonItem+RxTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "UIBarButtonItem+RxTests.swift"; sourceTree = "<group>"; };
C8C4F15E1DE9CC5B00003FA7 /* UISwitch+RxTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "UISwitch+RxTests.swift"; sourceTree = "<group>"; };
C8C4F1601DE9CD1600003FA7 /* UILabel+RxTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "UILabel+RxTests.swift"; sourceTree = "<group>"; };
@ -2276,15 +2221,6 @@
isa = PBXGroup;
children = (
C8093C6A1B8A72BE0088E94D /* Implementations */,
C8093C951B8A72BE0088E94D /* Observable+Aggregate.swift */,
C8093C961B8A72BE0088E94D /* Observable+Binding.swift */,
C8093C971B8A72BE0088E94D /* Observable+Concurrency.swift */,
C8093C981B8A72BE0088E94D /* Observable+Creation.swift */,
C8093C991B8A72BE0088E94D /* Observable+Debug.swift */,
C8093C9A1B8A72BE0088E94D /* Observable+Multiple.swift */,
C8093C9B1B8A72BE0088E94D /* Observable+Single.swift */,
C8093C9C1B8A72BE0088E94D /* Observable+StandardSequenceOperators.swift */,
C8093C9D1B8A72BE0088E94D /* Observable+Time.swift */,
);
path = Observables;
sourceTree = "<group>";
@ -2294,7 +2230,7 @@
children = (
CB883B491BE369AA000AC2EE /* AddRef.swift */,
C8093C6B1B8A72BE0088E94D /* Amb.swift */,
C8C3DA111B93A3EA004D233E /* AnonymousObservable.swift */,
C8C3DA111B93A3EA004D233E /* Create.swift */,
C89814811E75B77B0035949C /* AsMaybe.swift */,
C89814861E75BE590035949C /* AsSingle.swift */,
C821DBA11BA4DCAB008F3809 /* Buffer.swift */,
@ -2327,12 +2263,10 @@
C8093C7E1B8A72BE0088E94D /* Multicast.swift */,
C8C3DA0B1B93959F004D233E /* Never.swift */,
C8093C801B8A72BE0088E94D /* ObserveOn.swift */,
C8093C811B8A72BE0088E94D /* ObserveOnSerialDispatchQueue.swift */,
EB15145C1DFFAACB00555E2C /* Optional.swift */,
C8093C831B8A72BE0088E94D /* Producer.swift */,
C86409FB1BA593F500D3C4E8 /* Range.swift */,
C8093C841B8A72BE0088E94D /* Reduce.swift */,
C8093C851B8A72BE0088E94D /* RefCount.swift */,
C8640A021BA5B12A00D3C4E8 /* Repeat.swift */,
CB255BD61BC46A9C00798A4C /* RetryWhen.swift */,
C8093C861B8A72BE0088E94D /* Sample.swift */,
@ -4373,7 +4307,6 @@
isa = PBXSourcesBuildPhase;
buildActionMask = 2147483647;
files = (
C8093D5A1B8A72BE0088E94D /* Observable+Creation.swift in Sources */,
C8093CCC1B8A72BE0088E94D /* ConnectableObservableType.swift in Sources */,
C83D73BD1C1DBAEE003DC470 /* InvocableScheduledItem.swift in Sources */,
C8C3DA041B9390C4004D233E /* Just.swift in Sources */,
@ -4412,7 +4345,6 @@
C89814831E75B77B0035949C /* AsMaybe.swift in Sources */,
C8093DA41B8A72BE0088E94D /* ReplaySubject.swift in Sources */,
C8C3D9FF1B935EDF004D233E /* Zip+Collection.swift in Sources */,
C8093D641B8A72BE0088E94D /* Observable+Time.swift in Sources */,
C8093CFC1B8A72BE0088E94D /* ObservableType+Extensions.swift in Sources */,
C8093D4A1B8A72BE0088E94D /* Throttle.swift in Sources */,
C8B145011BD2D80100267DCE /* ImmediateScheduler.swift in Sources */,
@ -4420,16 +4352,13 @@
C8BCD3C81C1468D4005F1280 /* ShareReplay1WhileConnected.swift in Sources */,
C8093D0C1B8A72BE0088E94D /* CombineLatest.swift in Sources */,
D2FC15B31BCB95E5007361FF /* SkipWhile.swift in Sources */,
C8093D5E1B8A72BE0088E94D /* Observable+Multiple.swift in Sources */,
C83D73C11C1DBAEE003DC470 /* InvocableType.swift in Sources */,
C8093D741B8A72BE0088E94D /* ObserverBase.swift in Sources */,
C85106891C2D550E0075150C /* String+Rx.swift in Sources */,
EB15145E1DFFAACB00555E2C /* Optional.swift in Sources */,
C8093D121B8A72BE0088E94D /* ConnectableObservable.swift in Sources */,
C8BF34D01C2E426800416CAE /* Platform.Linux.swift in Sources */,
C8093D621B8A72BE0088E94D /* Observable+StandardSequenceOperators.swift in Sources */,
C8093D1A1B8A72BE0088E94D /* DistinctUntilChanged.swift in Sources */,
C8093D561B8A72BE0088E94D /* Observable+Binding.swift in Sources */,
C8FA89221C30424100CD3A17 /* VirtualTimeConverterType.swift in Sources */,
C8F03F4B1DBBAC0A00AECC4C /* DispatchQueue+Extensions.swift in Sources */,
C8FA891D1C30412A00CD3A17 /* HistoricalSchedulerTimeConverter.swift in Sources */,
@ -4454,8 +4383,6 @@
C80D342F1B9245A40014629D /* CombineLatest+Collection.swift in Sources */,
C84CC5411BDC3B3E00E06A64 /* ElementAt.swift in Sources */,
C8093DA61B8A72BE0088E94D /* SubjectType.swift in Sources */,
C8093D5C1B8A72BE0088E94D /* Observable+Debug.swift in Sources */,
C8093D581B8A72BE0088E94D /* Observable+Concurrency.swift in Sources */,
C8093D6C1B8A72BE0088E94D /* AnonymousObserver.swift in Sources */,
C8093DA21B8A72BE0088E94D /* PublishSubject.swift in Sources */,
C83D73C91C1DBAEE003DC470 /* ScheduledItemType.swift in Sources */,
@ -4471,7 +4398,7 @@
C81A09821E6C6B2500900B3B /* Deprecated.swift in Sources */,
C8093D381B8A72BE0088E94D /* Scan.swift in Sources */,
CB30D9EA1BF0E3500084C1C0 /* SingleAsync.swift in Sources */,
C8C3DA131B93A3EA004D233E /* AnonymousObservable.swift in Sources */,
C8C3DA131B93A3EA004D233E /* Create.swift in Sources */,
C8093CE01B8A72BE0088E94D /* DisposeBase.swift in Sources */,
C81A09881E6C702700900B3B /* PrimitiveSequence.swift in Sources */,
C8093CD61B8A72BE0088E94D /* AnonymousDisposable.swift in Sources */,
@ -4483,8 +4410,6 @@
C8093D221B8A72BE0088E94D /* Map.swift in Sources */,
D235B23F1BD003DD007E84DA /* Using.swift in Sources */,
C8093D661B8A72BE0088E94D /* ObservableType.swift in Sources */,
C8093D541B8A72BE0088E94D /* Observable+Aggregate.swift in Sources */,
C8093D2C1B8A72BE0088E94D /* ObserveOnSerialDispatchQueue.swift in Sources */,
C8093D3E1B8A72BE0088E94D /* StartWith.swift in Sources */,
C821DBA31BA4DCAB008F3809 /* Buffer.swift in Sources */,
B1D899901BF653410027B05C /* Timeout.swift in Sources */,
@ -4492,7 +4417,6 @@
C8093D001B8A72BE0088E94D /* Amb.swift in Sources */,
C8093D1C1B8A72BE0088E94D /* Do.swift in Sources */,
C8093D9E1B8A72BE0088E94D /* SerialDispatchQueueScheduler.swift in Sources */,
C8093D341B8A72BE0088E94D /* RefCount.swift in Sources */,
C8093D0E1B8A72BE0088E94D /* Concat.swift in Sources */,
CDDEF16B1D4FB40000CA8546 /* Disposables.swift in Sources */,
C85217F81E33FBBE0015DD38 /* RecursiveLock.swift in Sources */,
@ -4514,7 +4438,6 @@
C8093CC61B8A72BE0088E94D /* Cancelable.swift in Sources */,
C8093CE81B8A72BE0088E94D /* ScheduledDisposable.swift in Sources */,
C8093D1E1B8A72BE0088E94D /* Filter.swift in Sources */,
C8093D601B8A72BE0088E94D /* Observable+Single.swift in Sources */,
C8093CDC1B8A72BE0088E94D /* CompositeDisposable.swift in Sources */,
C8093D7E1B8A72BE0088E94D /* ObserverType.swift in Sources */,
C8093D401B8A72BE0088E94D /* SubscribeOn.swift in Sources */,
@ -4617,7 +4540,6 @@
isa = PBXSourcesBuildPhase;
buildActionMask = 2147483647;
files = (
C8093D591B8A72BE0088E94D /* Observable+Creation.swift in Sources */,
C8093CCB1B8A72BE0088E94D /* ConnectableObservableType.swift in Sources */,
C83D73BC1C1DBAEE003DC470 /* InvocableScheduledItem.swift in Sources */,
C8C3DA031B9390C4004D233E /* Just.swift in Sources */,
@ -4654,7 +4576,6 @@
C8093DA31B8A72BE0088E94D /* ReplaySubject.swift in Sources */,
C8C3D9FE1B935EDF004D233E /* Zip+Collection.swift in Sources */,
C89814821E75B77B0035949C /* AsMaybe.swift in Sources */,
C8093D631B8A72BE0088E94D /* Observable+Time.swift in Sources */,
C8093CFB1B8A72BE0088E94D /* ObservableType+Extensions.swift in Sources */,
C8093D491B8A72BE0088E94D /* Throttle.swift in Sources */,
C8B145001BD2D80100267DCE /* ImmediateScheduler.swift in Sources */,
@ -4662,16 +4583,13 @@
C8BCD3C71C1468D4005F1280 /* ShareReplay1WhileConnected.swift in Sources */,
C8093D0B1B8A72BE0088E94D /* CombineLatest.swift in Sources */,
D22B6D261BC8504A00BCE0AB /* SkipWhile.swift in Sources */,
C8093D5D1B8A72BE0088E94D /* Observable+Multiple.swift in Sources */,
C83D73C01C1DBAEE003DC470 /* InvocableType.swift in Sources */,
C8093D731B8A72BE0088E94D /* ObserverBase.swift in Sources */,
C85106881C2D550E0075150C /* String+Rx.swift in Sources */,
C8093D111B8A72BE0088E94D /* ConnectableObservable.swift in Sources */,
C8BF34CF1C2E426800416CAE /* Platform.Linux.swift in Sources */,
EB15145D1DFFAACB00555E2C /* Optional.swift in Sources */,
C8093D611B8A72BE0088E94D /* Observable+StandardSequenceOperators.swift in Sources */,
C8093D191B8A72BE0088E94D /* DistinctUntilChanged.swift in Sources */,
C8093D551B8A72BE0088E94D /* Observable+Binding.swift in Sources */,
C8093D791B8A72BE0088E94D /* TailRecursiveSink.swift in Sources */,
B1B7C3BD1BDD39DB0076934E /* TakeLast.swift in Sources */,
C8093CC71B8A72BE0088E94D /* AsyncLock.swift in Sources */,
@ -4697,8 +4615,6 @@
C84CC5401BDC3B3700E06A64 /* ElementAt.swift in Sources */,
C8093DA51B8A72BE0088E94D /* SubjectType.swift in Sources */,
C8FA89171C30409900CD3A17 /* HistoricalScheduler.swift in Sources */,
C8093D5B1B8A72BE0088E94D /* Observable+Debug.swift in Sources */,
C8093D571B8A72BE0088E94D /* Observable+Concurrency.swift in Sources */,
C8093D6B1B8A72BE0088E94D /* AnonymousObserver.swift in Sources */,
C8093DA11B8A72BE0088E94D /* PublishSubject.swift in Sources */,
C83D73C81C1DBAEE003DC470 /* ScheduledItemType.swift in Sources */,
@ -4714,7 +4630,7 @@
C8093D371B8A72BE0088E94D /* Scan.swift in Sources */,
C81A09811E6C6B2500900B3B /* Deprecated.swift in Sources */,
CB30D9E91BF0E3500084C1C0 /* SingleAsync.swift in Sources */,
C8C3DA121B93A3EA004D233E /* AnonymousObservable.swift in Sources */,
C8C3DA121B93A3EA004D233E /* Create.swift in Sources */,
C8093CDF1B8A72BE0088E94D /* DisposeBase.swift in Sources */,
C8093CD51B8A72BE0088E94D /* AnonymousDisposable.swift in Sources */,
C81A09871E6C702700900B3B /* PrimitiveSequence.swift in Sources */,
@ -4726,8 +4642,6 @@
C8093D211B8A72BE0088E94D /* Map.swift in Sources */,
D235B23E1BD003DD007E84DA /* Using.swift in Sources */,
C8093D651B8A72BE0088E94D /* ObservableType.swift in Sources */,
C8093D531B8A72BE0088E94D /* Observable+Aggregate.swift in Sources */,
C8093D2B1B8A72BE0088E94D /* ObserveOnSerialDispatchQueue.swift in Sources */,
C8093D3D1B8A72BE0088E94D /* StartWith.swift in Sources */,
C821DBA21BA4DCAB008F3809 /* Buffer.swift in Sources */,
B1D8998F1BF653410027B05C /* Timeout.swift in Sources */,
@ -4735,7 +4649,6 @@
C8093CFF1B8A72BE0088E94D /* Amb.swift in Sources */,
C8093D1B1B8A72BE0088E94D /* Do.swift in Sources */,
C8093D9D1B8A72BE0088E94D /* SerialDispatchQueueScheduler.swift in Sources */,
C8093D331B8A72BE0088E94D /* RefCount.swift in Sources */,
C8093D0D1B8A72BE0088E94D /* Concat.swift in Sources */,
CDDEF16A1D4FB40000CA8546 /* Disposables.swift in Sources */,
C8093CC91B8A72BE0088E94D /* Lock.swift in Sources */,
@ -4757,7 +4670,6 @@
C8093CC51B8A72BE0088E94D /* Cancelable.swift in Sources */,
C8093CE71B8A72BE0088E94D /* ScheduledDisposable.swift in Sources */,
C8093D1D1B8A72BE0088E94D /* Filter.swift in Sources */,
C8093D5F1B8A72BE0088E94D /* Observable+Single.swift in Sources */,
C8FA891C1C30412A00CD3A17 /* HistoricalSchedulerTimeConverter.swift in Sources */,
C8093CDB1B8A72BE0088E94D /* CompositeDisposable.swift in Sources */,
C8093D7D1B8A72BE0088E94D /* ObserverType.swift in Sources */,
@ -4789,7 +4701,6 @@
isa = PBXSourcesBuildPhase;
buildActionMask = 2147483647;
files = (
C8F0BF921BBBFB8B001B112F /* Observable+Creation.swift in Sources */,
C8F0BF931BBBFB8B001B112F /* ConnectableObservableType.swift in Sources */,
C83D73BF1C1DBAEE003DC470 /* InvocableScheduledItem.swift in Sources */,
C8F0BF941BBBFB8B001B112F /* Just.swift in Sources */,
@ -4828,7 +4739,6 @@
C89814851E75B77B0035949C /* AsMaybe.swift in Sources */,
C8F0BFA61BBBFB8B001B112F /* ReplaySubject.swift in Sources */,
C8F0BFA71BBBFB8B001B112F /* Zip+Collection.swift in Sources */,
C8F0BFA81BBBFB8B001B112F /* Observable+Time.swift in Sources */,
C8F0BFA91BBBFB8B001B112F /* ObservableType+Extensions.swift in Sources */,
C8F0BFAA1BBBFB8B001B112F /* Throttle.swift in Sources */,
C8B145031BD2D80100267DCE /* ImmediateScheduler.swift in Sources */,
@ -4836,16 +4746,13 @@
C8BCD3CA1C1468D4005F1280 /* ShareReplay1WhileConnected.swift in Sources */,
C8F0BFAD1BBBFB8B001B112F /* CombineLatest.swift in Sources */,
D2FC15B51BCB95E8007361FF /* SkipWhile.swift in Sources */,
C8F0BFAE1BBBFB8B001B112F /* Observable+Multiple.swift in Sources */,
C83D73C31C1DBAEE003DC470 /* InvocableType.swift in Sources */,
C8F0BFAF1BBBFB8B001B112F /* ObserverBase.swift in Sources */,
C851068B1C2D550E0075150C /* String+Rx.swift in Sources */,
EB1514601DFFAACB00555E2C /* Optional.swift in Sources */,
C8F0BFB01BBBFB8B001B112F /* ConnectableObservable.swift in Sources */,
C8BF34D21C2E426800416CAE /* Platform.Linux.swift in Sources */,
C8F0BFB11BBBFB8B001B112F /* Observable+StandardSequenceOperators.swift in Sources */,
C8F0BFB21BBBFB8B001B112F /* DistinctUntilChanged.swift in Sources */,
C8F0BFB31BBBFB8B001B112F /* Observable+Binding.swift in Sources */,
C8FA89201C30424000CD3A17 /* VirtualTimeConverterType.swift in Sources */,
C8F03F4D1DBBAC0A00AECC4C /* DispatchQueue+Extensions.swift in Sources */,
C8FA891F1C30412A00CD3A17 /* HistoricalSchedulerTimeConverter.swift in Sources */,
@ -4870,8 +4777,6 @@
C8F0BFBD1BBBFB8B001B112F /* CombineLatest+Collection.swift in Sources */,
C84CC5431BDC3B3E00E06A64 /* ElementAt.swift in Sources */,
C8F0BFBE1BBBFB8B001B112F /* SubjectType.swift in Sources */,
C8F0BFBF1BBBFB8B001B112F /* Observable+Debug.swift in Sources */,
C8F0BFC01BBBFB8B001B112F /* Observable+Concurrency.swift in Sources */,
C8F0BFC11BBBFB8B001B112F /* AnonymousObserver.swift in Sources */,
C8F0BFC21BBBFB8B001B112F /* PublishSubject.swift in Sources */,
C83D73CB1C1DBAEE003DC470 /* ScheduledItemType.swift in Sources */,
@ -4887,7 +4792,7 @@
C81A09841E6C6B2500900B3B /* Deprecated.swift in Sources */,
C8F0BFCB1BBBFB8B001B112F /* Scan.swift in Sources */,
CB30D9EC1BF0E3500084C1C0 /* SingleAsync.swift in Sources */,
C8F0BFCD1BBBFB8B001B112F /* AnonymousObservable.swift in Sources */,
C8F0BFCD1BBBFB8B001B112F /* Create.swift in Sources */,
C8F0BFCF1BBBFB8B001B112F /* DisposeBase.swift in Sources */,
C81A098A1E6C702700900B3B /* PrimitiveSequence.swift in Sources */,
C8F0BFD01BBBFB8B001B112F /* AnonymousDisposable.swift in Sources */,
@ -4899,8 +4804,6 @@
C8F0BFD61BBBFB8B001B112F /* Map.swift in Sources */,
D235B2411BD003DD007E84DA /* Using.swift in Sources */,
C8F0BFD81BBBFB8B001B112F /* ObservableType.swift in Sources */,
C8F0BFD91BBBFB8B001B112F /* Observable+Aggregate.swift in Sources */,
C8F0BFDA1BBBFB8B001B112F /* ObserveOnSerialDispatchQueue.swift in Sources */,
C8F0BFDB1BBBFB8B001B112F /* StartWith.swift in Sources */,
C8F0BFDC1BBBFB8B001B112F /* Buffer.swift in Sources */,
B1D899921BF653410027B05C /* Timeout.swift in Sources */,
@ -4908,7 +4811,6 @@
C8F0BFDE1BBBFB8B001B112F /* Amb.swift in Sources */,
C8F0BFDF1BBBFB8B001B112F /* Do.swift in Sources */,
C8F0BFE01BBBFB8B001B112F /* SerialDispatchQueueScheduler.swift in Sources */,
C8F0BFE11BBBFB8B001B112F /* RefCount.swift in Sources */,
C8F0BFE21BBBFB8B001B112F /* Concat.swift in Sources */,
CDDEF16D1D4FB40000CA8546 /* Disposables.swift in Sources */,
C85217FA1E33FBBE0015DD38 /* RecursiveLock.swift in Sources */,
@ -4930,7 +4832,6 @@
C8F0BFED1BBBFB8B001B112F /* Cancelable.swift in Sources */,
C8F0BFEE1BBBFB8B001B112F /* ScheduledDisposable.swift in Sources */,
C8F0BFEF1BBBFB8B001B112F /* Filter.swift in Sources */,
C8F0BFF01BBBFB8B001B112F /* Observable+Single.swift in Sources */,
C8F0BFF11BBBFB8B001B112F /* CompositeDisposable.swift in Sources */,
C8F0BFF21BBBFB8B001B112F /* ObserverType.swift in Sources */,
C8F0BFF31BBBFB8B001B112F /* SubscribeOn.swift in Sources */,
@ -5181,18 +5082,15 @@
CB255BD91BC46A9C00798A4C /* RetryWhen.swift in Sources */,
D2EBEADC1BB9B697003A27DC /* Cancelable.swift in Sources */,
D2EBEAE41BB9B697003A27DC /* ObservableType.swift in Sources */,
D2EBEB331BB9B6CA003A27DC /* Observable+Time.swift in Sources */,
D2EBEB191BB9B6C1003A27DC /* Reduce.swift in Sources */,
C867818A1DB814AD00B2029A /* Bag+Rx.swift in Sources */,
C8550B4D1D95A41400A6FCFE /* Reactive.swift in Sources */,
CB883B471BE256D4000AC2EE /* BooleanDisposable.swift in Sources */,
D2EBEB001BB9B6BA003A27DC /* Catch.swift in Sources */,
D2EBEB161BB9B6C1003A27DC /* ObserveOnSerialDispatchQueue.swift in Sources */,
C89814841E75B77B0035949C /* AsMaybe.swift in Sources */,
D2EBEB061BB9B6C1003A27DC /* Debug.swift in Sources */,
D2EBEB341BB9B6D2003A27DC /* AnonymousObserver.swift in Sources */,
D2EBEB421BB9B6DE003A27DC /* ReplaySubject.swift in Sources */,
D2EBEB2D1BB9B6CA003A27DC /* Observable+Concurrency.swift in Sources */,
D2EBEB381BB9B6D8003A27DC /* ConcurrentDispatchQueueScheduler.swift in Sources */,
C8B145021BD2D80100267DCE /* ImmediateScheduler.swift in Sources */,
C8BCD3C91C1468D4005F1280 /* ShareReplay1WhileConnected.swift in Sources */,
@ -5202,7 +5100,6 @@
C83D73C21C1DBAEE003DC470 /* InvocableType.swift in Sources */,
D2EBEB071BB9B6C1003A27DC /* Deferred.swift in Sources */,
C851068A1C2D550E0075150C /* String+Rx.swift in Sources */,
D2EBEB2C1BB9B6CA003A27DC /* Observable+Binding.swift in Sources */,
EB15145F1DFFAACB00555E2C /* Optional.swift in Sources */,
C8BF34D11C2E426800416CAE /* Platform.Linux.swift in Sources */,
D2EBEB041BB9B6C1003A27DC /* Concat.swift in Sources */,
@ -5230,11 +5127,9 @@
C8C0A4A71E886B1200B8215F /* Materialize.swift in Sources */,
252FC1D11E0D250500D28877 /* DefaultIfEmpty.swift in Sources */,
D2EBEB1F1BB9B6C1003A27DC /* Skip.swift in Sources */,
D2EBEB321BB9B6CA003A27DC /* Observable+StandardSequenceOperators.swift in Sources */,
C84CC5421BDC3B3E00E06A64 /* ElementAt.swift in Sources */,
D2EBEB081BB9B6C1003A27DC /* DelaySubscription.swift in Sources */,
D2EBEADE1BB9B697003A27DC /* Disposable.swift in Sources */,
D2EBEB2F1BB9B6CA003A27DC /* Observable+Debug.swift in Sources */,
D2EBEAE61BB9B697003A27DC /* ObserverType.swift in Sources */,
C83D73CA1C1DBAEE003DC470 /* ScheduledItemType.swift in Sources */,
D2EBEB011BB9B6BA003A27DC /* CombineLatest.swift in Sources */,
@ -5261,7 +5156,6 @@
D2EBEADD1BB9B697003A27DC /* ConnectableObservableType.swift in Sources */,
D2EBEB0C1BB9B6C1003A27DC /* Error.swift in Sources */,
D2EBEB361BB9B6D2003A27DC /* TailRecursiveSink.swift in Sources */,
D2EBEB311BB9B6CA003A27DC /* Observable+Single.swift in Sources */,
D235B2401BD003DD007E84DA /* Using.swift in Sources */,
D2EBEAE91BB9B697003A27DC /* RxMutableBox.swift in Sources */,
D2EBEAFC1BB9B6BA003A27DC /* Amb.swift in Sources */,
@ -5269,8 +5163,6 @@
D2EBEAE31BB9B697003A27DC /* ObservableType+Extensions.swift in Sources */,
B1D899911BF653410027B05C /* Timeout.swift in Sources */,
D2EBEB121BB9B6C1003A27DC /* Merge.swift in Sources */,
D2EBEB301BB9B6CA003A27DC /* Observable+Multiple.swift in Sources */,
D2EBEB2B1BB9B6CA003A27DC /* Observable+Aggregate.swift in Sources */,
D2EBEB291BB9B6C1003A27DC /* Zip+arity.swift in Sources */,
D2EBEB241BB9B6C1003A27DC /* TakeUntil.swift in Sources */,
CDDEF16C1D4FB40000CA8546 /* Disposables.swift in Sources */,
@ -5280,7 +5172,7 @@
D2EBEAE51BB9B697003A27DC /* AnyObserver.swift in Sources */,
D2EBEB3D1BB9B6D8003A27DC /* SchedulerServices+Emulation.swift in Sources */,
D2EBEB1C1BB9B6C1003A27DC /* Sample.swift in Sources */,
D2EBEAFD1BB9B6BA003A27DC /* AnonymousObservable.swift in Sources */,
D2EBEAFD1BB9B6BA003A27DC /* Create.swift in Sources */,
C86B0A581D735CCC005D8A16 /* Delay.swift in Sources */,
C867817A1DB8129E00B2029A /* PriorityQueue.swift in Sources */,
CB883B4C1BE369AA000AC2EE /* AddRef.swift in Sources */,
@ -5289,7 +5181,6 @@
D2EBEAF31BB9B6AE003A27DC /* DisposeBag.swift in Sources */,
252FC1E11E0DC64D00D28877 /* SwitchIfEmpty.swift in Sources */,
C8BF34CD1C2E426800416CAE /* Platform.Darwin.swift in Sources */,
D2EBEB1A1BB9B6C1003A27DC /* RefCount.swift in Sources */,
D2EBEB141BB9B6C1003A27DC /* Never.swift in Sources */,
D2EBEAE01BB9B697003A27DC /* Event.swift in Sources */,
D2EBEB411BB9B6DE003A27DC /* PublishSubject.swift in Sources */,
@ -5308,7 +5199,6 @@
D2EBEB0A1BB9B6C1003A27DC /* Do.swift in Sources */,
C83D73C61C1DBAEE003DC470 /* ScheduledItem.swift in Sources */,
C867817E1DB8129E00B2029A /* Queue.swift in Sources */,
D2EBEB2E1BB9B6CA003A27DC /* Observable+Creation.swift in Sources */,
);
runOnlyForDeploymentPostprocessing = 0;
};

4
RxSwift/Deprecated.swift
View File

@ -17,7 +17,7 @@ extension Observable {
*/
@available(*, deprecated, message: "Implicit conversions from any type to optional type are allowed and that is causing issues with `from` operator overloading.", renamed: "from(optional:)")
public static func from(_ optional: E?) -> Observable<E> {
return ObservableOptional(optional: optional)
return Observable.from(optional: optional)
}
/**
@ -31,7 +31,7 @@ extension Observable {
*/
@available(*, deprecated, message: "Implicit conversions from any type to optional type are allowed and that is causing issues with `from` operator overloading.", renamed: "from(optional:scheduler:)")
public static func from(_ optional: E?, scheduler: ImmediateSchedulerType) -> Observable<E> {
return ObservableOptionalScheduled(optional: optional, scheduler: scheduler)
return Observable.from(optional: optional, scheduler: scheduler)
}
}

4
RxSwift/Observable.swift
View File

@ -37,8 +37,8 @@ public class Observable<Element> : ObservableType {
// Swift compiler reports "Not supported yet" when trying to override protocol extensions, so ¯\_(ツ)_/¯
/// Optimizations for map operator
internal func composeMap<R>(_ selector: @escaping (Element) throws -> R) -> Observable<R> {
return Map(source: self, transform: selector)
internal func composeMap<R>(_ transform: @escaping (Element) throws -> R) -> Observable<R> {
return _map(source: self, transform: transform)
}
}

41
RxSwift/Observables/Implementations/Amb.swift
View File

@ -6,13 +6,46 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
enum AmbState {
extension Observable {
/**
Propagates the observable sequence that reacts first.
- seealso: [amb operator on reactivex.io](http://reactivex.io/documentation/operators/amb.html)
- returns: An observable sequence that surfaces any of the given sequences, whichever reacted first.
*/
public static func amb<S: Sequence>(_ sequence: S) -> Observable<Element>
where S.Iterator.Element == Observable<Element> {
return sequence.reduce(Observable<S.Iterator.Element.E>.never()) { a, o in
return a.amb(o.asObservable())
}
}
}
extension ObservableType {
/**
Propagates the observable sequence that reacts first.
- seealso: [amb operator on reactivex.io](http://reactivex.io/documentation/operators/amb.html)
- parameter right: Second observable sequence.
- returns: An observable sequence that surfaces either of the given sequences, whichever reacted first.
*/
public func amb<O2: ObservableType>
(_ right: O2)
-> Observable<E> where O2.E == E {
return Amb(left: asObservable(), right: right.asObservable())
}
}
fileprivate enum AmbState {
case neither
case left
case right
}
final class AmbObserver<O: ObserverType> : ObserverType {
final fileprivate class AmbObserver<O: ObserverType> : ObserverType {
typealias Element = O.E
typealias Parent = AmbSink<O>
typealias This = AmbObserver<O>
@ -46,7 +79,7 @@ final class AmbObserver<O: ObserverType> : ObserverType {
}
}
final class AmbSink<O: ObserverType> : Sink<O> {
final fileprivate class AmbSink<O: ObserverType> : Sink<O> {
typealias ElementType = O.E
typealias Parent = Amb<ElementType>
typealias AmbObserverType = AmbObserver<O>
@ -107,7 +140,7 @@ final class AmbSink<O: ObserverType> : Sink<O> {
}
}
final class Amb<Element>: Producer<Element> {
final fileprivate class Amb<Element>: Producer<Element> {
fileprivate let _left: Observable<Element>
fileprivate let _right: Observable<Element>

24
RxSwift/Observables/Implementations/Buffer.swift
View File

@ -6,7 +6,27 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class BufferTimeCount<Element> : Producer<[Element]> {
extension ObservableType {
/**
Projects each element of an observable sequence into a buffer that's sent out when either it's full or a given amount of time has elapsed, using the specified scheduler to run timers.
A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first.
- seealso: [buffer operator on reactivex.io](http://reactivex.io/documentation/operators/buffer.html)
- parameter timeSpan: Maximum time length of a buffer.
- parameter count: Maximum element count of a buffer.
- parameter scheduler: Scheduler to run buffering timers on.
- returns: An observable sequence of buffers.
*/
public func buffer(timeSpan: RxTimeInterval, count: Int, scheduler: SchedulerType)
-> Observable<[E]> {
return BufferTimeCount(source: self.asObservable(), timeSpan: timeSpan, count: count, scheduler: scheduler)
}
}
final fileprivate class BufferTimeCount<Element> : Producer<[Element]> {
fileprivate let _timeSpan: RxTimeInterval
fileprivate let _count: Int
@ -27,7 +47,7 @@ final class BufferTimeCount<Element> : Producer<[Element]> {
}
}
final class BufferTimeCountSink<Element, O: ObserverType>
final fileprivate class BufferTimeCountSink<Element, O: ObserverType>
: Sink<O>
, LockOwnerType
, ObserverType

85
RxSwift/Observables/Implementations/Catch.swift
View File

@ -6,9 +6,84 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
extension ObservableType {
/**
Continues an observable sequence that is terminated by an error with the observable sequence produced by the handler.
- seealso: [catch operator on reactivex.io](http://reactivex.io/documentation/operators/catch.html)
- parameter handler: Error handler function, producing another observable sequence.
- returns: An observable sequence containing the source sequence's elements, followed by the elements produced by the handler's resulting observable sequence in case an error occurred.
*/
public func catchError(_ handler: @escaping (Swift.Error) throws -> Observable<E>)
-> Observable<E> {
return Catch(source: asObservable(), handler: handler)
}
/**
Continues an observable sequence that is terminated by an error with a single element.
- seealso: [catch operator on reactivex.io](http://reactivex.io/documentation/operators/catch.html)
- parameter element: Last element in an observable sequence in case error occurs.
- returns: An observable sequence containing the source sequence's elements, followed by the `element` in case an error occurred.
*/
public func catchErrorJustReturn(_ element: E)
-> Observable<E> {
return Catch(source: asObservable(), handler: { _ in Observable.just(element) })
}
}
extension Observable {
/**
Continues an observable sequence that is terminated by an error with the next observable sequence.
- seealso: [catch operator on reactivex.io](http://reactivex.io/documentation/operators/catch.html)
- returns: An observable sequence containing elements from consecutive source sequences until a source sequence terminates successfully.
*/
public static func catchError<S: Sequence>(_ sequence: S) -> Observable<Element>
where S.Iterator.Element == Observable<Element> {
return CatchSequence(sources: sequence)
}
}
extension ObservableType {
/**
Repeats the source observable sequence until it successfully terminates.
**This could potentially create an infinite sequence.**
- seealso: [retry operator on reactivex.io](http://reactivex.io/documentation/operators/retry.html)
- returns: Observable sequence to repeat until it successfully terminates.
*/
public func retry() -> Observable<E> {
return CatchSequence(sources: InfiniteSequence(repeatedValue: self.asObservable()))
}
/**
Repeats the source observable sequence the specified number of times in case of an error or until it successfully terminates.
If you encounter an error and want it to retry once, then you must use `retry(2)`
- seealso: [retry operator on reactivex.io](http://reactivex.io/documentation/operators/retry.html)
- parameter maxAttemptCount: Maximum number of times to repeat the sequence.
- returns: An observable sequence producing the elements of the given sequence repeatedly until it terminates successfully.
*/
public func retry(_ maxAttemptCount: Int)
-> Observable<E> {
return CatchSequence(sources: repeatElement(self.asObservable(), count: maxAttemptCount))
}
}
// catch with callback
final class CatchSinkProxy<O: ObserverType> : ObserverType {
final fileprivate class CatchSinkProxy<O: ObserverType> : ObserverType {
typealias E = O.E
typealias Parent = CatchSink<O>
@ -30,7 +105,7 @@ final class CatchSinkProxy<O: ObserverType> : ObserverType {
}
}
final class CatchSink<O: ObserverType> : Sink<O>, ObserverType {
final fileprivate class CatchSink<O: ObserverType> : Sink<O>, ObserverType {
typealias E = O.E
typealias Parent = Catch<E>
@ -73,7 +148,7 @@ final class CatchSink<O: ObserverType> : Sink<O>, ObserverType {
}
}
final class Catch<Element> : Producer<Element> {
final fileprivate class Catch<Element> : Producer<Element> {
typealias Handler = (Swift.Error) throws -> Observable<Element>
fileprivate let _source: Observable<Element>
@ -93,7 +168,7 @@ final class Catch<Element> : Producer<Element> {
// catch enumerable
final class CatchSequenceSink<S: Sequence, O: ObserverType>
final fileprivate class CatchSequenceSink<S: Sequence, O: ObserverType>
: TailRecursiveSink<S, O>
, ObserverType where S.Iterator.Element : ObservableConvertibleType, S.Iterator.Element.E == O.E {
typealias Element = O.E
@ -143,7 +218,7 @@ final class CatchSequenceSink<S: Sequence, O: ObserverType>
}
}
final class CatchSequence<S: Sequence> : Producer<S.Iterator.Element.E> where S.Iterator.Element : ObservableConvertibleType {
final fileprivate class CatchSequence<S: Sequence> : Producer<S.Iterator.Element.E> where S.Iterator.Element : ObservableConvertibleType {
typealias Element = S.Iterator.Element.E
let sources: S

31
RxSwift/Observables/Implementations/CombineLatest+Collection.swift
View File

@ -6,7 +6,34 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class CombineLatestCollectionTypeSink<C: Collection, O: ObserverType>
extension Observable {
/**
Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element.
- seealso: [combinelatest operator on reactivex.io](http://reactivex.io/documentation/operators/combinelatest.html)
- parameter resultSelector: Function to invoke whenever any of the sources produces an element.
- returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
*/
public static func combineLatest<C: Collection>(_ collection: C, _ resultSelector: @escaping ([C.Iterator.Element.E]) throws -> Element) -> Observable<Element>
where C.Iterator.Element: ObservableType {
return CombineLatestCollectionType(sources: collection, resultSelector: resultSelector)
}
/**
Merges the specified observable sequences into one observable sequence whenever any of the observable sequences produces an element.
- seealso: [combinelatest operator on reactivex.io](http://reactivex.io/documentation/operators/combinelatest.html)
- returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
*/
public static func combineLatest<C: Collection>(_ collection: C) -> Observable<[Element]>
where C.Iterator.Element: ObservableType, C.Iterator.Element.E == Element {
return CombineLatestCollectionType(sources: collection, resultSelector: { $0 })
}
}
final fileprivate class CombineLatestCollectionTypeSink<C: Collection, O: ObserverType>
: Sink<O> where C.Iterator.Element : ObservableConvertibleType {
typealias R = O.E
typealias Parent = CombineLatestCollectionType<C, R>
@ -105,7 +132,7 @@ final class CombineLatestCollectionTypeSink<C: Collection, O: ObserverType>
}
}
final class CombineLatestCollectionType<C: Collection, R> : Producer<R> where C.Iterator.Element : ObservableConvertibleType {
final fileprivate class CombineLatestCollectionType<C: Collection, R> : Producer<R> where C.Iterator.Element : ObservableConvertibleType {
typealias ResultSelector = ([C.Iterator.Element.E]) throws -> R
let _sources: C

73
RxSwift/Observables/Implementations/Concat.swift
View File

@ -6,8 +6,77 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
extension ObservableType {
final class ConcatSink<S: Sequence, O: ObserverType>
/**
Concatenates the second observable sequence to `self` upon successful termination of `self`.
- seealso: [concat operator on reactivex.io](http://reactivex.io/documentation/operators/concat.html)
- parameter second: Second observable sequence.
- returns: An observable sequence that contains the elements of `self`, followed by those of the second sequence.
*/
public func concat<O: ObservableConvertibleType>(_ second: O) -> Observable<E> where O.E == E {
return Observable.concat([self.asObservable(), second.asObservable()])
}
}
extension Observable {
/**
Concatenates all observable sequences in the given sequence, as long as the previous observable sequence terminated successfully.
This operator has tail recursive optimizations that will prevent stack overflow.
Optimizations will be performed in cases equivalent to following:
[1, [2, [3, .....].concat()].concat].concat()
- seealso: [concat operator on reactivex.io](http://reactivex.io/documentation/operators/concat.html)
- returns: An observable sequence that contains the elements of each given sequence, in sequential order.
*/
public static func concat<S: Sequence >(_ sequence: S) -> Observable<Element>
where S.Iterator.Element == Observable<Element> {
return Concat(sources: sequence, count: nil)
}
/**
Concatenates all observable sequences in the given collection, as long as the previous observable sequence terminated successfully.
This operator has tail recursive optimizations that will prevent stack overflow.
Optimizations will be performed in cases equivalent to following:
[1, [2, [3, .....].concat()].concat].concat()
- seealso: [concat operator on reactivex.io](http://reactivex.io/documentation/operators/concat.html)
- returns: An observable sequence that contains the elements of each given sequence, in sequential order.
*/
public static func concat<S: Collection >(_ collection: S) -> Observable<Element>
where S.Iterator.Element == Observable<Element> {
return Concat(sources: collection, count: collection.count.toIntMax())
}
/**
Concatenates all observable sequences in the given collection, as long as the previous observable sequence terminated successfully.
This operator has tail recursive optimizations that will prevent stack overflow.
Optimizations will be performed in cases equivalent to following:
[1, [2, [3, .....].concat()].concat].concat()
- seealso: [concat operator on reactivex.io](http://reactivex.io/documentation/operators/concat.html)
- returns: An observable sequence that contains the elements of each given sequence, in sequential order.
*/
public static func concat(_ sources: Observable<Element> ...) -> Observable<Element> {
return Concat(sources: sources, count: sources.count.toIntMax())
}
}
final fileprivate class ConcatSink<S: Sequence, O: ObserverType>
: TailRecursiveSink<S, O>
, ObserverType where S.Iterator.Element : ObservableConvertibleType, S.Iterator.Element.E == O.E {
typealias Element = O.E
@ -42,7 +111,7 @@ final class ConcatSink<S: Sequence, O: ObserverType>
}
}
final class Concat<S: Sequence> : Producer<S.Iterator.Element.E> where S.Iterator.Element : ObservableConvertibleType {
final fileprivate class Concat<S: Sequence> : Producer<S.Iterator.Element.E> where S.Iterator.Element : ObservableConvertibleType {
typealias Element = S.Iterator.Element.E
fileprivate let _sources: S

21
RxSwift/Observables/Implementations/ConnectableObservable.swift
View File

@ -6,6 +6,27 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
extension ObservableType {
/**
Multicasts the source sequence notifications through the specified subject to the resulting connectable observable.
Upon connection of the connectable observable, the subject is subscribed to the source exactly one, and messages are forwarded to the observers registered with the connectable observable.
For specializations with fixed subject types, see `publish` and `replay`.
- seealso: [multicast operator on reactivex.io](http://reactivex.io/documentation/operators/publish.html)
- parameter subject: Subject to push source elements into.
- returns: A connectable observable sequence that upon connection causes the source sequence to push results into the specified subject.
*/
public func multicast<S: SubjectType>(_ subject: S)
-> ConnectableObservable<S.E> where S.SubjectObserverType.E == E {
return ConnectableObservableAdapter(source: self.asObservable(), subject: subject)
}
}
/**
Represents an observable wrapper that can be connected and disconnected from its underlying observable sequence.
*/

22
RxSwift/Observables/Implementations/AnonymousObservable.swift → RxSwift/Observables/Implementations/Create.swift
View File

@ -1,12 +1,28 @@
//
// AnonymousObservable.swift
// Create.swift
// RxSwift
//
// Created by Krunoslav Zaher on 2/8/15.
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class AnonymousObservableSink<O: ObserverType> : Sink<O>, ObserverType {
extension Observable {
// MARK: create
/**
Creates an observable sequence from a specified subscribe method implementation.
- seealso: [create operator on reactivex.io](http://reactivex.io/documentation/operators/create.html)
- parameter subscribe: Implementation of the resulting observable sequence's `subscribe` method.
- returns: The observable sequence with the specified implementation for the `subscribe` method.
*/
public static func create(_ subscribe: @escaping (AnyObserver<E>) -> Disposable) -> Observable<E> {
return AnonymousObservable(subscribe)
}
}
final fileprivate class AnonymousObservableSink<O: ObserverType> : Sink<O>, ObserverType {
typealias E = O.E
typealias Parent = AnonymousObservable<E>
@ -50,7 +66,7 @@ final class AnonymousObservableSink<O: ObserverType> : Sink<O>, ObserverType {
}
}
final class AnonymousObservable<Element> : Producer<Element> {
final fileprivate class AnonymousObservable<Element> : Producer<Element> {
typealias SubscribeHandler = (AnyObserver<Element>) -> Disposable
let _subscribeHandler: SubscribeHandler

21
RxSwift/Observables/Implementations/Debounce.swift
View File

@ -6,7 +6,24 @@
// Copyright © 2016 Krunoslav Zaher. All rights reserved.
//
final class DebounceSink<O: ObserverType>
extension ObservableType {
/**
Ignores elements from an observable sequence which are followed by another element within a specified relative time duration, using the specified scheduler to run throttling timers.
- seealso: [debounce operator on reactivex.io](http://reactivex.io/documentation/operators/debounce.html)
- parameter dueTime: Throttling duration for each element.
- parameter scheduler: Scheduler to run the throttle timers on.
- returns: The throttled sequence.
*/
public func debounce(_ dueTime: RxTimeInterval, scheduler: SchedulerType)
-> Observable<E> {
return Debounce(source: self.asObservable(), dueTime: dueTime, scheduler: scheduler)
}
}
final fileprivate class DebounceSink<O: ObserverType>
: Sink<O>
, ObserverType
, LockOwnerType
@ -81,7 +98,7 @@ final class DebounceSink<O: ObserverType>
}
}
final class Debounce<Element> : Producer<Element> {
final fileprivate class Debounce<Element> : Producer<Element> {
fileprivate let _source: Observable<Element>
fileprivate let _dueTime: RxTimeInterval

25
RxSwift/Observables/Implementations/Debug.swift
View File

@ -9,13 +9,30 @@
import struct Foundation.Date
import class Foundation.DateFormatter
let dateFormat = "yyyy-MM-dd HH:mm:ss.SSS"
extension ObservableType {
func logEvent(_ identifier: String, dateFormat: DateFormatter, content: String) {
/**
Prints received events for all observers on standard output.
- seealso: [do operator on reactivex.io](http://reactivex.io/documentation/operators/do.html)
- parameter identifier: Identifier that is printed together with event description to standard output.
- parameter trimOutput: Should output be trimmed to max 40 characters.
- returns: An observable sequence whose events are printed to standard output.
*/
public func debug(_ identifier: String? = nil, trimOutput: Bool = false, file: String = #file, line: UInt = #line, function: String = #function)
-> Observable<E> {
return Debug(source: self, identifier: identifier, trimOutput: trimOutput, file: file, line: line, function: function)
}
}
fileprivate let dateFormat = "yyyy-MM-dd HH:mm:ss.SSS"
fileprivate func logEvent(_ identifier: String, dateFormat: DateFormatter, content: String) {
print("\(dateFormat.string(from: Date())): \(identifier) -> \(content)")
}
final class DebugSink<Source: ObservableType, O: ObserverType> : Sink<O>, ObserverType where O.E == Source.E {
final fileprivate class DebugSink<Source: ObservableType, O: ObserverType> : Sink<O>, ObserverType where O.E == Source.E {
typealias Element = O.E
typealias Parent = Debug<Source>
@ -55,7 +72,7 @@ final class DebugSink<Source: ObservableType, O: ObserverType> : Sink<O>, Observ
}
}
final class Debug<Source: ObservableType> : Producer<Source.E> {
final fileprivate class Debug<Source: ObservableType> : Producer<Source.E> {
fileprivate let _identifier: String
fileprivate let _trimOutput: Bool
fileprivate let _source: Source

19
RxSwift/Observables/Implementations/DefaultIfEmpty.swift
View File

@ -6,7 +6,22 @@
// Copyright © 2016 Krunoslav Zaher. All rights reserved.
//
final class DefaultIfEmptySink<O: ObserverType>: Sink<O>, ObserverType {
extension ObservableType {
/**
Emits elements from the source observable sequence, or a default element if the source observable sequence is empty.
- seealso: [DefaultIfEmpty operator on reactivex.io](http://reactivex.io/documentation/operators/defaultifempty.html)
- parameter default: Default element to be sent if the source does not emit any elements
- returns: An observable sequence which emits default element end completes in case the original sequence is empty
*/
public func ifEmpty(default: E) -> Observable<E> {
return DefaultIfEmpty(source: self.asObservable(), default: `default`)
}
}
final fileprivate class DefaultIfEmptySink<O: ObserverType>: Sink<O>, ObserverType {
typealias E = O.E
private let _default: E
private var _isEmpty = true
@ -34,7 +49,7 @@ final class DefaultIfEmptySink<O: ObserverType>: Sink<O>, ObserverType {
}
}
final class DefaultIfEmpty<SourceType>: Producer<SourceType> {
final fileprivate class DefaultIfEmpty<SourceType>: Producer<SourceType> {
private let _source: Observable<SourceType>
private let _default: SourceType

19
RxSwift/Observables/Implementations/Deferred.swift
View File

@ -6,7 +6,22 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class DeferredSink<S: ObservableType, O: ObserverType> : Sink<O>, ObserverType where S.E == O.E {
extension Observable {
/**
Returns an observable sequence that invokes the specified factory function whenever a new observer subscribes.
- seealso: [defer operator on reactivex.io](http://reactivex.io/documentation/operators/defer.html)
- parameter observableFactory: Observable factory function to invoke for each observer that subscribes to the resulting sequence.
- returns: An observable sequence whose observers trigger an invocation of the given observable factory function.
*/
public static func deferred(_ observableFactory: @escaping () throws -> Observable<E>)
-> Observable<E> {
return Deferred(observableFactory: observableFactory)
}
}
final fileprivate class DeferredSink<S: ObservableType, O: ObserverType> : Sink<O>, ObserverType where S.E == O.E {
typealias E = O.E
private let _observableFactory: () throws -> S
@ -42,7 +57,7 @@ final class DeferredSink<S: ObservableType, O: ObserverType> : Sink<O>, Observer
}
}
final class Deferred<S: ObservableType> : Producer<S.E> {
final fileprivate class Deferred<S: ObservableType> : Producer<S.E> {
typealias Factory = () throws -> S
private let _observableFactory : Factory

21
RxSwift/Observables/Implementations/Delay.swift
View File

@ -8,7 +8,24 @@
import struct Foundation.Date
final class DelaySink<O: ObserverType>
extension ObservableType {
/**
Returns an observable sequence by the source observable sequence shifted forward in time by a specified delay. Error events from the source observable sequence are not delayed.
- seealso: [delay operator on reactivex.io](http://reactivex.io/documentation/operators/delay.html)
- parameter dueTime: Relative time shift of the source by.
- parameter scheduler: Scheduler to run the subscription delay timer on.
- returns: the source Observable shifted in time by the specified delay.
*/
public func delay(_ dueTime: RxTimeInterval, scheduler: SchedulerType)
-> Observable<E> {
return Delay(source: self.asObservable(), dueTime: dueTime, scheduler: scheduler)
}
}
final fileprivate class DelaySink<O: ObserverType>
: Sink<O>
, ObserverType {
typealias E = O.E
@ -145,7 +162,7 @@ final class DelaySink<O: ObserverType>
}
}
final class Delay<Element>: Producer<Element> {
final fileprivate class Delay<Element>: Producer<Element> {
private let _source: Observable<Element>
private let _dueTime: RxTimeInterval
private let _scheduler: SchedulerType

21
RxSwift/Observables/Implementations/DelaySubscription.swift
View File

@ -6,7 +6,24 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class DelaySubscriptionSink<O: ObserverType>
extension ObservableType {
/**
Time shifts the observable sequence by delaying the subscription with the specified relative time duration, using the specified scheduler to run timers.
- seealso: [delay operator on reactivex.io](http://reactivex.io/documentation/operators/delay.html)
- parameter dueTime: Relative time shift of the subscription.
- parameter scheduler: Scheduler to run the subscription delay timer on.
- returns: Time-shifted sequence.
*/
public func delaySubscription(_ dueTime: RxTimeInterval, scheduler: SchedulerType)
-> Observable<E> {
return DelaySubscription(source: self.asObservable(), dueTime: dueTime, scheduler: scheduler)
}
}
final fileprivate class DelaySubscriptionSink<O: ObserverType>
: Sink<O>, ObserverType {
typealias E = O.E
typealias Parent = DelaySubscription<E>
@ -27,7 +44,7 @@ final class DelaySubscriptionSink<O: ObserverType>
}
final class DelaySubscription<Element>: Producer<Element> {
final fileprivate class DelaySubscription<Element>: Producer<Element> {
private let _source: Observable<Element>
private let _dueTime: RxTimeInterval
private let _scheduler: SchedulerType

14
RxSwift/Observables/Implementations/Dematerialize.swift
View File

@ -6,6 +6,18 @@
// Copyright © 2017 Krunoslav Zaher. All rights reserved.
//
extension ObservableType where E: EventConvertible {
/**
Convert any previously materialized Observable into it's original form.
- seealso: [materialize operator on reactivex.io](http://reactivex.io/documentation/operators/materialize-dematerialize.html)
- returns: The dematerialized observable sequence.
*/
public func dematerialize() -> Observable<E.ElementType> {
return Dematerialize(source: self.asObservable())
}
}
fileprivate final class DematerializeSink<Element: EventConvertible, O: ObserverType>: Sink<O>, ObserverType where O.E == Element.ElementType {
fileprivate func on(_ event: Event<Element>) {
switch event {
@ -24,7 +36,7 @@ fileprivate final class DematerializeSink<Element: EventConvertible, O: Observer
}
}
final class Dematerialize<Element: EventConvertible>: Producer<Element.ElementType> {
final fileprivate class Dematerialize<Element: EventConvertible>: Producer<Element.ElementType> {
private let _source: Observable<Element>
init(source: Observable<Element>) {

61
RxSwift/Observables/Implementations/DistinctUntilChanged.swift
View File

@ -6,7 +6,64 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class DistinctUntilChangedSink<O: ObserverType, Key>: Sink<O>, ObserverType {
extension ObservableType where E: Equatable {
/**
Returns an observable sequence that contains only distinct contiguous elements according to equality operator.
- seealso: [distinct operator on reactivex.io](http://reactivex.io/documentation/operators/distinct.html)
- returns: An observable sequence only containing the distinct contiguous elements, based on equality operator, from the source sequence.
*/
public func distinctUntilChanged()
-> Observable<E> {
return self.distinctUntilChanged({ $0 }, comparer: { ($0 == $1) })
}
}
extension ObservableType {
/**
Returns an observable sequence that contains only distinct contiguous elements according to the `keySelector`.
- seealso: [distinct operator on reactivex.io](http://reactivex.io/documentation/operators/distinct.html)
- parameter keySelector: A function to compute the comparison key for each element.
- returns: An observable sequence only containing the distinct contiguous elements, based on a computed key value, from the source sequence.
*/
public func distinctUntilChanged<K: Equatable>(_ keySelector: @escaping (E) throws -> K)
-> Observable<E> {
return self.distinctUntilChanged(keySelector, comparer: { $0 == $1 })
}
/**
Returns an observable sequence that contains only distinct contiguous elements according to the `comparer`.
- seealso: [distinct operator on reactivex.io](http://reactivex.io/documentation/operators/distinct.html)
- parameter comparer: Equality comparer for computed key values.
- returns: An observable sequence only containing the distinct contiguous elements, based on `comparer`, from the source sequence.
*/
public func distinctUntilChanged(_ comparer: @escaping (E, E) throws -> Bool)
-> Observable<E> {
return self.distinctUntilChanged({ $0 }, comparer: comparer)
}
/**
Returns an observable sequence that contains only distinct contiguous elements according to the keySelector and the comparer.
- seealso: [distinct operator on reactivex.io](http://reactivex.io/documentation/operators/distinct.html)
- parameter keySelector: A function to compute the comparison key for each element.
- parameter comparer: Equality comparer for computed key values.
- returns: An observable sequence only containing the distinct contiguous elements, based on a computed key value and the comparer, from the source sequence.
*/
public func distinctUntilChanged<K>(_ keySelector: @escaping (E) throws -> K, comparer: @escaping (K, K) throws -> Bool)
-> Observable<E> {
return DistinctUntilChanged(source: self.asObservable(), selector: keySelector, comparer: comparer)
}
}
final fileprivate class DistinctUntilChangedSink<O: ObserverType, Key>: Sink<O>, ObserverType {
typealias E = O.E
private let _parent: DistinctUntilChanged<E, Key>
@ -46,7 +103,7 @@ final class DistinctUntilChangedSink<O: ObserverType, Key>: Sink<O>, ObserverTyp
}
}
final class DistinctUntilChanged<Element, Key>: Producer<Element> {
final fileprivate class DistinctUntilChanged<Element, Key>: Producer<Element> {
typealias KeySelector = (Element) throws -> Key
typealias EqualityComparer = (Key, Key) throws -> Bool

33
RxSwift/Observables/Implementations/Do.swift
View File

@ -6,7 +6,36 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class DoSink<O: ObserverType> : Sink<O>, ObserverType {
extension ObservableType {
/**
Invokes an action for each event in the observable sequence, and propagates all observer messages through the result sequence.
- seealso: [do operator on reactivex.io](http://reactivex.io/documentation/operators/do.html)
- parameter onNext: Action to invoke for each element in the observable sequence.
- parameter onError: Action to invoke upon errored termination of the observable sequence.
- parameter onCompleted: Action to invoke upon graceful termination of the observable sequence.
- parameter onSubscribe: Action to invoke before subscribing to source observable sequence.
- parameter onSubscribed: Action to invoke after subscribing to source observable sequence.
- parameter onDispose: Action to invoke after subscription to source observable has been disposed for any reason. It can be either because sequence terminates for some reason or observer subscription being disposed.
- returns: The source sequence with the side-effecting behavior applied.
*/
public func `do`(onNext: ((E) throws -> Void)? = nil, onError: ((Swift.Error) throws -> Void)? = nil, onCompleted: (() throws -> Void)? = nil, onSubscribe: (() -> ())? = nil, onSubscribed: (() -> ())? = nil, onDispose: (() -> ())? = nil)
-> Observable<E> {
return Do(source: self.asObservable(), eventHandler: { e in
switch e {
case .next(let element):
try onNext?(element)
case .error(let e):
try onError?(e)
case .completed:
try onCompleted?()
}
}, onSubscribe: onSubscribe, onSubscribed: onSubscribed, onDispose: onDispose)
}
}
final fileprivate class DoSink<O: ObserverType> : Sink<O>, ObserverType {
typealias Element = O.E
typealias Parent = Do<Element>
@ -32,7 +61,7 @@ final class DoSink<O: ObserverType> : Sink<O>, ObserverType {
}
}
final class Do<Element> : Producer<Element> {
final fileprivate class Do<Element> : Producer<Element> {
typealias EventHandler = (Event<Element>) throws -> Void
fileprivate let _source: Observable<Element>

19
RxSwift/Observables/Implementations/ElementAt.swift
View File

@ -6,8 +6,23 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
extension ObservableType {
final class ElementAtSink<O: ObserverType> : Sink<O>, ObserverType {
/**
Returns a sequence emitting only element _n_ emitted by an Observable
- seealso: [elementAt operator on reactivex.io](http://reactivex.io/documentation/operators/elementat.html)
- parameter index: The index of the required element (starting from 0).
- returns: An observable sequence that emits the desired element as its own sole emission.
*/
public func elementAt(_ index: Int)
-> Observable<E> {
return ElementAt(source: asObservable(), index: index, throwOnEmpty: true)
}
}
final fileprivate class ElementAtSink<O: ObserverType> : Sink<O>, ObserverType {
typealias SourceType = O.E
typealias Parent = ElementAt<SourceType>
@ -54,7 +69,7 @@ final class ElementAtSink<O: ObserverType> : Sink<O>, ObserverType {
}
}
final class ElementAt<SourceType> : Producer<SourceType> {
final fileprivate class ElementAt<SourceType> : Producer<SourceType> {
let _source: Observable<SourceType>
let _throwOnEmpty: Bool

15
RxSwift/Observables/Implementations/Empty.swift
View File

@ -6,7 +6,20 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class EmptyProducer<Element> : Producer<Element> {
extension Observable {
/**
Returns an empty observable sequence, using the specified scheduler to send out the single `Completed` message.
- seealso: [empty operator on reactivex.io](http://reactivex.io/documentation/operators/empty-never-throw.html)
- returns: An observable sequence with no elements.
*/
public static func empty() -> Observable<E> {
return EmptyProducer<E>()
}
}
final fileprivate class EmptyProducer<Element> : Producer<Element> {
override func subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == Element {
observer.on(.completed)
return Disposables.create()

15
RxSwift/Observables/Implementations/Error.swift
View File

@ -6,7 +6,20 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class ErrorProducer<Element> : Producer<Element> {
extension Observable {
/**
Returns an observable sequence that terminates with an `error`.
- seealso: [throw operator on reactivex.io](http://reactivex.io/documentation/operators/empty-never-throw.html)
- returns: The observable sequence that terminates with specified error.
*/
public static func error(_ error: Swift.Error) -> Observable<E> {
return ErrorProducer(error: error)
}
}
final fileprivate class ErrorProducer<Element> : Producer<Element> {
private let _error: Swift.Error
init(error: Swift.Error) {

37
RxSwift/Observables/Implementations/Filter.swift
View File

@ -6,7 +6,40 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class FilterSink<O : ObserverType>: Sink<O>, ObserverType {
extension ObservableType {
/**
Filters the elements of an observable sequence based on a predicate.
- seealso: [filter operator on reactivex.io](http://reactivex.io/documentation/operators/filter.html)
- parameter predicate: A function to test each source element for a condition.
- returns: An observable sequence that contains elements from the input sequence that satisfy the condition.
*/
public func filter(_ predicate: @escaping (E) throws -> Bool)
-> Observable<E> {
return Filter(source: asObservable(), predicate: predicate)
}
}
extension ObservableType {
/**
Skips elements and completes (or errors) when the receiver completes (or errors). Equivalent to filter that always returns false.
- seealso: [ignoreElements operator on reactivex.io](http://reactivex.io/documentation/operators/ignoreelements.html)
- returns: An observable sequence that skips all elements of the source sequence.
*/
public func ignoreElements()
-> Observable<E> {
return filter { _ -> Bool in
return false
}
}
}
final fileprivate class FilterSink<O : ObserverType>: Sink<O>, ObserverType {
typealias Predicate = (Element) throws -> Bool
typealias Element = O.E
@ -37,7 +70,7 @@ final class FilterSink<O : ObserverType>: Sink<O>, ObserverType {
}
}
final class Filter<Element> : Producer<Element> {
final fileprivate class Filter<Element> : Producer<Element> {
typealias Predicate = (Element) throws -> Bool
private let _source: Observable<Element>

22
RxSwift/Observables/Implementations/Generate.swift
View File

@ -6,7 +6,25 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class GenerateSink<S, O: ObserverType> : Sink<O> {
extension Observable {
/**
Generates an observable sequence by running a state-driven loop producing the sequence's elements, using the specified scheduler
to run the loop send out observer messages.
- seealso: [create operator on reactivex.io](http://reactivex.io/documentation/operators/create.html)
- parameter initialState: Initial state.
- parameter condition: Condition to terminate generation (upon returning `false`).
- parameter iterate: Iteration step function.
- parameter scheduler: Scheduler on which to run the generator loop.
- returns: The generated sequence.
*/
public static func generate(initialState: E, condition: @escaping (E) throws -> Bool, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance, iterate: @escaping (E) throws -> E) -> Observable<E> {
return Generate(initialState: initialState, condition: condition, iterate: iterate, resultSelector: { $0 }, scheduler: scheduler)
}
}
final fileprivate class GenerateSink<S, O: ObserverType> : Sink<O> {
typealias Parent = Generate<S, O.E>
private let _parent: Parent
@ -45,7 +63,7 @@ final class GenerateSink<S, O: ObserverType> : Sink<O> {
}
}
final class Generate<S, E> : Producer<E> {
final fileprivate class Generate<S, E> : Producer<E> {
fileprivate let _initialState: S
fileprivate let _condition: (S) throws -> Bool
fileprivate let _iterate: (S) throws -> S

21
RxSwift/Observables/Implementations/GroupBy.swift
View File

@ -6,7 +6,22 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class GroupedObservableImpl<Key, Element> : Observable<Element> {
extension ObservableType {
/*
Groups the elements of an observable sequence according to a specified key selector function.
- seealso: [groupBy operator on reactivex.io](http://reactivex.io/documentation/operators/groupby.html)
- parameter keySelector: A function to extract the key for each element.
- returns: A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value.
*/
public func groupBy<K: Hashable>(keySelector: @escaping (E) throws -> K)
-> Observable<GroupedObservable<K,E>> {
return GroupBy(source: self.asObservable(), selector: keySelector)
}
}
final fileprivate class GroupedObservableImpl<Key, Element> : Observable<Element> {
private var _subject: PublishSubject<Element>
private var _refCount: RefCountDisposable
@ -23,7 +38,7 @@ final class GroupedObservableImpl<Key, Element> : Observable<Element> {
}
final class GroupBySink<Key: Hashable, Element, O: ObserverType>
final fileprivate class GroupBySink<Key: Hashable, Element, O: ObserverType>
: Sink<O>
, ObserverType where O.E == GroupedObservable<Key, Element> {
typealias E = Element
@ -101,7 +116,7 @@ final class GroupBySink<Key: Hashable, Element, O: ObserverType>
}
}
final class GroupBy<Key: Hashable, Element>: Producer<GroupedObservable<Key,Element>> {
final fileprivate class GroupBy<Key: Hashable, Element>: Producer<GroupedObservable<Key,Element>> {
typealias KeySelector = (Element) throws -> Key
fileprivate let _source: Observable<Element>

33
RxSwift/Observables/Implementations/Just.swift
View File

@ -6,7 +6,34 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class JustScheduledSink<O: ObserverType> : Sink<O> {
extension Observable {
/**
Returns an observable sequence that contains a single element.
- seealso: [just operator on reactivex.io](http://reactivex.io/documentation/operators/just.html)
- parameter element: Single element in the resulting observable sequence.
- returns: An observable sequence containing the single specified element.
*/
public static func just(_ element: E) -> Observable<E> {
return Just(element: element)
}
/**
Returns an observable sequence that contains a single element.
- seealso: [just operator on reactivex.io](http://reactivex.io/documentation/operators/just.html)
- parameter element: Single element in the resulting observable sequence.
- parameter: Scheduler to send the single element on.
- returns: An observable sequence containing the single specified element.
*/
public static func just(_ element: E, scheduler: ImmediateSchedulerType) -> Observable<E> {
return JustScheduled(element: element, scheduler: scheduler)
}
}
final fileprivate class JustScheduledSink<O: ObserverType> : Sink<O> {
typealias Parent = JustScheduled<O.E>
private let _parent: Parent
@ -29,7 +56,7 @@ final class JustScheduledSink<O: ObserverType> : Sink<O> {
}
}
final class JustScheduled<Element> : Producer<Element> {
final fileprivate class JustScheduled<Element> : Producer<Element> {
fileprivate let _scheduler: ImmediateSchedulerType
fileprivate let _element: Element
@ -45,7 +72,7 @@ final class JustScheduled<Element> : Producer<Element> {
}
}
final class Just<Element> : Producer<Element> {
final fileprivate class Just<Element> : Producer<Element> {
private let _element: Element
init(element: Element) {

44
RxSwift/Observables/Implementations/Map.swift
View File

@ -6,7 +6,37 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class MapSink<SourceType, O : ObserverType> : Sink<O>, ObserverType {
extension ObservableType {
/**
Projects each element of an observable sequence into a new form.
- seealso: [map operator on reactivex.io](http://reactivex.io/documentation/operators/map.html)
- parameter transform: A transform function to apply to each source element.
- returns: An observable sequence whose elements are the result of invoking the transform function on each element of source.
*/
public func map<R>(_ transform: @escaping (E) throws -> R)
-> Observable<R> {
return self.asObservable().composeMap(transform)
}
/**
Projects each element of an observable sequence into a new form by incorporating the element's index.
- seealso: [map operator on reactivex.io](http://reactivex.io/documentation/operators/map.html)
- parameter selector: A transform function to apply to each source element; the second parameter of the function represents the index of the source element.
- returns: An observable sequence whose elements are the result of invoking the transform function on each element of source.
*/
public func mapWithIndex<R>(_ selector: @escaping (E, Int) throws -> R)
-> Observable<R> {
return MapWithIndex(source: asObservable(), selector: selector)
}
}
final fileprivate class MapSink<SourceType, O : ObserverType> : Sink<O>, ObserverType {
typealias Transform = (SourceType) throws -> ResultType
typealias ResultType = O.E
@ -40,7 +70,7 @@ final class MapSink<SourceType, O : ObserverType> : Sink<O>, ObserverType {
}
}
final class MapWithIndexSink<SourceType, O : ObserverType> : Sink<O>, ObserverType {
final fileprivate class MapWithIndexSink<SourceType, O : ObserverType> : Sink<O>, ObserverType {
typealias Selector = (SourceType, Int) throws -> ResultType
typealias ResultType = O.E
@ -77,7 +107,7 @@ final class MapWithIndexSink<SourceType, O : ObserverType> : Sink<O>, ObserverTy
}
}
final class MapWithIndex<SourceType, ResultType> : Producer<ResultType> {
final fileprivate class MapWithIndex<SourceType, ResultType> : Producer<ResultType> {
typealias Selector = (SourceType, Int) throws -> ResultType
private let _source: Observable<SourceType>
@ -97,7 +127,7 @@ final class MapWithIndex<SourceType, ResultType> : Producer<ResultType> {
}
#if TRACE_RESOURCES
var _numberOfMapOperators: AtomicInt = 0
fileprivate var _numberOfMapOperators: AtomicInt = 0
extension Resources {
public static var numberOfMapOperators: Int32 {
return _numberOfMapOperators.valueSnapshot()
@ -105,7 +135,11 @@ final class MapWithIndex<SourceType, ResultType> : Producer<ResultType> {
}
#endif
final class Map<SourceType, ResultType>: Producer<ResultType> {
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> {
typealias Transform = (SourceType) throws -> ResultType
private let _source: Observable<SourceType>

13
RxSwift/Observables/Implementations/Materialize.swift
View File

@ -6,6 +6,17 @@
// Copyright © 2017 Krunoslav Zaher. All rights reserved.
//
extension ObservableType {
/**
Convert any Observable into an Observable of its events.
- seealso: [materialize operator on reactivex.io](http://reactivex.io/documentation/operators/materialize-dematerialize.html)
- returns: An observable sequence that wraps events in an Event<E>. The returned Observable never errors, but it does complete after observing all of the events of the underlying Observable.
*/
public func materialize() -> Observable<Event<E>> {
return Materialize(source: self.asObservable())
}
}
fileprivate final class MaterializeSink<Element, O: ObserverType>: Sink<O>, ObserverType where O.E == Event<Element> {
func on(_ event: Event<Element>) {
@ -17,7 +28,7 @@ fileprivate final class MaterializeSink<Element, O: ObserverType>: Sink<O>, Obse
}
}
final class Materialize<Element>: Producer<Event<Element>> {
final fileprivate class Materialize<Element>: Producer<Event<Element>> {
private let _source: Observable<Element>
init(source: Observable<Element>) {

137
RxSwift/Observables/Implementations/Merge.swift
View File

@ -6,7 +6,130 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
// MARK: Limited concurrency version
extension ObservableType {
/**
Projects each element of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence.
- seealso: [flatMap operator on reactivex.io](http://reactivex.io/documentation/operators/flatmap.html)
- parameter selector: A transform function to apply to each element.
- returns: An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence.
*/
public func flatMap<O: ObservableConvertibleType>(_ selector: @escaping (E) throws -> O)
-> Observable<O.E> {
return FlatMap(source: asObservable(), selector: selector)
}
/**
Projects each element of an observable sequence to an observable sequence by incorporating the element's index and merges the resulting observable sequences into one observable sequence.
- seealso: [flatMap operator on reactivex.io](http://reactivex.io/documentation/operators/flatmap.html)
- parameter selector: A transform function to apply to each element; the second parameter of the function represents the index of the source element.
- returns: An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence.
*/
public func flatMapWithIndex<O: ObservableConvertibleType>(_ selector: @escaping (E, Int) throws -> O)
-> Observable<O.E> {
return FlatMapWithIndex(source: asObservable(), selector: selector)
}
}
extension ObservableType {
/**
Projects each element of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence.
If element is received while there is some projected observable sequence being merged it will simply be ignored.
- seealso: [flatMapFirst operator on reactivex.io](http://reactivex.io/documentation/operators/flatmap.html)
- parameter selector: A transform function to apply to element that was observed while no observable is executing in parallel.
- returns: An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence that was received while no other sequence was being calculated.
*/
public func flatMapFirst<O: ObservableConvertibleType>(_ selector: @escaping (E) throws -> O)
-> Observable<O.E> {
return FlatMapFirst(source: asObservable(), selector: selector)
}
}
extension ObservableType where E : ObservableConvertibleType {
/**
Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence.
- seealso: [merge operator on reactivex.io](http://reactivex.io/documentation/operators/merge.html)
- returns: The observable sequence that merges the elements of the observable sequences.
*/
public func merge() -> Observable<E.E> {
return Merge(source: asObservable())
}
/**
Merges elements from all inner observable sequences into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences.
- seealso: [merge operator on reactivex.io](http://reactivex.io/documentation/operators/merge.html)
- parameter maxConcurrent: Maximum number of inner observable sequences being subscribed to concurrently.
- returns: The observable sequence that merges the elements of the inner sequences.
*/
public func merge(maxConcurrent: Int)
-> Observable<E.E> {
return MergeLimited(source: asObservable(), maxConcurrent: maxConcurrent)
}
}
extension ObservableType where E : ObservableConvertibleType {
/**
Concatenates all inner observable sequences, as long as the previous observable sequence terminated successfully.
- seealso: [concat operator on reactivex.io](http://reactivex.io/documentation/operators/concat.html)
- returns: An observable sequence that contains the elements of each observed inner sequence, in sequential order.
*/
public func concat() -> Observable<E.E> {
return merge(maxConcurrent: 1)
}
}
extension Observable {
/**
Merges elements from all observable sequences from collection into a single observable sequence.
- seealso: [merge operator on reactivex.io](http://reactivex.io/documentation/operators/merge.html)
- parameter sources: Collection of observable sequences to merge.
- returns: The observable sequence that merges the elements of the observable sequences.
*/
public static func merge<C: Collection>(_ sources: C) -> Observable<E> where C.Iterator.Element == Observable<E> {
return MergeArray(sources: Array(sources))
}
/**
Merges elements from all observable sequences from array into a single observable sequence.
- seealso: [merge operator on reactivex.io](http://reactivex.io/documentation/operators/merge.html)
- parameter sources: Array of observable sequences to merge.
- returns: The observable sequence that merges the elements of the observable sequences.
*/
public static func merge(_ sources: [Observable<E>]) -> Observable<E> {
return MergeArray(sources: sources)
}
/**
Merges elements from all observable sequences into a single observable sequence.
- seealso: [merge operator on reactivex.io](http://reactivex.io/documentation/operators/merge.html)
- parameter sources: Collection of observable sequences to merge.
- returns: The observable sequence that merges the elements of the observable sequences.
*/
public static func merge(_ sources: Observable<E>...) -> Observable<E> {
return MergeArray(sources: sources)
}
}
fileprivate final class MergeLimitedSinkIter<S: ObservableConvertibleType, O: ObserverType>
: ObserverType
@ -141,7 +264,7 @@ fileprivate final class MergeLimitedSink<S: ObservableConvertibleType, O: Observ
}
}
final class MergeLimited<S: ObservableConvertibleType> : Producer<S.E> {
final fileprivate class MergeLimited<S: ObservableConvertibleType> : Producer<S.E> {
private let _source: Observable<S>
private let _maxConcurrent: Int
@ -350,7 +473,7 @@ fileprivate class MergeSink<SourceType, S: ObservableConvertibleType, O: Observe
// MARK: Producers
final class FlatMap<SourceType, S: ObservableConvertibleType>: Producer<S.E> {
final fileprivate class FlatMap<SourceType, S: ObservableConvertibleType>: Producer<S.E> {
typealias Selector = (SourceType) throws -> S
private let _source: Observable<SourceType>
@ -369,7 +492,7 @@ final class FlatMap<SourceType, S: ObservableConvertibleType>: Producer<S.E> {
}
}
final class FlatMapWithIndex<SourceType, S: ObservableConvertibleType>: Producer<S.E> {
final fileprivate class FlatMapWithIndex<SourceType, S: ObservableConvertibleType>: Producer<S.E> {
typealias Selector = (SourceType, Int) throws -> S
private let _source: Observable<SourceType>
@ -389,7 +512,7 @@ final class FlatMapWithIndex<SourceType, S: ObservableConvertibleType>: Producer
}
final class FlatMapFirst<SourceType, S: ObservableConvertibleType>: Producer<S.E> {
final fileprivate class FlatMapFirst<SourceType, S: ObservableConvertibleType>: Producer<S.E> {
typealias Selector = (SourceType) throws -> S
private let _source: Observable<SourceType>
@ -408,7 +531,7 @@ final class FlatMapFirst<SourceType, S: ObservableConvertibleType>: Producer<S.E
}
}
final class Merge<S: ObservableConvertibleType> : Producer<S.E> {
final fileprivate class Merge<S: ObservableConvertibleType> : Producer<S.E> {
private let _source: Observable<S>
init(source: Observable<S>) {
@ -422,7 +545,7 @@ final class Merge<S: ObservableConvertibleType> : Producer<S.E> {
}
}
final class MergeArray<E> : Producer<E> {
final fileprivate class MergeArray<E> : Producer<E> {
private let _sources: [Observable<E>]
init(sources: [Observable<E>]) {

186
RxSwift/Observables/Implementations/Multicast.swift
View File

@ -6,7 +6,189 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class MulticastSink<S: SubjectType, O: ObserverType>: Sink<O>, ObserverType {
extension ObservableType {
/**
Multicasts the source sequence notifications through an instantiated subject into all uses of the sequence within a selector function.
Each subscription to the resulting sequence causes a separate multicast invocation, exposing the sequence resulting from the selector function's invocation.
For specializations with fixed subject types, see `publish` and `replay`.
- seealso: [multicast operator on reactivex.io](http://reactivex.io/documentation/operators/publish.html)
- parameter subjectSelector: Factory function to create an intermediate subject through which the source sequence's elements will be multicast to the selector function.
- parameter selector: Selector function which can use the multicasted source sequence subject to the policies enforced by the created subject.
- returns: An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.
*/
public func multicast<S: SubjectType, R>(_ subjectSelector: @escaping () throws -> S, selector: @escaping (Observable<S.E>) throws -> Observable<R>)
-> Observable<R> where S.SubjectObserverType.E == E {
return Multicast(
source: self.asObservable(),
subjectSelector: subjectSelector,
selector: selector
)
}
}
extension ObservableType {
/**
Returns a connectable observable sequence that shares a single subscription to the underlying sequence.
This operator is a specialization of `multicast` using a `PublishSubject`.
- seealso: [publish operator on reactivex.io](http://reactivex.io/documentation/operators/publish.html)
- returns: A connectable observable sequence that shares a single subscription to the underlying sequence.
*/
public func publish() -> ConnectableObservable<E> {
return self.multicast(PublishSubject())
}
}
extension ObservableType {
/**
Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying bufferSize elements.
This operator is a specialization of `multicast` using a `ReplaySubject`.
- seealso: [replay operator on reactivex.io](http://reactivex.io/documentation/operators/replay.html)
- parameter bufferSize: Maximum element count of the replay buffer.
- returns: A connectable observable sequence that shares a single subscription to the underlying sequence.
*/
public func replay(_ bufferSize: Int)
-> ConnectableObservable<E> {
return self.multicast(ReplaySubject.create(bufferSize: bufferSize))
}
/**
Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying all elements.
This operator is a specialization of `multicast` using a `ReplaySubject`.
- seealso: [replay operator on reactivex.io](http://reactivex.io/documentation/operators/replay.html)
- returns: A connectable observable sequence that shares a single subscription to the underlying sequence.
*/
public func replayAll()
-> ConnectableObservable<E> {
return self.multicast(ReplaySubject.createUnbounded())
}
}
extension ConnectableObservableType {
/**
Returns an observable sequence that stays connected to the source as long as there is at least one subscription to the observable sequence.
- seealso: [refCount operator on reactivex.io](http://reactivex.io/documentation/operators/refCount.html)
- returns: An observable sequence that stays connected to the source as long as there is at least one subscription to the observable sequence.
*/
public func refCount() -> Observable<E> {
return RefCount(source: self)
}
}
extension ObservableType {
/**
Returns an observable sequence that shares a single subscription to the underlying sequence.
This operator is a specialization of publish which creates a subscription when the number of observers goes from zero to one, then shares that subscription with all subsequent observers until the number of observers returns to zero, at which point the subscription is disposed.
- seealso: [share operator on reactivex.io](http://reactivex.io/documentation/operators/refcount.html)
- returns: An observable sequence that contains the elements of a sequence produced by multicasting the source sequence.
*/
public func share() -> Observable<E> {
return self.publish().refCount()
}
}
final fileprivate class RefCountSink<CO: ConnectableObservableType, O: ObserverType>
: Sink<O>
, ObserverType where CO.E == O.E {
typealias Element = O.E
typealias Parent = RefCount<CO>
private let _parent: Parent
init(parent: Parent, observer: O, cancel: Cancelable) {
_parent = parent
super.init(observer: observer, cancel: cancel)
}
func run() -> Disposable {
let subscription = _parent._source.subscribe(self)
_parent._lock.lock(); defer { _parent._lock.unlock() } // {
if _parent._count == 0 {
_parent._count = 1
_parent._connectableSubscription = _parent._source.connect()
}
else {
_parent._count = _parent._count + 1
}
// }
return Disposables.create {
subscription.dispose()
self._parent._lock.lock(); defer { self._parent._lock.unlock() } // {
if self._parent._count == 1 {
self._parent._count = 0
guard let connectableSubscription = self._parent._connectableSubscription else {
return
}
connectableSubscription.dispose()
self._parent._connectableSubscription = nil
}
else if self._parent._count > 1 {
self._parent._count = self._parent._count - 1
}
else {
rxFatalError("Something went wrong with RefCount disposing mechanism")
}
// }
}
}
func on(_ event: Event<Element>) {
switch event {
case .next:
forwardOn(event)
case .error, .completed:
forwardOn(event)
dispose()
}
}
}
final fileprivate class RefCount<CO: ConnectableObservableType>: Producer<CO.E> {
fileprivate let _lock = RecursiveLock()
// state
fileprivate var _count = 0
fileprivate var _connectableSubscription = nil as Disposable?
fileprivate let _source: CO
init(source: CO) {
_source = source
}
override func run<O: ObserverType>(_ observer: O, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where O.E == CO.E {
let sink = RefCountSink(parent: self, observer: observer, cancel: cancel)
let subscription = sink.run()
return (sink: sink, subscription: subscription)
}
}
final fileprivate class MulticastSink<S: SubjectType, O: ObserverType>: Sink<O>, ObserverType {
typealias Element = O.E
typealias ResultType = Element
typealias MutlicastType = Multicast<S, O.E>
@ -47,7 +229,7 @@ final class MulticastSink<S: SubjectType, O: ObserverType>: Sink<O>, ObserverTyp
}
}
final class Multicast<S: SubjectType, R>: Producer<R> {
final fileprivate class Multicast<S: SubjectType, R>: Producer<R> {
typealias SubjectSelectorType = () throws -> S
typealias SelectorType = (Observable<S.E>) throws -> Observable<R>

16
RxSwift/Observables/Implementations/Never.swift
View File

@ -6,7 +6,21 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class NeverProducer<Element> : Producer<Element> {
extension Observable {
/**
Returns a non-terminating observable sequence, which can be used to denote an infinite duration.
- seealso: [never operator on reactivex.io](http://reactivex.io/documentation/operators/empty-never-throw.html)
- returns: An observable sequence whose observers will never get called.
*/
public static func never() -> Observable<E> {
return NeverProducer()
}
}
final fileprivate class NeverProducer<Element> : Producer<Element> {
override func subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == Element {
return Disposables.create()
}

106
RxSwift/Observables/Implementations/ObserveOn.swift
View File

@ -6,7 +6,31 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class ObserveOn<E> : Producer<E> {
extension ObservableType {
/**
Wraps the source sequence in order to run its observer callbacks on the specified scheduler.
This only invokes observer callbacks on a `scheduler`. In case the subscription and/or unsubscription
actions have side-effects that require to be run on a scheduler, use `subscribeOn`.
- seealso: [observeOn operator on reactivex.io](http://reactivex.io/documentation/operators/observeon.html)
- parameter scheduler: Scheduler to notify observers on.
- returns: The source sequence whose observations happen on the specified scheduler.
*/
public func observeOn(_ scheduler: ImmediateSchedulerType)
-> Observable<E> {
if let scheduler = scheduler as? SerialDispatchQueueScheduler {
return ObserveOnSerialDispatchQueue(source: self.asObservable(), scheduler: scheduler)
}
else {
return ObserveOn(source: self.asObservable(), scheduler: scheduler)
}
}
}
final fileprivate class ObserveOn<E> : Producer<E> {
let scheduler: ImmediateSchedulerType
let source: Observable<E>
@ -39,7 +63,7 @@ enum ObserveOnState : Int32 {
case running = 1
}
final class ObserveOnSink<O: ObserverType> : ObserverBase<O.E> {
final fileprivate class ObserveOnSink<O: ObserverType> : ObserverBase<O.E> {
typealias E = O.E
let _scheduler: ImmediateSchedulerType
@ -125,3 +149,81 @@ final class ObserveOnSink<O: ObserverType> : ObserverBase<O.E> {
_scheduleDisposable.dispose()
}
}
#if TRACE_RESOURCES
fileprivate var _numberOfSerialDispatchQueueObservables: AtomicInt = 0
extension Resources {
/**
Counts number of `SerialDispatchQueueObservables`.
Purposed for unit tests.
*/
public static var numberOfSerialDispatchQueueObservables: Int32 {
return _numberOfSerialDispatchQueueObservables.valueSnapshot()
}
}
#endif
final fileprivate class ObserveOnSerialDispatchQueueSink<O: ObserverType> : ObserverBase<O.E> {
let scheduler: SerialDispatchQueueScheduler
let observer: O
let cancel: Cancelable
var cachedScheduleLambda: ((ObserveOnSerialDispatchQueueSink<O>, Event<E>) -> Disposable)!
init(scheduler: SerialDispatchQueueScheduler, observer: O, cancel: Cancelable) {
self.scheduler = scheduler
self.observer = observer
self.cancel = cancel
super.init()
cachedScheduleLambda = { sink, event in
sink.observer.on(event)
if event.isStopEvent {
sink.dispose()
}
return Disposables.create()
}
}
override func onCore(_ event: Event<E>) {
let _ = self.scheduler.schedule((self, event), action: cachedScheduleLambda)
}
override func dispose() {
super.dispose()
cancel.dispose()
}
}
final fileprivate class ObserveOnSerialDispatchQueue<E> : Producer<E> {
let scheduler: SerialDispatchQueueScheduler
let source: Observable<E>
init(source: Observable<E>, scheduler: SerialDispatchQueueScheduler) {
self.scheduler = scheduler
self.source = source
#if TRACE_RESOURCES
let _ = Resources.incrementTotal()
let _ = AtomicIncrement(&_numberOfSerialDispatchQueueObservables)
#endif
}
override func run<O : ObserverType>(_ observer: O, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where O.E == E {
let sink = ObserveOnSerialDispatchQueueSink(scheduler: scheduler, observer: observer, cancel: cancel)
let subscription = source.subscribe(sink)
return (sink: sink, subscription: subscription)
}
#if TRACE_RESOURCES
deinit {
let _ = Resources.decrementTotal()
let _ = AtomicDecrement(&_numberOfSerialDispatchQueueObservables)
}
#endif
}

85
RxSwift/Observables/Implementations/ObserveOnSerialDispatchQueue.swift
View File

@ -1,85 +0,0 @@
//
// ObserveOnSerialDispatchQueue.swift
// RxSwift
//
// Created by Krunoslav Zaher on 5/31/15.
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
#if TRACE_RESOURCES
fileprivate var _numberOfSerialDispatchQueueObservables: AtomicInt = 0
extension Resources {
/**
Counts number of `SerialDispatchQueueObservables`.
Purposed for unit tests.
*/
public static var numberOfSerialDispatchQueueObservables: Int32 {
return _numberOfSerialDispatchQueueObservables.valueSnapshot()
}
}
#endif
final class ObserveOnSerialDispatchQueueSink<O: ObserverType> : ObserverBase<O.E> {
let scheduler: SerialDispatchQueueScheduler
let observer: O
let cancel: Cancelable
var cachedScheduleLambda: ((ObserveOnSerialDispatchQueueSink<O>, Event<E>) -> Disposable)!
init(scheduler: SerialDispatchQueueScheduler, observer: O, cancel: Cancelable) {
self.scheduler = scheduler
self.observer = observer
self.cancel = cancel
super.init()
cachedScheduleLambda = { sink, event in
sink.observer.on(event)
if event.isStopEvent {
sink.dispose()
}
return Disposables.create()
}
}
override func onCore(_ event: Event<E>) {
let _ = self.scheduler.schedule((self, event), action: cachedScheduleLambda)
}
override func dispose() {
super.dispose()
cancel.dispose()
}
}
final class ObserveOnSerialDispatchQueue<E> : Producer<E> {
let scheduler: SerialDispatchQueueScheduler
let source: Observable<E>
init(source: Observable<E>, scheduler: SerialDispatchQueueScheduler) {
self.scheduler = scheduler
self.source = source
#if TRACE_RESOURCES
let _ = Resources.incrementTotal()
let _ = AtomicIncrement(&_numberOfSerialDispatchQueueObservables)
#endif
}
override func run<O : ObserverType>(_ observer: O, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where O.E == E {
let sink = ObserveOnSerialDispatchQueueSink(scheduler: scheduler, observer: observer, cancel: cancel)
let subscription = source.subscribe(sink)
return (sink: sink, subscription: subscription)
}
#if TRACE_RESOURCES
deinit {
let _ = Resources.decrementTotal()
let _ = AtomicDecrement(&_numberOfSerialDispatchQueueObservables)
}
#endif
}

33
RxSwift/Observables/Implementations/Optional.swift
View File

@ -6,7 +6,34 @@
// Copyright © 2016 Krunoslav Zaher. All rights reserved.
//
final class ObservableOptionalScheduledSink<O: ObserverType> : Sink<O> {
extension Observable {
/**
Converts a optional to an observable sequence.
- seealso: [from operator on reactivex.io](http://reactivex.io/documentation/operators/from.html)
- parameter optional: Optional element in the resulting observable sequence.
- returns: An observable sequence containing the wrapped value or not from given optional.
*/
public static func from(optional: E?) -> Observable<E> {
return ObservableOptional(optional: optional)
}
/**
Converts a optional to an observable sequence.
- seealso: [from operator on reactivex.io](http://reactivex.io/documentation/operators/from.html)
- parameter optional: Optional element in the resulting observable sequence.
- parameter: Scheduler to send the optional element on.
- returns: An observable sequence containing the wrapped value or not from given optional.
*/
public static func from(optional: E?, scheduler: ImmediateSchedulerType) -> Observable<E> {
return ObservableOptionalScheduled(optional: optional, scheduler: scheduler)
}
}
final fileprivate class ObservableOptionalScheduledSink<O: ObserverType> : Sink<O> {
typealias E = O.E
typealias Parent = ObservableOptionalScheduled<E>
@ -35,7 +62,7 @@ final class ObservableOptionalScheduledSink<O: ObserverType> : Sink<O> {
}
}
final class ObservableOptionalScheduled<E> : Producer<E> {
final fileprivate class ObservableOptionalScheduled<E> : Producer<E> {
fileprivate let _optional: E?
fileprivate let _scheduler: ImmediateSchedulerType
@ -51,7 +78,7 @@ final class ObservableOptionalScheduled<E> : Producer<E> {
}
}
final class ObservableOptional<E>: Producer<E> {
final fileprivate class ObservableOptional<E>: Producer<E> {
private let _optional: E?
init(optional: E?) {

20
RxSwift/Observables/Implementations/Range.swift
View File

@ -6,7 +6,23 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class RangeProducer<E: SignedInteger> : Producer<E> {
extension Observable where Element : SignedInteger {
/**
Generates an observable sequence of integral numbers within a specified range, using the specified scheduler to generate and send out observer messages.
- seealso: [range operator on reactivex.io](http://reactivex.io/documentation/operators/range.html)
- parameter start: The value of the first integer in the sequence.
- parameter count: The number of sequential integers to generate.
- parameter scheduler: Scheduler to run the generator loop on.
- returns: An observable sequence that contains a range of sequential integral numbers.
*/
public static func range(start: E, count: E, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance) -> Observable<E> {
return RangeProducer<E>(start: start, count: count, scheduler: scheduler)
}
}
final fileprivate class RangeProducer<E: SignedInteger> : Producer<E> {
fileprivate let _start: E
fileprivate let _count: E
fileprivate let _scheduler: ImmediateSchedulerType
@ -32,7 +48,7 @@ final class RangeProducer<E: SignedInteger> : Producer<E> {
}
}
final class RangeSink<O: ObserverType> : Sink<O> where O.E: SignedInteger {
final fileprivate class RangeSink<O: ObserverType> : Sink<O> where O.E: SignedInteger {
typealias Parent = RangeProducer<O.E>
private let _parent: Parent

41
RxSwift/Observables/Implementations/Reduce.swift
View File

@ -6,7 +6,43 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class ReduceSink<SourceType, AccumulateType, O: ObserverType> : Sink<O>, ObserverType {
extension ObservableType {
/**
Applies an `accumulator` function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. The specified `seed` value is used as the initial accumulator value.
For aggregation behavior with incremental intermediate results, see `scan`.
- seealso: [reduce operator on reactivex.io](http://reactivex.io/documentation/operators/reduce.html)
- parameter seed: The initial accumulator value.
- parameter accumulator: A accumulator function to be invoked on each element.
- parameter mapResult: A function to transform the final accumulator value into the result value.
- returns: An observable sequence containing a single element with the final accumulator value.
*/
public func reduce<A, R>(_ seed: A, accumulator: @escaping (A, E) throws -> A, mapResult: @escaping (A) throws -> R)
-> Observable<R> {
return Reduce(source: self.asObservable(), seed: seed, accumulator: accumulator, mapResult: mapResult)
}
/**
Applies an `accumulator` function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. The specified `seed` value is used as the initial accumulator value.
For aggregation behavior with incremental intermediate results, see `scan`.
- seealso: [reduce operator on reactivex.io](http://reactivex.io/documentation/operators/reduce.html)
- parameter seed: The initial accumulator value.
- parameter accumulator: A accumulator function to be invoked on each element.
- returns: An observable sequence containing a single element with the final accumulator value.
*/
public func reduce<A>(_ seed: A, accumulator: @escaping (A, E) throws -> A)
-> Observable<A> {
return Reduce(source: self.asObservable(), seed: seed, accumulator: accumulator, mapResult: { $0 })
}
}
final fileprivate class ReduceSink<SourceType, AccumulateType, O: ObserverType> : Sink<O>, ObserverType {
typealias ResultType = O.E
typealias Parent = Reduce<SourceType, AccumulateType, ResultType>
@ -48,7 +84,7 @@ final class ReduceSink<SourceType, AccumulateType, O: ObserverType> : Sink<O>, O
}
}
final class Reduce<SourceType, AccumulateType, ResultType> : Producer<ResultType> {
final fileprivate class Reduce<SourceType, AccumulateType, ResultType> : Producer<ResultType> {
typealias AccumulatorType = (AccumulateType, SourceType) throws -> AccumulateType
typealias ResultSelectorType = (AccumulateType) throws -> ResultType
@ -70,3 +106,4 @@ final class Reduce<SourceType, AccumulateType, ResultType> : Producer<ResultType
return (sink: sink, subscription: subscription)
}
}

86
RxSwift/Observables/Implementations/RefCount.swift
View File

@ -1,86 +0,0 @@
//
// RefCount.swift
// RxSwift
//
// Created by Krunoslav Zaher on 3/5/15.
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class RefCountSink<CO: ConnectableObservableType, O: ObserverType>
: Sink<O>
, ObserverType where CO.E == O.E {
typealias Element = O.E
typealias Parent = RefCount<CO>
private let _parent: Parent
init(parent: Parent, observer: O, cancel: Cancelable) {
_parent = parent
super.init(observer: observer, cancel: cancel)
}
func run() -> Disposable {
let subscription = _parent._source.subscribe(self)
_parent._lock.lock(); defer { _parent._lock.unlock() } // {
if _parent._count == 0 {
_parent._count = 1
_parent._connectableSubscription = _parent._source.connect()
}
else {
_parent._count = _parent._count + 1
}
// }
return Disposables.create {
subscription.dispose()
self._parent._lock.lock(); defer { self._parent._lock.unlock() } // {
if self._parent._count == 1 {
self._parent._count = 0
guard let connectableSubscription = self._parent._connectableSubscription else {
return
}
connectableSubscription.dispose()
self._parent._connectableSubscription = nil
}
else if self._parent._count > 1 {
self._parent._count = self._parent._count - 1
}
else {
rxFatalError("Something went wrong with RefCount disposing mechanism")
}
// }
}
}
func on(_ event: Event<Element>) {
switch event {
case .next:
forwardOn(event)
case .error, .completed:
forwardOn(event)
dispose()
}
}
}
final class RefCount<CO: ConnectableObservableType>: Producer<CO.E> {
fileprivate let _lock = RecursiveLock()
// state
fileprivate var _count = 0
fileprivate var _connectableSubscription = nil as Disposable?
fileprivate let _source: CO
init(source: CO) {
_source = source
}
override func run<O: ObserverType>(_ observer: O, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where O.E == CO.E {
let sink = RefCountSink(parent: self, observer: observer, cancel: cancel)
let subscription = sink.run()
return (sink: sink, subscription: subscription)
}
}

19
RxSwift/Observables/Implementations/Repeat.swift
View File

@ -6,7 +6,22 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class RepeatElement<Element> : Producer<Element> {
extension Observable {
/**
Generates an observable sequence that repeats the given element infinitely, using the specified scheduler to send out observer messages.
- seealso: [repeat operator on reactivex.io](http://reactivex.io/documentation/operators/repeat.html)
- parameter element: Element to repeat.
- parameter scheduler: Scheduler to run the producer loop on.
- returns: An observable sequence that repeats the given element infinitely.
*/
public static func repeatElement(_ element: E, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance) -> Observable<E> {
return RepeatElement(element: element, scheduler: scheduler)
}
}
final fileprivate class RepeatElement<Element> : Producer<Element> {
fileprivate let _element: Element
fileprivate let _scheduler: ImmediateSchedulerType
@ -23,7 +38,7 @@ final class RepeatElement<Element> : Producer<Element> {
}
}
final class RepeatElementSink<O: ObserverType> : Sink<O> {
final fileprivate class RepeatElementSink<O: ObserverType> : Sink<O> {
typealias Parent = RepeatElement<O.E>
private let _parent: Parent

39
RxSwift/Observables/Implementations/RetryWhen.swift
View File

@ -6,7 +6,38 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class RetryTriggerSink<S: Sequence, O: ObserverType, TriggerObservable: ObservableType, Error>
extension ObservableType {
/**
Repeats the source observable sequence on error when the notifier emits a next value.
If the source observable errors and the notifier completes, it will complete the source sequence.
- seealso: [retry operator on reactivex.io](http://reactivex.io/documentation/operators/retry.html)
- parameter notificationHandler: A handler that is passed an observable sequence of errors raised by the source observable and returns and observable that either continues, completes or errors. This behavior is then applied to the source observable.
- returns: An observable sequence producing the elements of the given sequence repeatedly until it terminates successfully or is notified to error or complete.
*/
public func retryWhen<TriggerObservable: ObservableType, Error: Swift.Error>(_ notificationHandler: @escaping (Observable<Error>) -> TriggerObservable)
-> Observable<E> {
return RetryWhenSequence(sources: InfiniteSequence(repeatedValue: self.asObservable()), notificationHandler: notificationHandler)
}
/**
Repeats the source observable sequence on error when the notifier emits a next value.
If the source observable errors and the notifier completes, it will complete the source sequence.
- seealso: [retry operator on reactivex.io](http://reactivex.io/documentation/operators/retry.html)
- parameter notificationHandler: A handler that is passed an observable sequence of errors raised by the source observable and returns and observable that either continues, completes or errors. This behavior is then applied to the source observable.
- returns: An observable sequence producing the elements of the given sequence repeatedly until it terminates successfully or is notified to error or complete.
*/
public func retryWhen<TriggerObservable: ObservableType>(_ notificationHandler: @escaping (Observable<Swift.Error>) -> TriggerObservable)
-> Observable<E> {
return RetryWhenSequence(sources: InfiniteSequence(repeatedValue: self.asObservable()), notificationHandler: notificationHandler)
}
}
final fileprivate class RetryTriggerSink<S: Sequence, O: ObserverType, TriggerObservable: ObservableType, Error>
: ObserverType where S.Iterator.Element : ObservableType, S.Iterator.Element.E == O.E {
typealias E = TriggerObservable.E
@ -33,7 +64,7 @@ final class RetryTriggerSink<S: Sequence, O: ObserverType, TriggerObservable: Ob
}
}
final class RetryWhenSequenceSinkIter<S: Sequence, O: ObserverType, TriggerObservable: ObservableType, Error>
final fileprivate class RetryWhenSequenceSinkIter<S: Sequence, O: ObserverType, TriggerObservable: ObservableType, Error>
: ObserverType
, Disposable where S.Iterator.Element : ObservableType, S.Iterator.Element.E == O.E {
typealias E = O.E
@ -79,7 +110,7 @@ final class RetryWhenSequenceSinkIter<S: Sequence, O: ObserverType, TriggerObser
}
}
final class RetryWhenSequenceSink<S: Sequence, O: ObserverType, TriggerObservable: ObservableType, Error>
final fileprivate class RetryWhenSequenceSink<S: Sequence, O: ObserverType, TriggerObservable: ObservableType, Error>
: TailRecursiveSink<S, O> where S.Iterator.Element : ObservableType, S.Iterator.Element.E == O.E {
typealias Element = O.E
typealias Parent = RetryWhenSequence<S, TriggerObservable, Error>
@ -132,7 +163,7 @@ final class RetryWhenSequenceSink<S: Sequence, O: ObserverType, TriggerObservabl
}
}
final class RetryWhenSequence<S: Sequence, TriggerObservable: ObservableType, Error> : Producer<S.Iterator.Element.E> where S.Iterator.Element : ObservableType {
final fileprivate class RetryWhenSequence<S: Sequence, TriggerObservable: ObservableType, Error> : Producer<S.Iterator.Element.E> where S.Iterator.Element : ObservableType {
typealias Element = S.Iterator.Element.E
fileprivate let _sources: S

26
RxSwift/Observables/Implementations/Sample.swift
View File

@ -6,7 +6,27 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class SamplerSink<O: ObserverType, SampleType>
extension ObservableType {
/**
Samples the source observable sequence using a sampler observable sequence producing sampling ticks.
Upon each sampling tick, the latest element (if any) in the source sequence during the last sampling interval is sent to the resulting sequence.
**In case there were no new elements between sampler ticks, no element is sent to the resulting sequence.**
- seealso: [sample operator on reactivex.io](http://reactivex.io/documentation/operators/sample.html)
- parameter sampler: Sampling tick sequence.
- returns: Sampled observable sequence.
*/
public func sample<O: ObservableType>(_ sampler: O)
-> Observable<E> {
return Sample(source: self.asObservable(), sampler: sampler.asObservable())
}
}
final fileprivate class SamplerSink<O: ObserverType, SampleType>
: ObserverType
, LockOwnerType
, SynchronizedOnType {
@ -56,7 +76,7 @@ final class SamplerSink<O: ObserverType, SampleType>
}
}
final class SampleSequenceSink<O: ObserverType, SampleType>
final fileprivate class SampleSequenceSink<O: ObserverType, SampleType>
: Sink<O>
, ObserverType
, LockOwnerType
@ -105,7 +125,7 @@ final class SampleSequenceSink<O: ObserverType, SampleType>
}
final class Sample<Element, SampleType> : Producer<Element> {
final fileprivate class Sample<Element, SampleType> : Producer<Element> {
fileprivate let _source: Observable<Element>
fileprivate let _sampler: Observable<SampleType>

23
RxSwift/Observables/Implementations/Scan.swift
View File

@ -6,7 +6,26 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class ScanSink<ElementType, O: ObserverType> : Sink<O>, ObserverType {
extension ObservableType {
/**
Applies an accumulator function over an observable sequence and returns each intermediate result. The specified seed value is used as the initial accumulator value.
For aggregation behavior with no intermediate results, see `reduce`.
- seealso: [scan operator on reactivex.io](http://reactivex.io/documentation/operators/scan.html)
- parameter seed: The initial accumulator value.
- parameter accumulator: An accumulator function to be invoked on each element.
- returns: An observable sequence containing the accumulated values.
*/
public func scan<A>(_ seed: A, accumulator: @escaping (A, E) throws -> A)
-> Observable<A> {
return Scan(source: self.asObservable(), seed: seed, accumulator: accumulator)
}
}
final fileprivate class ScanSink<ElementType, O: ObserverType> : Sink<O>, ObserverType {
typealias Accumulate = O.E
typealias Parent = Scan<ElementType, Accumulate>
typealias E = ElementType
@ -42,7 +61,7 @@ final class ScanSink<ElementType, O: ObserverType> : Sink<O>, ObserverType {
}
final class Scan<Element, Accumulate>: Producer<Accumulate> {
final fileprivate class Scan<Element, Accumulate>: Producer<Accumulate> {
typealias Accumulator = (Accumulate, Element) throws -> Accumulate
fileprivate let _source: Observable<Element>

45
RxSwift/Observables/Implementations/Sequence.swift
View File

@ -6,7 +6,48 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class ObservableSequenceSink<S: Sequence, O: ObserverType> : Sink<O> where S.Iterator.Element == O.E {
extension Observable {
// MARK: of
/**
This method creates a new Observable instance with a variable number of elements.
- seealso: [from operator on reactivex.io](http://reactivex.io/documentation/operators/from.html)
- parameter elements: Elements to generate.
- parameter scheduler: Scheduler to send elements on. If `nil`, elements are sent immediatelly on subscription.
- returns: The observable sequence whose elements are pulled from the given arguments.
*/
public static func of(_ elements: E ..., scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance) -> Observable<E> {
return ObservableSequence(elements: elements, scheduler: scheduler)
}
}
extension Observable {
/**
Converts an array to an observable sequence.
- seealso: [from operator on reactivex.io](http://reactivex.io/documentation/operators/from.html)
- returns: The observable sequence whose elements are pulled from the given enumerable sequence.
*/
public static func from(_ array: [E], scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance) -> Observable<E> {
return ObservableSequence(elements: array, scheduler: scheduler)
}
/**
Converts a sequence to an observable sequence.
- seealso: [from operator on reactivex.io](http://reactivex.io/documentation/operators/from.html)
- returns: The observable sequence whose elements are pulled from the given enumerable sequence.
*/
public static func from<S: Sequence>(_ sequence: S, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance) -> Observable<E> where S.Iterator.Element == E {
return ObservableSequence(elements: sequence, scheduler: scheduler)
}
}
final fileprivate class ObservableSequenceSink<S: Sequence, O: ObserverType> : Sink<O> where S.Iterator.Element == O.E {
typealias Parent = ObservableSequence<S>
private let _parent: Parent
@ -31,7 +72,7 @@ final class ObservableSequenceSink<S: Sequence, O: ObserverType> : Sink<O> where
}
}
final class ObservableSequence<S: Sequence> : Producer<S.Iterator.Element> {
final fileprivate class ObservableSequence<S: Sequence> : Producer<S.Iterator.Element> {
fileprivate let _elements: S
fileprivate let _scheduler: ImmediateSchedulerType

25
RxSwift/Observables/Implementations/ShareReplay1.swift
View File

@ -6,8 +6,31 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
extension ObservableType {
/**
Returns an observable sequence that shares a single subscription to the underlying sequence, and immediately upon subscription replays maximum number of elements in buffer.
This operator is a specialization of replay which creates a subscription when the number of observers goes from zero to one, then shares that subscription with all subsequent observers until the number of observers returns to zero, at which point the subscription is disposed.
- seealso: [shareReplay operator on reactivex.io](http://reactivex.io/documentation/operators/replay.html)
- parameter bufferSize: Maximum element count of the replay buffer.
- returns: An observable sequence that contains the elements of a sequence produced by multicasting the source sequence.
*/
public func shareReplay(_ bufferSize: Int)
-> Observable<E> {
if bufferSize == 1 {
return ShareReplay1(source: self.asObservable())
}
else {
return self.replay(bufferSize).refCount()
}
}
}
// optimized version of share replay for most common case
final class ShareReplay1<Element>
final fileprivate class ShareReplay1<Element>
: Observable<Element>
, ObserverType
, SynchronizedUnsubscribeType {

22
RxSwift/Observables/Implementations/ShareReplay1WhileConnected.swift
View File

@ -6,6 +6,26 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
extension ObservableType {
/**
Returns an observable sequence that shares a single subscription to the underlying sequence, and immediately upon subscription replays latest element in buffer.
This operator is a specialization of replay which creates a subscription when the number of observers goes from zero to one, then shares that subscription with all subsequent observers until the number of observers returns to zero, at which point the subscription is disposed.
Unlike `shareReplay(bufferSize: Int)`, this operator will clear latest element from replay buffer in case number of subscribers drops from one to zero. In case sequence
completes or errors out replay buffer is also cleared.
- seealso: [shareReplay operator on reactivex.io](http://reactivex.io/documentation/operators/replay.html)
- returns: An observable sequence that contains the elements of a sequence produced by multicasting the source sequence.
*/
public func shareReplayLatestWhileConnected()
-> Observable<E> {
return ShareReplay1WhileConnected(source: self.asObservable())
}
}
fileprivate final class ShareReplay1WhileConnectedConnection<Element>
: ObserverType
, SynchronizedUnsubscribeType {
@ -104,7 +124,7 @@ fileprivate final class ShareReplay1WhileConnectedConnection<Element>
}
// optimized version of share replay for most common case
final class ShareReplay1WhileConnected<Element>
final fileprivate class ShareReplay1WhileConnected<Element>
: Observable<Element> {
fileprivate typealias Connection = ShareReplay1WhileConnectedConnection<Element>

30
RxSwift/Observables/Implementations/SingleAsync.swift
View File

@ -6,6 +6,36 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
extension ObservableType {
/**
The single operator is similar to first, but throws a `RxError.noElements` or `RxError.moreThanOneElement`
if the source Observable does not emit exactly one element before successfully completing.
- seealso: [single operator on reactivex.io](http://reactivex.io/documentation/operators/first.html)
- returns: An observable sequence that emits a single element or throws an exception if more (or none) of them are emitted.
*/
public func single()
-> Observable<E> {
return SingleAsync(source: asObservable())
}
/**
The single operator is similar to first, but throws a `RxError.NoElements` or `RxError.MoreThanOneElement`
if the source Observable does not emit exactly one element before successfully completing.
- seealso: [single operator on reactivex.io](http://reactivex.io/documentation/operators/first.html)
- parameter predicate: A function to test each source element for a condition.
- returns: An observable sequence that emits a single element or throws an exception if more (or none) of them are emitted.
*/
public func single(_ predicate: @escaping (E) throws -> Bool)
-> Observable<E> {
return SingleAsync(source: asObservable(), predicate: predicate)
}
}
fileprivate final class SingleAsyncSink<O: ObserverType> : Sink<O>, ObserverType {
typealias ElementType = O.E
typealias Parent = SingleAsync<ElementType>

41
RxSwift/Observables/Implementations/Skip.swift
View File

@ -6,9 +6,42 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
extension ObservableType {
/**
Bypasses a specified number of elements in an observable sequence and then returns the remaining elements.
- seealso: [skip operator on reactivex.io](http://reactivex.io/documentation/operators/skip.html)
- parameter count: The number of elements to skip before returning the remaining elements.
- returns: An observable sequence that contains the elements that occur after the specified index in the input sequence.
*/
public func skip(_ count: Int)
-> Observable<E> {
return SkipCount(source: asObservable(), count: count)
}
}
extension ObservableType {
/**
Skips elements for the specified duration from the start of the observable source sequence, using the specified scheduler to run timers.
- seealso: [skip operator on reactivex.io](http://reactivex.io/documentation/operators/skip.html)
- parameter duration: Duration for skipping elements from the start of the sequence.
- parameter scheduler: Scheduler to run the timer on.
- returns: An observable sequence with the elements skipped during the specified duration from the start of the source sequence.
*/
public func skip(_ duration: RxTimeInterval, scheduler: SchedulerType)
-> Observable<E> {
return SkipTime(source: self.asObservable(), duration: duration, scheduler: scheduler)
}
}
// count version
final class SkipCountSink<O: ObserverType> : Sink<O>, ObserverType {
final fileprivate class SkipCountSink<O: ObserverType> : Sink<O>, ObserverType {
typealias Element = O.E
typealias Parent = SkipCount<Element>
@ -43,7 +76,7 @@ final class SkipCountSink<O: ObserverType> : Sink<O>, ObserverType {
}
final class SkipCount<Element>: Producer<Element> {
final fileprivate class SkipCount<Element>: Producer<Element> {
let source: Observable<Element>
let count: Int
@ -62,7 +95,7 @@ final class SkipCount<Element>: Producer<Element> {
// time version
final class SkipTimeSink<ElementType, O: ObserverType> : Sink<O>, ObserverType where O.E == ElementType {
final fileprivate class SkipTimeSink<ElementType, O: ObserverType> : Sink<O>, ObserverType where O.E == ElementType {
typealias Parent = SkipTime<ElementType>
typealias Element = ElementType
@ -107,7 +140,7 @@ final class SkipTimeSink<ElementType, O: ObserverType> : Sink<O>, ObserverType w
}
}
final class SkipTime<Element>: Producer<Element> {
final fileprivate class SkipTime<Element>: Producer<Element> {
let source: Observable<Element>
let duration: RxTimeInterval
let scheduler: SchedulerType

22
RxSwift/Observables/Implementations/SkipUntil.swift
View File

@ -6,7 +6,23 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class SkipUntilSinkOther<Other, O: ObserverType>
extension ObservableType {
/**
Returns the elements from the source observable sequence that are emitted after the other observable sequence produces an element.
- seealso: [skipUntil operator on reactivex.io](http://reactivex.io/documentation/operators/skipuntil.html)
- parameter other: Observable sequence that starts propagation of elements of the source sequence.
- returns: An observable sequence containing the elements of the source sequence that are emitted after the other sequence emits an item.
*/
public func skipUntil<O: ObservableType>(_ other: O)
-> Observable<E> {
return SkipUntil(source: asObservable(), other: other.asObservable())
}
}
final fileprivate class SkipUntilSinkOther<Other, O: ObserverType>
: ObserverType
, LockOwnerType
, SynchronizedOnType {
@ -54,7 +70,7 @@ final class SkipUntilSinkOther<Other, O: ObserverType>
}
final class SkipUntilSink<Other, O: ObserverType>
final fileprivate class SkipUntilSink<Other, O: ObserverType>
: Sink<O>
, ObserverType
, LockOwnerType
@ -105,7 +121,7 @@ final class SkipUntilSink<Other, O: ObserverType>
}
}
final class SkipUntil<Element, Other>: Producer<Element> {
final fileprivate class SkipUntil<Element, Other>: Producer<Element> {
fileprivate let _source: Observable<Element>
fileprivate let _other: Observable<Other>

34
RxSwift/Observables/Implementations/SkipWhile.swift
View File

@ -6,7 +6,35 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class SkipWhileSink<O: ObserverType> : Sink<O>, ObserverType {
extension ObservableType {
/**
Bypasses elements in an observable sequence as long as a specified condition is true and then returns the remaining elements.
- seealso: [skipWhile operator on reactivex.io](http://reactivex.io/documentation/operators/skipwhile.html)
- parameter predicate: A function to test each element for a condition.
- returns: An observable sequence that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate.
*/
public func skipWhile(_ predicate: @escaping (E) throws -> Bool) -> Observable<E> {
return SkipWhile(source: asObservable(), predicate: predicate)
}
/**
Bypasses elements in an observable sequence as long as a specified condition is true and then returns the remaining elements.
The element's index is used in the logic of the predicate function.
- seealso: [skipWhile operator on reactivex.io](http://reactivex.io/documentation/operators/skipwhile.html)
- parameter predicate: A function to test each element for a condition; the second parameter of the function represents the index of the source element.
- returns: An observable sequence that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate.
*/
public func skipWhileWithIndex(_ predicate: @escaping (E, Int) throws -> Bool) -> Observable<E> {
return SkipWhile(source: asObservable(), predicate: predicate)
}
}
final fileprivate class SkipWhileSink<O: ObserverType> : Sink<O>, ObserverType {
typealias Element = O.E
typealias Parent = SkipWhile<Element>
@ -42,7 +70,7 @@ final class SkipWhileSink<O: ObserverType> : Sink<O>, ObserverType {
}
}
final class SkipWhileSinkWithIndex<O: ObserverType> : Sink<O>, ObserverType {
final fileprivate class SkipWhileSinkWithIndex<O: ObserverType> : Sink<O>, ObserverType {
typealias Element = O.E
typealias Parent = SkipWhile<Element>
@ -80,7 +108,7 @@ final class SkipWhileSinkWithIndex<O: ObserverType> : Sink<O>, ObserverType {
}
}
final class SkipWhile<Element>: Producer<Element> {
final fileprivate class SkipWhile<Element>: Producer<Element> {
typealias Predicate = (Element) throws -> Bool
typealias PredicateWithIndex = (Element, Int) throws -> Bool

18
RxSwift/Observables/Implementations/StartWith.swift
View File

@ -6,7 +6,23 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class StartWith<Element>: Producer<Element> {
extension ObservableType {
/**
Prepends a sequence of values to an observable sequence.
- seealso: [startWith operator on reactivex.io](http://reactivex.io/documentation/operators/startwith.html)
- parameter elements: Elements to prepend to the specified sequence.
- returns: The source sequence prepended with the specified values.
*/
public func startWith(_ elements: E ...)
-> Observable<E> {
return StartWith(source: self.asObservable(), elements: elements)
}
}
final fileprivate class StartWith<Element>: Producer<Element> {
let elements: [Element]
let source: Observable<Element>

27
RxSwift/Observables/Implementations/SubscribeOn.swift
View File

@ -6,7 +6,30 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class SubscribeOnSink<Ob: ObservableType, O: ObserverType> : Sink<O>, ObserverType where Ob.E == O.E {
extension ObservableType {
/**
Wraps the source sequence in order to run its subscription and unsubscription logic on the specified
scheduler.
This operation is not commonly used.
This only performs the side-effects of subscription and unsubscription on the specified scheduler.
In order to invoke observer callbacks on a `scheduler`, use `observeOn`.
- seealso: [subscribeOn operator on reactivex.io](http://reactivex.io/documentation/operators/subscribeon.html)
- parameter scheduler: Scheduler to perform subscription and unsubscription actions on.
- returns: The source sequence whose subscriptions and unsubscriptions happen on the specified scheduler.
*/
public func subscribeOn(_ scheduler: ImmediateSchedulerType)
-> Observable<E> {
return SubscribeOn(source: self, scheduler: scheduler)
}
}
final fileprivate class SubscribeOnSink<Ob: ObservableType, O: ObserverType> : Sink<O>, ObserverType where Ob.E == O.E {
typealias Element = O.E
typealias Parent = SubscribeOn<Ob>
@ -43,7 +66,7 @@ final class SubscribeOnSink<Ob: ObservableType, O: ObserverType> : Sink<O>, Obse
}
}
final class SubscribeOn<Ob: ObservableType> : Producer<Ob.E> {
final fileprivate class SubscribeOn<Ob: ObservableType> : Producer<Ob.E> {
let source: Ob
let scheduler: ImmediateSchedulerType

49
RxSwift/Observables/Implementations/Switch.swift
View File

@ -6,7 +6,44 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
class SwitchSink<SourceType, S: ObservableConvertibleType, O: ObserverType>
extension ObservableType {
/**
Projects each element of an observable sequence into a new sequence of observable sequences and then
transforms an observable sequence of observable sequences into an observable sequence producing values only from the most recent observable sequence.
It is a combination of `map` + `switchLatest` operator
- seealso: [flatMapLatest operator on reactivex.io](http://reactivex.io/documentation/operators/flatmap.html)
- parameter selector: A transform function to apply to each element.
- returns: An observable sequence whose elements are the result of invoking the transform function on each element of source producing an
Observable of Observable sequences and that at any point in time produces the elements of the most recent inner observable sequence that has been received.
*/
public func flatMapLatest<O: ObservableConvertibleType>(_ selector: @escaping (E) throws -> O)
-> Observable<O.E> {
return FlatMapLatest(source: asObservable(), selector: selector)
}
}
extension ObservableType where E : ObservableConvertibleType {
/**
Transforms an observable sequence of observable sequences into an observable sequence
producing values only from the most recent observable sequence.
Each time a new inner observable sequence is received, unsubscribe from the
previous inner observable sequence.
- seealso: [switch operator on reactivex.io](http://reactivex.io/documentation/operators/switch.html)
- returns: The observable sequence that at any point in time produces the elements of the most recent inner observable sequence that has been received.
*/
public func switchLatest() -> Observable<E.E> {
return Switch(source: asObservable())
}
}
fileprivate class SwitchSink<SourceType, S: ObservableConvertibleType, O: ObserverType>
: Sink<O>
, ObserverType
, LockOwnerType
@ -77,7 +114,7 @@ class SwitchSink<SourceType, S: ObservableConvertibleType, O: ObserverType>
}
}
final class SwitchSinkIter<SourceType, S: ObservableConvertibleType, O: ObserverType>
final fileprivate class SwitchSinkIter<SourceType, S: ObservableConvertibleType, O: ObserverType>
: ObserverType
, LockOwnerType
, SynchronizedOnType where S.E == O.E {
@ -131,7 +168,7 @@ final class SwitchSinkIter<SourceType, S: ObservableConvertibleType, O: Observer
// MARK: Specializations
final class SwitchIdentitySink<S: ObservableConvertibleType, O: ObserverType> : SwitchSink<S, S, O> where O.E == S.E {
final fileprivate class SwitchIdentitySink<S: ObservableConvertibleType, O: ObserverType> : SwitchSink<S, S, O> where O.E == S.E {
override init(observer: O, cancel: Cancelable) {
super.init(observer: observer, cancel: cancel)
}
@ -141,7 +178,7 @@ final class SwitchIdentitySink<S: ObservableConvertibleType, O: ObserverType> :
}
}
final class MapSwitchSink<SourceType, S: ObservableConvertibleType, O: ObserverType> : SwitchSink<SourceType, S, O> where O.E == S.E {
final fileprivate class MapSwitchSink<SourceType, S: ObservableConvertibleType, O: ObserverType> : SwitchSink<SourceType, S, O> where O.E == S.E {
typealias Selector = (SourceType) throws -> S
fileprivate let _selector: Selector
@ -158,7 +195,7 @@ final class MapSwitchSink<SourceType, S: ObservableConvertibleType, O: ObserverT
// MARK: Producers
final class Switch<S: ObservableConvertibleType> : Producer<S.E> {
final fileprivate class Switch<S: ObservableConvertibleType> : Producer<S.E> {
fileprivate let _source: Observable<S>
init(source: Observable<S>) {
@ -172,7 +209,7 @@ final class Switch<S: ObservableConvertibleType> : Producer<S.E> {
}
}
final class FlatMapLatest<SourceType, S: ObservableConvertibleType> : Producer<S.E> {
final fileprivate class FlatMapLatest<SourceType, S: ObservableConvertibleType> : Producer<S.E> {
typealias Selector = (SourceType) throws -> S
fileprivate let _source: Observable<SourceType>

20
RxSwift/Observables/Implementations/SwitchIfEmpty.swift
View File

@ -6,7 +6,21 @@
// Copyright © 2016 Krunoslav Zaher. All rights reserved.
//
final class SwitchIfEmpty<Element>: Producer<Element> {
extension ObservableType {
/**
Returns the elements of the specified sequence or `switchTo` sequence if the sequence is empty.
- seealso: [DefaultIfEmpty operator on reactivex.io](http://reactivex.io/documentation/operators/defaultifempty.html)
- parameter switchTo: Observable sequence being returned when source sequence is empty.
- returns: Observable sequence that contains elements from switchTo sequence if source is empty, otherwise returns source sequence elements.
*/
public func ifEmpty(switchTo other: Observable<E>) -> Observable<E> {
return SwitchIfEmpty(source: asObservable(), ifEmpty: other)
}
}
final fileprivate class SwitchIfEmpty<Element>: Producer<Element> {
private let _source: Observable<E>
private let _ifEmpty: Observable<E>
@ -26,7 +40,7 @@ final class SwitchIfEmpty<Element>: Producer<Element> {
}
}
final class SwitchIfEmptySink<O: ObserverType>: Sink<O>
final fileprivate class SwitchIfEmptySink<O: ObserverType>: Sink<O>
, ObserverType {
typealias E = O.E
@ -64,7 +78,7 @@ final class SwitchIfEmptySink<O: ObserverType>: Sink<O>
}
}
final class SwitchIfEmptySinkIter<O: ObserverType>
final fileprivate class SwitchIfEmptySinkIter<O: ObserverType>
: ObserverType {
typealias E = O.E
typealias Parent = SwitchIfEmptySink<O>

46
RxSwift/Observables/Implementations/Take.swift
View File

@ -6,9 +6,47 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
extension ObservableType {
/**
Returns a specified number of contiguous elements from the start of an observable sequence.
- seealso: [take operator on reactivex.io](http://reactivex.io/documentation/operators/take.html)
- parameter count: The number of elements to return.
- returns: An observable sequence that contains the specified number of elements from the start of the input sequence.
*/
public func take(_ count: Int)
-> Observable<E> {
if count == 0 {
return Observable.empty()
}
else {
return TakeCount(source: asObservable(), count: count)
}
}
}
extension ObservableType {
/**
Takes elements for the specified duration from the start of the observable source sequence, using the specified scheduler to run timers.
- seealso: [take operator on reactivex.io](http://reactivex.io/documentation/operators/take.html)
- parameter duration: Duration for taking elements from the start of the sequence.
- parameter scheduler: Scheduler to run the timer on.
- returns: An observable sequence with the elements taken during the specified duration from the start of the source sequence.
*/
public func take(_ duration: RxTimeInterval, scheduler: SchedulerType)
-> Observable<E> {
return TakeTime(source: self.asObservable(), duration: duration, scheduler: scheduler)
}
}
// count version
final class TakeCountSink<O: ObserverType> : Sink<O>, ObserverType {
final fileprivate class TakeCountSink<O: ObserverType> : Sink<O>, ObserverType {
typealias E = O.E
typealias Parent = TakeCount<E>
@ -47,7 +85,7 @@ final class TakeCountSink<O: ObserverType> : Sink<O>, ObserverType {
}
final class TakeCount<Element>: Producer<Element> {
final fileprivate class TakeCount<Element>: Producer<Element> {
fileprivate let _source: Observable<Element>
fileprivate let _count: Int
@ -68,7 +106,7 @@ final class TakeCount<Element>: Producer<Element> {
// time version
final class TakeTimeSink<ElementType, O: ObserverType>
final fileprivate class TakeTimeSink<ElementType, O: ObserverType>
: Sink<O>
, LockOwnerType
, ObserverType
@ -121,7 +159,7 @@ final class TakeTimeSink<ElementType, O: ObserverType>
}
}
final class TakeTime<Element> : Producer<Element> {
final fileprivate class TakeTime<Element> : Producer<Element> {
typealias TimeInterval = RxTimeInterval
fileprivate let _source: Observable<Element>

22
RxSwift/Observables/Implementations/TakeLast.swift
View File

@ -6,7 +6,25 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class TakeLastSink<O: ObserverType> : Sink<O>, ObserverType {
extension ObservableType {
/**
Returns a specified number of contiguous elements from the end of an observable sequence.
This operator accumulates a buffer with a length enough to store elements count elements. Upon completion of the source sequence, this buffer is drained on the result sequence. This causes the elements to be delayed.
- seealso: [takeLast operator on reactivex.io](http://reactivex.io/documentation/operators/takelast.html)
- parameter count: Number of elements to take from the end of the source sequence.
- returns: An observable sequence containing the specified number of elements from the end of the source sequence.
*/
public func takeLast(_ count: Int)
-> Observable<E> {
return TakeLast(source: asObservable(), count: count)
}
}
final fileprivate class TakeLastSink<O: ObserverType> : Sink<O>, ObserverType {
typealias E = O.E
typealias Parent = TakeLast<E>
@ -40,7 +58,7 @@ final class TakeLastSink<O: ObserverType> : Sink<O>, ObserverType {
}
}
final class TakeLast<Element>: Producer<Element> {
final fileprivate class TakeLast<Element>: Producer<Element> {
fileprivate let _source: Observable<Element>
fileprivate let _count: Int

20
RxSwift/Observables/Implementations/TakeUntil.swift
View File

@ -6,6 +6,22 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
extension ObservableType {
/**
Returns the elements from the source observable sequence until the other observable sequence produces an element.
- seealso: [takeUntil operator on reactivex.io](http://reactivex.io/documentation/operators/takeuntil.html)
- parameter other: Observable sequence that terminates propagation of elements of the source sequence.
- returns: An observable sequence containing the elements of the source sequence up to the point the other sequence interrupted further propagation.
*/
public func takeUntil<O: ObservableType>(_ other: O)
-> Observable<E> {
return TakeUntil(source: asObservable(), other: other.asObservable())
}
}
final fileprivate class TakeUntilSinkOther<Other, O: ObserverType>
: ObserverType
, LockOwnerType
@ -52,7 +68,7 @@ final fileprivate class TakeUntilSinkOther<Other, O: ObserverType>
#endif
}
final class TakeUntilSink<Other, O: ObserverType>
final fileprivate class TakeUntilSink<Other, O: ObserverType>
: Sink<O>
, LockOwnerType
, ObserverType
@ -97,7 +113,7 @@ final class TakeUntilSink<Other, O: ObserverType>
}
}
final class TakeUntil<Element, Other>: Producer<Element> {
final fileprivate class TakeUntil<Element, Other>: Producer<Element> {
fileprivate let _source: Observable<Element>
fileprivate let _other: Observable<Other>

37
RxSwift/Observables/Implementations/TakeWhile.swift
View File

@ -6,7 +6,38 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class TakeWhileSink<O: ObserverType>
extension ObservableType {
/**
Returns elements from an observable sequence as long as a specified condition is true.
- seealso: [takeWhile operator on reactivex.io](http://reactivex.io/documentation/operators/takewhile.html)
- parameter predicate: A function to test each element for a condition.
- returns: An observable sequence that contains the elements from the input sequence that occur before the element at which the test no longer passes.
*/
public func takeWhile(_ predicate: @escaping (E) throws -> Bool)
-> Observable<E> {
return TakeWhile(source: asObservable(), predicate: predicate)
}
/**
Returns elements from an observable sequence as long as a specified condition is true.
The element's index is used in the logic of the predicate function.
- seealso: [takeWhile operator on reactivex.io](http://reactivex.io/documentation/operators/takewhile.html)
- parameter predicate: A function to test each element for a condition; the second parameter of the function represents the index of the source element.
- returns: An observable sequence that contains the elements from the input sequence that occur before the element at which the test no longer passes.
*/
public func takeWhileWithIndex(_ predicate: @escaping (E, Int) throws -> Bool)
-> Observable<E> {
return TakeWhile(source: asObservable(), predicate: predicate)
}
}
final fileprivate class TakeWhileSink<O: ObserverType>
: Sink<O>
, ObserverType {
typealias Element = O.E
@ -50,7 +81,7 @@ final class TakeWhileSink<O: ObserverType>
}
final class TakeWhileSinkWithIndex<O: ObserverType>
final fileprivate class TakeWhileSinkWithIndex<O: ObserverType>
: Sink<O>
, ObserverType {
typealias Element = O.E
@ -96,7 +127,7 @@ final class TakeWhileSinkWithIndex<O: ObserverType>
}
final class TakeWhile<Element>: Producer<Element> {
final fileprivate class TakeWhile<Element>: Producer<Element> {
typealias Predicate = (Element) throws -> Bool
typealias PredicateWithIndex = (Element, Int) throws -> Bool

24
RxSwift/Observables/Implementations/Throttle.swift
View File

@ -8,7 +8,27 @@
import struct Foundation.Date
final class ThrottleSink<O: ObserverType>
extension ObservableType {
/**
Returns an Observable that emits the first and the latest item emitted by the source Observable during sequential time windows of a specified duration.
This operator makes sure that no two elements are emitted in less then dueTime.
- seealso: [debounce operator on reactivex.io](http://reactivex.io/documentation/operators/debounce.html)
- parameter dueTime: Throttling duration for each element.
- parameter latest: Should latest element received in a dueTime wide time window since last element emission be emitted.
- parameter scheduler: Scheduler to run the throttle timers on.
- returns: The throttled sequence.
*/
public func throttle(_ dueTime: RxTimeInterval, latest: Bool = true, scheduler: SchedulerType)
-> Observable<E> {
return Throttle(source: self.asObservable(), dueTime: dueTime, latest: latest, scheduler: scheduler)
}
}
final fileprivate class ThrottleSink<O: ObserverType>
: Sink<O>
, ObserverType
, LockOwnerType
@ -120,7 +140,7 @@ final class ThrottleSink<O: ObserverType>
}
}
final class Throttle<Element> : Producer<Element> {
final fileprivate class Throttle<Element> : Producer<Element> {
fileprivate let _source: Observable<Element>
fileprivate let _dueTime: RxTimeInterval

36
RxSwift/Observables/Implementations/Timeout.swift
View File

@ -6,7 +6,39 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class TimeoutSink<O: ObserverType>: Sink<O>, LockOwnerType, ObserverType {
extension ObservableType {
/**
Applies a timeout policy for each element in the observable sequence. If the next element isn't received within the specified timeout duration starting from its predecessor, a TimeoutError is propagated to the observer.
- seealso: [timeout operator on reactivex.io](http://reactivex.io/documentation/operators/timeout.html)
- parameter dueTime: Maximum duration between values before a timeout occurs.
- parameter scheduler: Scheduler to run the timeout timer on.
- returns: An observable sequence with a `RxError.timeout` in case of a timeout.
*/
public func timeout(_ dueTime: RxTimeInterval, scheduler: SchedulerType)
-> Observable<E> {
return Timeout(source: self.asObservable(), dueTime: dueTime, other: Observable.error(RxError.timeout), scheduler: scheduler)
}
/**
Applies a timeout policy for each element in the observable sequence, using the specified scheduler to run timeout timers. If the next element isn't received within the specified timeout duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on.
- seealso: [timeout operator on reactivex.io](http://reactivex.io/documentation/operators/timeout.html)
- parameter dueTime: Maximum duration between values before a timeout occurs.
- parameter other: Sequence to return in case of a timeout.
- parameter scheduler: Scheduler to run the timeout timer on.
- returns: The source sequence switching to the other sequence in case of a timeout.
*/
public func timeout<O: ObservableConvertibleType>(_ dueTime: RxTimeInterval, other: O, scheduler: SchedulerType)
-> Observable<E> where E == O.E {
return Timeout(source: self.asObservable(), dueTime: dueTime, other: other.asObservable(), scheduler: scheduler)
}
}
final fileprivate class TimeoutSink<O: ObserverType>: Sink<O>, LockOwnerType, ObserverType {
typealias E = O.E
typealias Parent = Timeout<E>
@ -98,7 +130,7 @@ final class TimeoutSink<O: ObserverType>: Sink<O>, LockOwnerType, ObserverType {
}
final class Timeout<Element> : Producer<Element> {
final fileprivate class Timeout<Element> : Producer<Element> {
fileprivate let _source: Observable<Element>
fileprivate let _dueTime: RxTimeInterval

46
RxSwift/Observables/Implementations/Timer.swift
View File

@ -6,7 +6,47 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class TimerSink<O: ObserverType> : Sink<O> where O.E : SignedInteger {
extension Observable where Element : SignedInteger {
/**
Returns an observable sequence that produces a value after each period, using the specified scheduler to run timers and to send out observer messages.
- seealso: [interval operator on reactivex.io](http://reactivex.io/documentation/operators/interval.html)
- parameter period: Period for producing the values in the resulting sequence.
- parameter scheduler: Scheduler to run the timer on.
- returns: An observable sequence that produces a value after each period.
*/
public static func interval(_ period: RxTimeInterval, scheduler: SchedulerType)
-> Observable<E> {
return Timer(dueTime: period,
period: period,
scheduler: scheduler
)
}
}
extension Observable where Element: SignedInteger {
/**
Returns an observable sequence that periodically produces a value after the specified initial relative due time has elapsed, using the specified scheduler to run timers.
- seealso: [timer operator on reactivex.io](http://reactivex.io/documentation/operators/timer.html)
- parameter dueTime: Relative time at which to produce the first value.
- parameter period: Period to produce subsequent values.
- parameter scheduler: Scheduler to run timers on.
- returns: An observable sequence that produces a value after due time has elapsed and then each period.
*/
public static func timer(_ dueTime: RxTimeInterval, period: RxTimeInterval? = nil, scheduler: SchedulerType)
-> Observable<E> {
return Timer(
dueTime: dueTime,
period: period,
scheduler: scheduler
)
}
}
final fileprivate class TimerSink<O: ObserverType> : Sink<O> where O.E : SignedInteger {
typealias Parent = Timer<O.E>
private let _parent: Parent
@ -24,7 +64,7 @@ final class TimerSink<O: ObserverType> : Sink<O> where O.E : SignedInteger {
}
}
final class TimerOneOffSink<O: ObserverType> : Sink<O> where O.E : SignedInteger {
final fileprivate class TimerOneOffSink<O: ObserverType> : Sink<O> where O.E : SignedInteger {
typealias Parent = Timer<O.E>
private let _parent: Parent
@ -45,7 +85,7 @@ final class TimerOneOffSink<O: ObserverType> : Sink<O> where O.E : SignedInteger
}
}
final class Timer<E: SignedInteger>: Producer<E> {
final fileprivate class Timer<E: SignedInteger>: Producer<E> {
fileprivate let _scheduler: SchedulerType
fileprivate let _dueTime: RxTimeInterval
fileprivate let _period: RxTimeInterval?

22
RxSwift/Observables/Implementations/ToArray.swift
View File

@ -6,7 +6,25 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class ToArraySink<SourceType, O: ObserverType> : Sink<O>, ObserverType where O.E == [SourceType] {
extension ObservableType {
/**
Converts an Observable into another Observable that emits the whole sequence as a single array and then terminates.
For aggregation behavior see `reduce`.
- seealso: [toArray operator on reactivex.io](http://reactivex.io/documentation/operators/to.html)
- returns: An observable sequence containing all the emitted elements as array.
*/
public func toArray()
-> Observable<[E]> {
return ToArray(source: self.asObservable())
}
}
final fileprivate class ToArraySink<SourceType, O: ObserverType> : Sink<O>, ObserverType where O.E == [SourceType] {
typealias Parent = ToArray<SourceType>
let _parent: Parent
@ -33,7 +51,7 @@ final class ToArraySink<SourceType, O: ObserverType> : Sink<O>, ObserverType whe
}
}
final class ToArray<SourceType> : Producer<[SourceType]> {
final fileprivate class ToArray<SourceType> : Producer<[SourceType]> {
let _source: Observable<SourceType>
init(source: Observable<SourceType>) {

19
RxSwift/Observables/Implementations/Using.swift
View File

@ -6,7 +6,22 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class UsingSink<ResourceType: Disposable, O: ObserverType> : Sink<O>, ObserverType {
extension Observable {
/**
Constructs an observable sequence that depends on a resource object, whose lifetime is tied to the resulting observable sequence's lifetime.
- seealso: [using operator on reactivex.io](http://reactivex.io/documentation/operators/using.html)
- parameter resourceFactory: Factory function to obtain a resource object.
- parameter observableFactory: Factory function to obtain an observable sequence that depends on the obtained resource.
- returns: An observable sequence whose lifetime controls the lifetime of the dependent resource object.
*/
public static func using<R: Disposable>(_ resourceFactory: @escaping () throws -> R, observableFactory: @escaping (R) throws -> Observable<E>) -> Observable<E> {
return Using(resourceFactory: resourceFactory, observableFactory: observableFactory)
}
}
final fileprivate class UsingSink<ResourceType: Disposable, O: ObserverType> : Sink<O>, ObserverType {
typealias SourceType = O.E
typealias Parent = Using<SourceType, ResourceType>
@ -51,7 +66,7 @@ final class UsingSink<ResourceType: Disposable, O: ObserverType> : Sink<O>, Obse
}
}
class Using<SourceType, ResourceType: Disposable>: Producer<SourceType> {
final fileprivate class Using<SourceType, ResourceType: Disposable>: Producer<SourceType> {
typealias E = SourceType

22
RxSwift/Observables/Implementations/Window.swift
View File

@ -6,7 +6,25 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class WindowTimeCountSink<Element, O: ObserverType>
extension ObservableType {
/**
Projects each element of an observable sequence into a window that is completed when either it’s full or a given amount of time has elapsed.
- seealso: [window operator on reactivex.io](http://reactivex.io/documentation/operators/window.html)
- parameter timeSpan: Maximum time length of a window.
- parameter count: Maximum element count of a window.
- parameter scheduler: Scheduler to run windowing timers on.
- returns: An observable sequence of windows (instances of `Observable`).
*/
public func window(timeSpan: RxTimeInterval, count: Int, scheduler: SchedulerType)
-> Observable<Observable<E>> {
return WindowTimeCount(source: self.asObservable(), timeSpan: timeSpan, count: count, scheduler: scheduler)
}
}
final fileprivate class WindowTimeCountSink<Element, O: ObserverType>
: Sink<O>
, ObserverType
, LockOwnerType
@ -130,7 +148,7 @@ final class WindowTimeCountSink<Element, O: ObserverType>
}
}
final class WindowTimeCount<Element> : Producer<Observable<Element>> {
final fileprivate class WindowTimeCount<Element> : Producer<Observable<Element>> {
fileprivate let _timeSpan: RxTimeInterval
fileprivate let _count: Int

34
RxSwift/Observables/Implementations/WithLatestFrom.swift
View File

@ -6,7 +6,35 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
final class WithLatestFromSink<FirstType, SecondType, O: ObserverType>
extension ObservableType {
/**
Merges two observable sequences into one observable sequence by combining each element from self with the latest element from the second source, if any.
- seealso: [combineLatest operator on reactivex.io](http://reactivex.io/documentation/operators/combinelatest.html)
- parameter second: Second observable source.
- parameter resultSelector: Function to invoke for each element from the self combined with the latest element from the second source, if any.
- returns: An observable sequence containing the result of combining each element of the self with the latest element from the second source, if any, using the specified result selector function.
*/
public func withLatestFrom<SecondO: ObservableConvertibleType, ResultType>(_ second: SecondO, resultSelector: @escaping (E, SecondO.E) throws -> ResultType) -> Observable<ResultType> {
return WithLatestFrom(first: asObservable(), second: second.asObservable(), resultSelector: resultSelector)
}
/**
Merges two observable sequences into one observable sequence by using latest element from the second sequence every time when `self` emitts an element.
- seealso: [combineLatest operator on reactivex.io](http://reactivex.io/documentation/operators/combinelatest.html)
- parameter second: Second observable source.
- returns: An observable sequence containing the result of combining each element of the self with the latest element from the second source, if any, using the specified result selector function.
*/
public func withLatestFrom<SecondO: ObservableConvertibleType>(_ second: SecondO) -> Observable<SecondO.E> {
return WithLatestFrom(first: asObservable(), second: second.asObservable(), resultSelector: { $1 })
}
}
final fileprivate class WithLatestFromSink<FirstType, SecondType, O: ObserverType>
: Sink<O>
, ObserverType
, LockOwnerType
@ -62,7 +90,7 @@ final class WithLatestFromSink<FirstType, SecondType, O: ObserverType>
}
}
final class WithLatestFromSecond<FirstType, SecondType, O: ObserverType>
final fileprivate class WithLatestFromSecond<FirstType, SecondType, O: ObserverType>
: ObserverType
, LockOwnerType
, SynchronizedOnType {
@ -100,7 +128,7 @@ final class WithLatestFromSecond<FirstType, SecondType, O: ObserverType>
}
}
final class WithLatestFrom<FirstType, SecondType, ResultType>: Producer<ResultType> {
final fileprivate class WithLatestFrom<FirstType, SecondType, ResultType>: Producer<ResultType> {
typealias ResultSelector = (FirstType, SecondType) throws -> ResultType
fileprivate let _first: Observable<FirstType>

30
RxSwift/Observables/Implementations/Zip+Collection.swift
View File

@ -6,6 +6,34 @@
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
extension Observable {
/**
Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.
- seealso: [zip operator on reactivex.io](http://reactivex.io/documentation/operators/zip.html)
- parameter resultSelector: Function to invoke for each series of elements at corresponding indexes in the sources.
- returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
*/
public static func zip<C: Collection>(_ collection: C, _ resultSelector: @escaping ([C.Iterator.Element.E]) throws -> Element) -> Observable<Element>
where C.Iterator.Element: ObservableType {
return ZipCollectionType(sources: collection, resultSelector: resultSelector)
}
/**
Merges the specified observable sequences into one observable sequence whenever all of the observable sequences have produced an element at a corresponding index.
- seealso: [zip operator on reactivex.io](http://reactivex.io/documentation/operators/zip.html)
- returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
*/
public static func zip<C: Collection>(_ collection: C) -> Observable<[Element]>
where C.Iterator.Element: ObservableType, C.Iterator.Element.E == Element {
return ZipCollectionType(sources: collection, resultSelector: { $0 })
}
}
final fileprivate class ZipCollectionTypeSink<C: Collection, O: ObserverType>
: Sink<O> where C.Iterator.Element : ObservableConvertibleType {
typealias R = O.E
@ -116,7 +144,7 @@ final fileprivate class ZipCollectionTypeSink<C: Collection, O: ObserverType>
}
}
final class ZipCollectionType<C: Collection, R> : Producer<R> where C.Iterator.Element : ObservableConvertibleType {
final fileprivate class ZipCollectionType<C: Collection, R> : Producer<R> where C.Iterator.Element : ObservableConvertibleType {
typealias ResultSelector = ([C.Iterator.Element.E]) throws -> R
let sources: C

59
RxSwift/Observables/Observable+Aggregate.swift
View File

@ -1,59 +0,0 @@
//
// Observable+Aggregate.swift
// RxSwift
//
// Created by Krunoslav Zaher on 3/22/15.
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
// MARK: reduce
extension ObservableType {
/**
Applies an `accumulator` function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. The specified `seed` value is used as the initial accumulator value.
For aggregation behavior with incremental intermediate results, see `scan`.
- seealso: [reduce operator on reactivex.io](http://reactivex.io/documentation/operators/reduce.html)
- parameter seed: The initial accumulator value.
- parameter accumulator: A accumulator function to be invoked on each element.
- parameter mapResult: A function to transform the final accumulator value into the result value.
- returns: An observable sequence containing a single element with the final accumulator value.
*/
public func reduce<A, R>(_ seed: A, accumulator: @escaping (A, E) throws -> A, mapResult: @escaping (A) throws -> R)
-> Observable<R> {
return Reduce(source: self.asObservable(), seed: seed, accumulator: accumulator, mapResult: mapResult)
}
/**
Applies an `accumulator` function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. The specified `seed` value is used as the initial accumulator value.
For aggregation behavior with incremental intermediate results, see `scan`.
- seealso: [reduce operator on reactivex.io](http://reactivex.io/documentation/operators/reduce.html)
- parameter seed: The initial accumulator value.
- parameter accumulator: A accumulator function to be invoked on each element.
- returns: An observable sequence containing a single element with the final accumulator value.
*/
public func reduce<A>(_ seed: A, accumulator: @escaping (A, E) throws -> A)
-> Observable<A> {
return Reduce(source: self.asObservable(), seed: seed, accumulator: accumulator, mapResult: { $0 })
}
/**
Converts an Observable into another Observable that emits the whole sequence as a single array and then terminates.
For aggregation behavior see `reduce`.
- seealso: [toArray operator on reactivex.io](http://reactivex.io/documentation/operators/to.html)
- returns: An observable sequence containing all the emitted elements as array.
*/
public func toArray()
-> Observable<[E]> {
return ToArray(source: self.asObservable())
}
}

179
RxSwift/Observables/Observable+Binding.swift
View File

@ -1,179 +0,0 @@
//
// Observable+Binding.swift
// RxSwift
//
// Created by Krunoslav Zaher on 3/1/15.
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
// MARK: multicast
extension ObservableType {
/**
Multicasts the source sequence notifications through the specified subject to the resulting connectable observable.
Upon connection of the connectable observable, the subject is subscribed to the source exactly one, and messages are forwarded to the observers registered with the connectable observable.
For specializations with fixed subject types, see `publish` and `replay`.
- seealso: [multicast operator on reactivex.io](http://reactivex.io/documentation/operators/publish.html)
- parameter subject: Subject to push source elements into.
- returns: A connectable observable sequence that upon connection causes the source sequence to push results into the specified subject.
*/
public func multicast<S: SubjectType>(_ subject: S)
-> ConnectableObservable<S.E> where S.SubjectObserverType.E == E {
return ConnectableObservableAdapter(source: self.asObservable(), subject: subject)
}
/**
Multicasts the source sequence notifications through an instantiated subject into all uses of the sequence within a selector function.
Each subscription to the resulting sequence causes a separate multicast invocation, exposing the sequence resulting from the selector function's invocation.
For specializations with fixed subject types, see `publish` and `replay`.
- seealso: [multicast operator on reactivex.io](http://reactivex.io/documentation/operators/publish.html)
- parameter subjectSelector: Factory function to create an intermediate subject through which the source sequence's elements will be multicast to the selector function.
- parameter selector: Selector function which can use the multicasted source sequence subject to the policies enforced by the created subject.
- returns: An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.
*/
public func multicast<S: SubjectType, R>(_ subjectSelector: @escaping () throws -> S, selector: @escaping (Observable<S.E>) throws -> Observable<R>)
-> Observable<R> where S.SubjectObserverType.E == E {
return Multicast(
source: self.asObservable(),
subjectSelector: subjectSelector,
selector: selector
)
}
}
// MARK: publish
extension ObservableType {
/**
Returns a connectable observable sequence that shares a single subscription to the underlying sequence.
This operator is a specialization of `multicast` using a `PublishSubject`.
- seealso: [publish operator on reactivex.io](http://reactivex.io/documentation/operators/publish.html)
- returns: A connectable observable sequence that shares a single subscription to the underlying sequence.
*/
public func publish() -> ConnectableObservable<E> {
return self.multicast(PublishSubject())
}
}
// MARK: replay
extension ObservableType {
/**
Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying bufferSize elements.
This operator is a specialization of `multicast` using a `ReplaySubject`.
- seealso: [replay operator on reactivex.io](http://reactivex.io/documentation/operators/replay.html)
- parameter bufferSize: Maximum element count of the replay buffer.
- returns: A connectable observable sequence that shares a single subscription to the underlying sequence.
*/
public func replay(_ bufferSize: Int)
-> ConnectableObservable<E> {
return self.multicast(ReplaySubject.create(bufferSize: bufferSize))
}
/**
Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying all elements.
This operator is a specialization of `multicast` using a `ReplaySubject`.
- seealso: [replay operator on reactivex.io](http://reactivex.io/documentation/operators/replay.html)
- returns: A connectable observable sequence that shares a single subscription to the underlying sequence.
*/
public func replayAll()
-> ConnectableObservable<E> {
return self.multicast(ReplaySubject.createUnbounded())
}
}
// MARK: refcount
extension ConnectableObservableType {
/**
Returns an observable sequence that stays connected to the source as long as there is at least one subscription to the observable sequence.
- seealso: [refCount operator on reactivex.io](http://reactivex.io/documentation/operators/refCount.html)
- returns: An observable sequence that stays connected to the source as long as there is at least one subscription to the observable sequence.
*/
public func refCount() -> Observable<E> {
return RefCount(source: self)
}
}
// MARK: share
extension ObservableType {
/**
Returns an observable sequence that shares a single subscription to the underlying sequence.
This operator is a specialization of publish which creates a subscription when the number of observers goes from zero to one, then shares that subscription with all subsequent observers until the number of observers returns to zero, at which point the subscription is disposed.
- seealso: [share operator on reactivex.io](http://reactivex.io/documentation/operators/refcount.html)
- returns: An observable sequence that contains the elements of a sequence produced by multicasting the source sequence.
*/
public func share() -> Observable<E> {
return self.publish().refCount()
}
}
// MARK: shareReplay
extension ObservableType {
/**
Returns an observable sequence that shares a single subscription to the underlying sequence, and immediately upon subscription replays maximum number of elements in buffer.
This operator is a specialization of replay which creates a subscription when the number of observers goes from zero to one, then shares that subscription with all subsequent observers until the number of observers returns to zero, at which point the subscription is disposed.
- seealso: [shareReplay operator on reactivex.io](http://reactivex.io/documentation/operators/replay.html)
- parameter bufferSize: Maximum element count of the replay buffer.
- returns: An observable sequence that contains the elements of a sequence produced by multicasting the source sequence.
*/
public func shareReplay(_ bufferSize: Int)
-> Observable<E> {
if bufferSize == 1 {
return ShareReplay1(source: self.asObservable())
}
else {
return self.replay(bufferSize).refCount()
}
}
/**
Returns an observable sequence that shares a single subscription to the underlying sequence, and immediately upon subscription replays latest element in buffer.
This operator is a specialization of replay which creates a subscription when the number of observers goes from zero to one, then shares that subscription with all subsequent observers until the number of observers returns to zero, at which point the subscription is disposed.
Unlike `shareReplay(bufferSize: Int)`, this operator will clear latest element from replay buffer in case number of subscribers drops from one to zero. In case sequence
completes or errors out replay buffer is also cleared.
- seealso: [shareReplay operator on reactivex.io](http://reactivex.io/documentation/operators/replay.html)
- returns: An observable sequence that contains the elements of a sequence produced by multicasting the source sequence.
*/
public func shareReplayLatestWhileConnected()
-> Observable<E> {
return ShareReplay1WhileConnected(source: self.asObservable())
}
}

58
RxSwift/Observables/Observable+Concurrency.swift
View File

@ -1,58 +0,0 @@
//
// Observable+Concurrency.swift
// RxSwift
//
// Created by Krunoslav Zaher on 3/15/15.
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
// MARK: observeOn
extension ObservableType {
/**
Wraps the source sequence in order to run its observer callbacks on the specified scheduler.
This only invokes observer callbacks on a `scheduler`. In case the subscription and/or unsubscription
actions have side-effects that require to be run on a scheduler, use `subscribeOn`.
- seealso: [observeOn operator on reactivex.io](http://reactivex.io/documentation/operators/observeon.html)
- parameter scheduler: Scheduler to notify observers on.
- returns: The source sequence whose observations happen on the specified scheduler.
*/
public func observeOn(_ scheduler: ImmediateSchedulerType)
-> Observable<E> {
if let scheduler = scheduler as? SerialDispatchQueueScheduler {
return ObserveOnSerialDispatchQueue(source: self.asObservable(), scheduler: scheduler)
}
else {
return ObserveOn(source: self.asObservable(), scheduler: scheduler)
}
}
}
// MARK: subscribeOn
extension ObservableType {
/**
Wraps the source sequence in order to run its subscription and unsubscription logic on the specified
scheduler.
This operation is not commonly used.
This only performs the side-effects of subscription and unsubscription on the specified scheduler.
In order to invoke observer callbacks on a `scheduler`, use `observeOn`.
- seealso: [subscribeOn operator on reactivex.io](http://reactivex.io/documentation/operators/subscribeon.html)
- parameter scheduler: Scheduler to perform subscription and unsubscription actions on.
- returns: The source sequence whose subscriptions and unsubscriptions happen on the specified scheduler.
*/
public func subscribeOn(_ scheduler: ImmediateSchedulerType)
-> Observable<E> {
return SubscribeOn(source: self, scheduler: scheduler)
}
}

226
RxSwift/Observables/Observable+Creation.swift
View File

@ -1,226 +0,0 @@
//
// Observable+Creation.swift
// RxSwift
//
// Created by Krunoslav Zaher on 3/21/15.
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
extension Observable {
// MARK: create
/**
Creates an observable sequence from a specified subscribe method implementation.
- seealso: [create operator on reactivex.io](http://reactivex.io/documentation/operators/create.html)
- parameter subscribe: Implementation of the resulting observable sequence's `subscribe` method.
- returns: The observable sequence with the specified implementation for the `subscribe` method.
*/
public static func create(_ subscribe: @escaping (AnyObserver<E>) -> Disposable) -> Observable<E> {
return AnonymousObservable(subscribe)
}
// MARK: empty
/**
Returns an empty observable sequence, using the specified scheduler to send out the single `Completed` message.
- seealso: [empty operator on reactivex.io](http://reactivex.io/documentation/operators/empty-never-throw.html)
- returns: An observable sequence with no elements.
*/
public static func empty() -> Observable<E> {
return EmptyProducer<E>()
}
// MARK: never
/**
Returns a non-terminating observable sequence, which can be used to denote an infinite duration.
- seealso: [never operator on reactivex.io](http://reactivex.io/documentation/operators/empty-never-throw.html)
- returns: An observable sequence whose observers will never get called.
*/
public static func never() -> Observable<E> {
return NeverProducer()
}
// MARK: just
/**
Returns an observable sequence that contains a single element.
- seealso: [just operator on reactivex.io](http://reactivex.io/documentation/operators/just.html)
- parameter element: Single element in the resulting observable sequence.
- returns: An observable sequence containing the single specified element.
*/
public static func just(_ element: E) -> Observable<E> {
return Just(element: element)
}
/**
Returns an observable sequence that contains a single element.
- seealso: [just operator on reactivex.io](http://reactivex.io/documentation/operators/just.html)
- parameter element: Single element in the resulting observable sequence.
- parameter: Scheduler to send the single element on.
- returns: An observable sequence containing the single specified element.
*/
public static func just(_ element: E, scheduler: ImmediateSchedulerType) -> Observable<E> {
return JustScheduled(element: element, scheduler: scheduler)
}
// MARK: fail
/**
Returns an observable sequence that terminates with an `error`.
- seealso: [throw operator on reactivex.io](http://reactivex.io/documentation/operators/empty-never-throw.html)
- returns: The observable sequence that terminates with specified error.
*/
public static func error(_ error: Swift.Error) -> Observable<E> {
return ErrorProducer(error: error)
}
// MARK: of
/**
This method creates a new Observable instance with a variable number of elements.
- seealso: [from operator on reactivex.io](http://reactivex.io/documentation/operators/from.html)
- parameter elements: Elements to generate.
- parameter scheduler: Scheduler to send elements on. If `nil`, elements are sent immediatelly on subscription.
- returns: The observable sequence whose elements are pulled from the given arguments.
*/
public static func of(_ elements: E ..., scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance) -> Observable<E> {
return ObservableSequence(elements: elements, scheduler: scheduler)
}
// MARK: defer
/**
Returns an observable sequence that invokes the specified factory function whenever a new observer subscribes.
- seealso: [defer operator on reactivex.io](http://reactivex.io/documentation/operators/defer.html)
- parameter observableFactory: Observable factory function to invoke for each observer that subscribes to the resulting sequence.
- returns: An observable sequence whose observers trigger an invocation of the given observable factory function.
*/
public static func deferred(_ observableFactory: @escaping () throws -> Observable<E>)
-> Observable<E> {
return Deferred(observableFactory: observableFactory)
}
/**
Generates an observable sequence by running a state-driven loop producing the sequence's elements, using the specified scheduler
to run the loop send out observer messages.
- seealso: [create operator on reactivex.io](http://reactivex.io/documentation/operators/create.html)
- parameter initialState: Initial state.
- parameter condition: Condition to terminate generation (upon returning `false`).
- parameter iterate: Iteration step function.
- parameter scheduler: Scheduler on which to run the generator loop.
- returns: The generated sequence.
*/
public static func generate(initialState: E, condition: @escaping (E) throws -> Bool, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance, iterate: @escaping (E) throws -> E) -> Observable<E> {
return Generate(initialState: initialState, condition: condition, iterate: iterate, resultSelector: { $0 }, scheduler: scheduler)
}
/**
Generates an observable sequence that repeats the given element infinitely, using the specified scheduler to send out observer messages.
- seealso: [repeat operator on reactivex.io](http://reactivex.io/documentation/operators/repeat.html)
- parameter element: Element to repeat.
- parameter scheduler: Scheduler to run the producer loop on.
- returns: An observable sequence that repeats the given element infinitely.
*/
public static func repeatElement(_ element: E, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance) -> Observable<E> {
return RepeatElement(element: element, scheduler: scheduler)
}
/**
Constructs an observable sequence that depends on a resource object, whose lifetime is tied to the resulting observable sequence's lifetime.
- seealso: [using operator on reactivex.io](http://reactivex.io/documentation/operators/using.html)
- parameter resourceFactory: Factory function to obtain a resource object.
- parameter observableFactory: Factory function to obtain an observable sequence that depends on the obtained resource.
- returns: An observable sequence whose lifetime controls the lifetime of the dependent resource object.
*/
public static func using<R: Disposable>(_ resourceFactory: @escaping () throws -> R, observableFactory: @escaping (R) throws -> Observable<E>) -> Observable<E> {
return Using(resourceFactory: resourceFactory, observableFactory: observableFactory)
}
}
extension Observable where Element : SignedInteger {
/**
Generates an observable sequence of integral numbers within a specified range, using the specified scheduler to generate and send out observer messages.
- seealso: [range operator on reactivex.io](http://reactivex.io/documentation/operators/range.html)
- parameter start: The value of the first integer in the sequence.
- parameter count: The number of sequential integers to generate.
- parameter scheduler: Scheduler to run the generator loop on.
- returns: An observable sequence that contains a range of sequential integral numbers.
*/
public static func range(start: E, count: E, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance) -> Observable<E> {
return RangeProducer<E>(start: start, count: count, scheduler: scheduler)
}
}
extension Observable {
/**
Converts an array to an observable sequence.
- seealso: [from operator on reactivex.io](http://reactivex.io/documentation/operators/from.html)
- returns: The observable sequence whose elements are pulled from the given enumerable sequence.
*/
public static func from(_ array: [E], scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance) -> Observable<E> {
return ObservableSequence(elements: array, scheduler: scheduler)
}
/**
Converts a sequence to an observable sequence.
- seealso: [from operator on reactivex.io](http://reactivex.io/documentation/operators/from.html)
- returns: The observable sequence whose elements are pulled from the given enumerable sequence.
*/
public static func from<S: Sequence>(_ sequence: S, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance) -> Observable<E> where S.Iterator.Element == E {
return ObservableSequence(elements: sequence, scheduler: scheduler)
}
/**
Converts a optional to an observable sequence.
- seealso: [from operator on reactivex.io](http://reactivex.io/documentation/operators/from.html)
- parameter optional: Optional element in the resulting observable sequence.
- returns: An observable sequence containing the wrapped value or not from given optional.
*/
public static func from(optional: E?) -> Observable<E> {
return ObservableOptional(optional: optional)
}
/**
Converts a optional to an observable sequence.
- seealso: [from operator on reactivex.io](http://reactivex.io/documentation/operators/from.html)
- parameter optional: Optional element in the resulting observable sequence.
- parameter: Scheduler to send the optional element on.
- returns: An observable sequence containing the wrapped value or not from given optional.
*/
public static func from(optional: E?, scheduler: ImmediateSchedulerType) -> Observable<E> {
return ObservableOptionalScheduled(optional: optional, scheduler: scheduler)
}
}

26
RxSwift/Observables/Observable+Debug.swift
View File

@ -1,26 +0,0 @@
//
// Observable+Debug.swift
// RxSwift
//
// Created by Krunoslav Zaher on 5/2/15.
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
// MARK: debug
extension ObservableType {
/**
Prints received events for all observers on standard output.
- seealso: [do operator on reactivex.io](http://reactivex.io/documentation/operators/do.html)
- parameter identifier: Identifier that is printed together with event description to standard output.
- parameter trimOutput: Should output be trimmed to max 40 characters.
- returns: An observable sequence whose events are printed to standard output.
*/
public func debug(_ identifier: String? = nil, trimOutput: Bool = false, file: String = #file, line: UInt = #line, function: String = #function)
-> Observable<E> {
return Debug(source: self, identifier: identifier, trimOutput: trimOutput, file: file, line: line, function: function)
}
}

402
RxSwift/Observables/Observable+Multiple.swift
View File

@ -1,402 +0,0 @@
//
// Observable+Multiple.swift
// RxSwift
//
// Created by Krunoslav Zaher on 3/12/15.
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
// MARK: combineLatest
extension Observable {
/**
Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element.
- seealso: [combinelatest operator on reactivex.io](http://reactivex.io/documentation/operators/combinelatest.html)
- parameter resultSelector: Function to invoke whenever any of the sources produces an element.
- returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
*/
public static func combineLatest<C: Collection>(_ collection: C, _ resultSelector: @escaping ([C.Iterator.Element.E]) throws -> Element) -> Observable<Element>
where C.Iterator.Element: ObservableType {
return CombineLatestCollectionType(sources: collection, resultSelector: resultSelector)
}
/**
Merges the specified observable sequences into one observable sequence whenever any of the observable sequences produces an element.
- seealso: [combinelatest operator on reactivex.io](http://reactivex.io/documentation/operators/combinelatest.html)
- returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
*/
public static func combineLatest<C: Collection>(_ collection: C) -> Observable<[Element]>
where C.Iterator.Element: ObservableType, C.Iterator.Element.E == Element {
return CombineLatestCollectionType(sources: collection, resultSelector: { $0 })
}
}
// MARK: zip
extension Observable {
/**
Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.
- seealso: [zip operator on reactivex.io](http://reactivex.io/documentation/operators/zip.html)
- parameter resultSelector: Function to invoke for each series of elements at corresponding indexes in the sources.
- returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
*/
public static func zip<C: Collection>(_ collection: C, _ resultSelector: @escaping ([C.Iterator.Element.E]) throws -> Element) -> Observable<Element>
where C.Iterator.Element: ObservableType {
return ZipCollectionType(sources: collection, resultSelector: resultSelector)
}
/**
Merges the specified observable sequences into one observable sequence whenever all of the observable sequences have produced an element at a corresponding index.
- seealso: [zip operator on reactivex.io](http://reactivex.io/documentation/operators/zip.html)
- returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
*/
public static func zip<C: Collection>(_ collection: C) -> Observable<[Element]>
where C.Iterator.Element: ObservableType, C.Iterator.Element.E == Element {
return ZipCollectionType(sources: collection, resultSelector: { $0 })
}
}
// MARK: switch
extension ObservableType where E : ObservableConvertibleType {
/**
Transforms an observable sequence of observable sequences into an observable sequence
producing values only from the most recent observable sequence.
Each time a new inner observable sequence is received, unsubscribe from the
previous inner observable sequence.
- seealso: [switch operator on reactivex.io](http://reactivex.io/documentation/operators/switch.html)
- returns: The observable sequence that at any point in time produces the elements of the most recent inner observable sequence that has been received.
*/
public func switchLatest() -> Observable<E.E> {
return Switch(source: asObservable())
}
}
// switchIfEmpty
extension ObservableType {
/**
Returns the elements of the specified sequence or `switchTo` sequence if the sequence is empty.
- seealso: [DefaultIfEmpty operator on reactivex.io](http://reactivex.io/documentation/operators/defaultifempty.html)
- parameter switchTo: Observable sequence being returned when source sequence is empty.
- returns: Observable sequence that contains elements from switchTo sequence if source is empty, otherwise returns source sequence elements.
*/
public func ifEmpty(switchTo other: Observable<E>) -> Observable<E> {
return SwitchIfEmpty(source: asObservable(), ifEmpty: other)
}
}
// MARK: concat
extension ObservableType {
/**
Concatenates the second observable sequence to `self` upon successful termination of `self`.
- seealso: [concat operator on reactivex.io](http://reactivex.io/documentation/operators/concat.html)
- parameter second: Second observable sequence.
- returns: An observable sequence that contains the elements of `self`, followed by those of the second sequence.
*/
public func concat<O: ObservableConvertibleType>(_ second: O) -> Observable<E> where O.E == E {
return Observable.concat([self.asObservable(), second.asObservable()])
}
}
extension Observable {
/**
Concatenates all observable sequences in the given sequence, as long as the previous observable sequence terminated successfully.
This operator has tail recursive optimizations that will prevent stack overflow.
Optimizations will be performed in cases equivalent to following:
[1, [2, [3, .....].concat()].concat].concat()
- seealso: [concat operator on reactivex.io](http://reactivex.io/documentation/operators/concat.html)
- returns: An observable sequence that contains the elements of each given sequence, in sequential order.
*/
public static func concat<S: Sequence >(_ sequence: S) -> Observable<Element>
where S.Iterator.Element == Observable<Element> {
return Concat(sources: sequence, count: nil)
}
/**
Concatenates all observable sequences in the given collection, as long as the previous observable sequence terminated successfully.
This operator has tail recursive optimizations that will prevent stack overflow.
Optimizations will be performed in cases equivalent to following:
[1, [2, [3, .....].concat()].concat].concat()
- seealso: [concat operator on reactivex.io](http://reactivex.io/documentation/operators/concat.html)
- returns: An observable sequence that contains the elements of each given sequence, in sequential order.
*/
public static func concat<S: Collection >(_ collection: S) -> Observable<Element>
where S.Iterator.Element == Observable<Element> {
return Concat(sources: collection, count: collection.count.toIntMax())
}
/**
Concatenates all observable sequences in the given collection, as long as the previous observable sequence terminated successfully.
This operator has tail recursive optimizations that will prevent stack overflow.
Optimizations will be performed in cases equivalent to following:
[1, [2, [3, .....].concat()].concat].concat()
- seealso: [concat operator on reactivex.io](http://reactivex.io/documentation/operators/concat.html)
- returns: An observable sequence that contains the elements of each given sequence, in sequential order.
*/
public static func concat(_ sources: Observable<Element> ...) -> Observable<Element> {
return Concat(sources: sources, count: sources.count.toIntMax())
}
}
extension ObservableType where E : ObservableConvertibleType {
/**
Concatenates all inner observable sequences, as long as the previous observable sequence terminated successfully.
- seealso: [concat operator on reactivex.io](http://reactivex.io/documentation/operators/concat.html)
- returns: An observable sequence that contains the elements of each observed inner sequence, in sequential order.
*/
public func concat() -> Observable<E.E> {
return merge(maxConcurrent: 1)
}
}
// MARK: merge
extension Observable {
/**
Merges elements from all observable sequences from collection into a single observable sequence.
- seealso: [merge operator on reactivex.io](http://reactivex.io/documentation/operators/merge.html)
- parameter sources: Collection of observable sequences to merge.
- returns: The observable sequence that merges the elements of the observable sequences.
*/
public static func merge<C: Collection>(_ sources: C) -> Observable<E> where C.Iterator.Element == Observable<E> {
return MergeArray(sources: Array(sources))
}
/**
Merges elements from all observable sequences from array into a single observable sequence.
- seealso: [merge operator on reactivex.io](http://reactivex.io/documentation/operators/merge.html)
- parameter sources: Array of observable sequences to merge.
- returns: The observable sequence that merges the elements of the observable sequences.
*/
public static func merge(_ sources: [Observable<E>]) -> Observable<E> {
return MergeArray(sources: sources)
}
/**
Merges elements from all observable sequences into a single observable sequence.
- seealso: [merge operator on reactivex.io](http://reactivex.io/documentation/operators/merge.html)
- parameter sources: Collection of observable sequences to merge.
- returns: The observable sequence that merges the elements of the observable sequences.
*/
public static func merge(_ sources: Observable<E>...) -> Observable<E> {
return MergeArray(sources: sources)
}
}
extension ObservableType where E : ObservableConvertibleType {
/**
Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence.
- seealso: [merge operator on reactivex.io](http://reactivex.io/documentation/operators/merge.html)
- returns: The observable sequence that merges the elements of the observable sequences.
*/
public func merge() -> Observable<E.E> {
return Merge(source: asObservable())
}
/**
Merges elements from all inner observable sequences into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences.
- seealso: [merge operator on reactivex.io](http://reactivex.io/documentation/operators/merge.html)
- parameter maxConcurrent: Maximum number of inner observable sequences being subscribed to concurrently.
- returns: The observable sequence that merges the elements of the inner sequences.
*/
public func merge(maxConcurrent: Int)
-> Observable<E.E> {
return MergeLimited(source: asObservable(), maxConcurrent: maxConcurrent)
}
}
// MARK: catch
extension ObservableType {
/**
Continues an observable sequence that is terminated by an error with the observable sequence produced by the handler.
- seealso: [catch operator on reactivex.io](http://reactivex.io/documentation/operators/catch.html)
- parameter handler: Error handler function, producing another observable sequence.
- returns: An observable sequence containing the source sequence's elements, followed by the elements produced by the handler's resulting observable sequence in case an error occurred.
*/
public func catchError(_ handler: @escaping (Swift.Error) throws -> Observable<E>)
-> Observable<E> {
return Catch(source: asObservable(), handler: handler)
}
/**
Continues an observable sequence that is terminated by an error with a single element.
- seealso: [catch operator on reactivex.io](http://reactivex.io/documentation/operators/catch.html)
- parameter element: Last element in an observable sequence in case error occurs.
- returns: An observable sequence containing the source sequence's elements, followed by the `element` in case an error occurred.
*/
public func catchErrorJustReturn(_ element: E)
-> Observable<E> {
return Catch(source: asObservable(), handler: { _ in Observable.just(element) })
}
}
extension Observable {
/**
Continues an observable sequence that is terminated by an error with the next observable sequence.
- seealso: [catch operator on reactivex.io](http://reactivex.io/documentation/operators/catch.html)
- returns: An observable sequence containing elements from consecutive source sequences until a source sequence terminates successfully.
*/
public static func catchError<S: Sequence>(_ sequence: S) -> Observable<Element>
where S.Iterator.Element == Observable<Element> {
return CatchSequence(sources: sequence)
}
}
// MARK: takeUntil
extension ObservableType {
/**
Returns the elements from the source observable sequence until the other observable sequence produces an element.
- seealso: [takeUntil operator on reactivex.io](http://reactivex.io/documentation/operators/takeuntil.html)
- parameter other: Observable sequence that terminates propagation of elements of the source sequence.
- returns: An observable sequence containing the elements of the source sequence up to the point the other sequence interrupted further propagation.
*/
public func takeUntil<O: ObservableType>(_ other: O)
-> Observable<E> {
return TakeUntil(source: asObservable(), other: other.asObservable())
}
}
// MARK: skipUntil
extension ObservableType {
/**
Returns the elements from the source observable sequence that are emitted after the other observable sequence produces an element.
- seealso: [skipUntil operator on reactivex.io](http://reactivex.io/documentation/operators/skipuntil.html)
- parameter other: Observable sequence that starts propagation of elements of the source sequence.
- returns: An observable sequence containing the elements of the source sequence that are emitted after the other sequence emits an item.
*/
public func skipUntil<O: ObservableType>(_ other: O)
-> Observable<E> {
return SkipUntil(source: asObservable(), other: other.asObservable())
}
}
// MARK: amb
extension ObservableType {
/**
Propagates the observable sequence that reacts first.
- seealso: [amb operator on reactivex.io](http://reactivex.io/documentation/operators/amb.html)
- parameter right: Second observable sequence.
- returns: An observable sequence that surfaces either of the given sequences, whichever reacted first.
*/
public func amb<O2: ObservableType>
(_ right: O2)
-> Observable<E> where O2.E == E {
return Amb(left: asObservable(), right: right.asObservable())
}
}
extension Observable {
/**
Propagates the observable sequence that reacts first.
- seealso: [amb operator on reactivex.io](http://reactivex.io/documentation/operators/amb.html)
- returns: An observable sequence that surfaces any of the given sequences, whichever reacted first.
*/
public static func amb<S: Sequence>(_ sequence: S) -> Observable<Element>
where S.Iterator.Element == Observable<Element> {
return sequence.reduce(Observable<S.Iterator.Element.E>.never()) { a, o in
return a.amb(o.asObservable())
}
}
}
// withLatestFrom
extension ObservableType {
/**
Merges two observable sequences into one observable sequence by combining each element from self with the latest element from the second source, if any.
- seealso: [combineLatest operator on reactivex.io](http://reactivex.io/documentation/operators/combinelatest.html)
- parameter second: Second observable source.
- parameter resultSelector: Function to invoke for each element from the self combined with the latest element from the second source, if any.
- returns: An observable sequence containing the result of combining each element of the self with the latest element from the second source, if any, using the specified result selector function.
*/
public func withLatestFrom<SecondO: ObservableConvertibleType, ResultType>(_ second: SecondO, resultSelector: @escaping (E, SecondO.E) throws -> ResultType) -> Observable<ResultType> {
return WithLatestFrom(first: asObservable(), second: second.asObservable(), resultSelector: resultSelector)
}
/**
Merges two observable sequences into one observable sequence by using latest element from the second sequence every time when `self` emitts an element.
- seealso: [combineLatest operator on reactivex.io](http://reactivex.io/documentation/operators/combinelatest.html)
- parameter second: Second observable source.
- returns: An observable sequence containing the result of combining each element of the self with the latest element from the second source, if any, using the specified result selector function.
*/
public func withLatestFrom<SecondO: ObservableConvertibleType>(_ second: SecondO) -> Observable<SecondO.E> {
return WithLatestFrom(first: asObservable(), second: second.asObservable(), resultSelector: { $1 })
}
}

256
RxSwift/Observables/Observable+Single.swift
View File

@ -1,256 +0,0 @@
//
// Observable+Single.swift
// RxSwift
//
// Created by Krunoslav Zaher on 2/14/15.
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
// MARK: distinct until changed
extension ObservableType where E: Equatable {
/**
Returns an observable sequence that contains only distinct contiguous elements according to equality operator.
- seealso: [distinct operator on reactivex.io](http://reactivex.io/documentation/operators/distinct.html)
- returns: An observable sequence only containing the distinct contiguous elements, based on equality operator, from the source sequence.
*/
public func distinctUntilChanged()
-> Observable<E> {
return self.distinctUntilChanged({ $0 }, comparer: { ($0 == $1) })
}
}
extension ObservableType {
/**
Returns an observable sequence that contains only distinct contiguous elements according to the `keySelector`.
- seealso: [distinct operator on reactivex.io](http://reactivex.io/documentation/operators/distinct.html)
- parameter keySelector: A function to compute the comparison key for each element.
- returns: An observable sequence only containing the distinct contiguous elements, based on a computed key value, from the source sequence.
*/
public func distinctUntilChanged<K: Equatable>(_ keySelector: @escaping (E) throws -> K)
-> Observable<E> {
return self.distinctUntilChanged(keySelector, comparer: { $0 == $1 })
}
/**
Returns an observable sequence that contains only distinct contiguous elements according to the `comparer`.
- seealso: [distinct operator on reactivex.io](http://reactivex.io/documentation/operators/distinct.html)
- parameter comparer: Equality comparer for computed key values.
- returns: An observable sequence only containing the distinct contiguous elements, based on `comparer`, from the source sequence.
*/
public func distinctUntilChanged(_ comparer: @escaping (E, E) throws -> Bool)
-> Observable<E> {
return self.distinctUntilChanged({ $0 }, comparer: comparer)
}
/**
Returns an observable sequence that contains only distinct contiguous elements according to the keySelector and the comparer.
- seealso: [distinct operator on reactivex.io](http://reactivex.io/documentation/operators/distinct.html)
- parameter keySelector: A function to compute the comparison key for each element.
- parameter comparer: Equality comparer for computed key values.
- returns: An observable sequence only containing the distinct contiguous elements, based on a computed key value and the comparer, from the source sequence.
*/
public func distinctUntilChanged<K>(_ keySelector: @escaping (E) throws -> K, comparer: @escaping (K, K) throws -> Bool)
-> Observable<E> {
return DistinctUntilChanged(source: self.asObservable(), selector: keySelector, comparer: comparer)
}
}
// MARK: doOn
extension ObservableType {
/**
Invokes an action for each event in the observable sequence, and propagates all observer messages through the result sequence.
- seealso: [do operator on reactivex.io](http://reactivex.io/documentation/operators/do.html)
- parameter onNext: Action to invoke for each element in the observable sequence.
- parameter onError: Action to invoke upon errored termination of the observable sequence.
- parameter onCompleted: Action to invoke upon graceful termination of the observable sequence.
- parameter onSubscribe: Action to invoke before subscribing to source observable sequence.
- parameter onSubscribed: Action to invoke after subscribing to source observable sequence.
- parameter onDispose: Action to invoke after subscription to source observable has been disposed for any reason. It can be either because sequence terminates for some reason or observer subscription being disposed.
- returns: The source sequence with the side-effecting behavior applied.
*/
public func `do`(onNext: ((E) throws -> Void)? = nil, onError: ((Swift.Error) throws -> Void)? = nil, onCompleted: (() throws -> Void)? = nil, onSubscribe: (() -> ())? = nil, onSubscribed: (() -> ())? = nil, onDispose: (() -> ())? = nil)
-> Observable<E> {
return Do(source: self.asObservable(), eventHandler: { e in
switch e {
case .next(let element):
try onNext?(element)
case .error(let e):
try onError?(e)
case .completed:
try onCompleted?()
}
}, onSubscribe: onSubscribe, onSubscribed: onSubscribed, onDispose: onDispose)
}
}
// MARK: startWith
extension ObservableType {
/**
Prepends a sequence of values to an observable sequence.
- seealso: [startWith operator on reactivex.io](http://reactivex.io/documentation/operators/startwith.html)
- parameter elements: Elements to prepend to the specified sequence.
- returns: The source sequence prepended with the specified values.
*/
public func startWith(_ elements: E ...)
-> Observable<E> {
return StartWith(source: self.asObservable(), elements: elements)
}
}
// MARK: retry
extension ObservableType {
/**
Repeats the source observable sequence until it successfully terminates.
**This could potentially create an infinite sequence.**
- seealso: [retry operator on reactivex.io](http://reactivex.io/documentation/operators/retry.html)
- returns: Observable sequence to repeat until it successfully terminates.
*/
public func retry() -> Observable<E> {
return CatchSequence(sources: InfiniteSequence(repeatedValue: self.asObservable()))
}
/**
Repeats the source observable sequence the specified number of times in case of an error or until it successfully terminates.
If you encounter an error and want it to retry once, then you must use `retry(2)`
- seealso: [retry operator on reactivex.io](http://reactivex.io/documentation/operators/retry.html)
- parameter maxAttemptCount: Maximum number of times to repeat the sequence.
- returns: An observable sequence producing the elements of the given sequence repeatedly until it terminates successfully.
*/
public func retry(_ maxAttemptCount: Int)
-> Observable<E> {
return CatchSequence(sources: repeatElement(self.asObservable(), count: maxAttemptCount))
}
/**
Repeats the source observable sequence on error when the notifier emits a next value.
If the source observable errors and the notifier completes, it will complete the source sequence.
- seealso: [retry operator on reactivex.io](http://reactivex.io/documentation/operators/retry.html)
- parameter notificationHandler: A handler that is passed an observable sequence of errors raised by the source observable and returns and observable that either continues, completes or errors. This behavior is then applied to the source observable.
- returns: An observable sequence producing the elements of the given sequence repeatedly until it terminates successfully or is notified to error or complete.
*/
public func retryWhen<TriggerObservable: ObservableType, Error: Swift.Error>(_ notificationHandler: @escaping (Observable<Error>) -> TriggerObservable)
-> Observable<E> {
return RetryWhenSequence(sources: InfiniteSequence(repeatedValue: self.asObservable()), notificationHandler: notificationHandler)
}
/**
Repeats the source observable sequence on error when the notifier emits a next value.
If the source observable errors and the notifier completes, it will complete the source sequence.
- seealso: [retry operator on reactivex.io](http://reactivex.io/documentation/operators/retry.html)
- parameter notificationHandler: A handler that is passed an observable sequence of errors raised by the source observable and returns and observable that either continues, completes or errors. This behavior is then applied to the source observable.
- returns: An observable sequence producing the elements of the given sequence repeatedly until it terminates successfully or is notified to error or complete.
*/
public func retryWhen<TriggerObservable: ObservableType>(_ notificationHandler: @escaping (Observable<Swift.Error>) -> TriggerObservable)
-> Observable<E> {
return RetryWhenSequence(sources: InfiniteSequence(repeatedValue: self.asObservable()), notificationHandler: notificationHandler)
}
}
// MARK: scan
extension ObservableType {
/**
Applies an accumulator function over an observable sequence and returns each intermediate result. The specified seed value is used as the initial accumulator value.
For aggregation behavior with no intermediate results, see `reduce`.
- seealso: [scan operator on reactivex.io](http://reactivex.io/documentation/operators/scan.html)
- parameter seed: The initial accumulator value.
- parameter accumulator: An accumulator function to be invoked on each element.
- returns: An observable sequence containing the accumulated values.
*/
public func scan<A>(_ seed: A, accumulator: @escaping (A, E) throws -> A)
-> Observable<A> {
return Scan(source: self.asObservable(), seed: seed, accumulator: accumulator)
}
}
// MARK: defaultIfEmpty
extension ObservableType {
/**
Emits elements from the source observable sequence, or a default element if the source observable sequence is empty.
- seealso: [DefaultIfEmpty operator on reactivex.io](http://reactivex.io/documentation/operators/defaultifempty.html)
- parameter default: Default element to be sent if the source does not emit any elements
- returns: An observable sequence which emits default element end completes in case the original sequence is empty
*/
public func ifEmpty(default: E) -> Observable<E> {
return DefaultIfEmpty(source: self.asObservable(), default: `default`)
}
}
extension ObservableType {
/**
Skips elements and completes (or errors) when the receiver completes (or errors). Equivalent to filter that always returns false.
- seealso: [ignoreElements operator on reactivex.io](http://reactivex.io/documentation/operators/ignoreelements.html)
- returns: An observable sequence that skips all elements of the source sequence.
*/
public func ignoreElements()
-> Observable<E> {
return filter { _ -> Bool in
return false
}
}
}
// MARK: materialize
extension ObservableType {
/**
Convert any Observable into an Observable of its events.
- seealso: [materialize operator on reactivex.io](http://reactivex.io/documentation/operators/materialize-dematerialize.html)
- returns: An observable sequence that wraps events in an Event<E>. The returned Observable never errors, but it does complete after observing all of the events of the underlying Observable.
*/
public func materialize() -> Observable<Event<E>> {
return Materialize(source: self.asObservable())
}
}
extension ObservableType where E: EventConvertible {
/**
Convert any previously materialized Observable into it's original form.
- seealso: [materialize operator on reactivex.io](http://reactivex.io/documentation/operators/materialize-dematerialize.html)
- returns: The dematerialized observable sequence.
*/
public func dematerialize() -> Observable<E.ElementType> {
return Dematerialize(source: self.asObservable())
}
}

320
RxSwift/Observables/Observable+StandardSequenceOperators.swift
View File

@ -1,320 +0,0 @@
//
// Observable+StandardSequenceOperators.swift
// RxSwift
//
// Created by Krunoslav Zaher on 2/17/15.
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
// MARK: filter aka where
extension ObservableType {
/**
Filters the elements of an observable sequence based on a predicate.
- seealso: [filter operator on reactivex.io](http://reactivex.io/documentation/operators/filter.html)
- parameter predicate: A function to test each source element for a condition.
- returns: An observable sequence that contains elements from the input sequence that satisfy the condition.
*/
public func filter(_ predicate: @escaping (E) throws -> Bool)
-> Observable<E> {
return Filter(source: asObservable(), predicate: predicate)
}
}
// MARK: takeWhile
extension ObservableType {
/**
Returns elements from an observable sequence as long as a specified condition is true.
- seealso: [takeWhile operator on reactivex.io](http://reactivex.io/documentation/operators/takewhile.html)
- parameter predicate: A function to test each element for a condition.
- returns: An observable sequence that contains the elements from the input sequence that occur before the element at which the test no longer passes.
*/
public func takeWhile(_ predicate: @escaping (E) throws -> Bool)
-> Observable<E> {
return TakeWhile(source: asObservable(), predicate: predicate)
}
/**
Returns elements from an observable sequence as long as a specified condition is true.
The element's index is used in the logic of the predicate function.
- seealso: [takeWhile operator on reactivex.io](http://reactivex.io/documentation/operators/takewhile.html)
- parameter predicate: A function to test each element for a condition; the second parameter of the function represents the index of the source element.
- returns: An observable sequence that contains the elements from the input sequence that occur before the element at which the test no longer passes.
*/
public func takeWhileWithIndex(_ predicate: @escaping (E, Int) throws -> Bool)
-> Observable<E> {
return TakeWhile(source: asObservable(), predicate: predicate)
}
}
// MARK: take
extension ObservableType {
/**
Returns a specified number of contiguous elements from the start of an observable sequence.
- seealso: [take operator on reactivex.io](http://reactivex.io/documentation/operators/take.html)
- parameter count: The number of elements to return.
- returns: An observable sequence that contains the specified number of elements from the start of the input sequence.
*/
public func take(_ count: Int)
-> Observable<E> {
if count == 0 {
return Observable.empty()
}
else {
return TakeCount(source: asObservable(), count: count)
}
}
}
// MARK: takeLast
extension ObservableType {
/**
Returns a specified number of contiguous elements from the end of an observable sequence.
This operator accumulates a buffer with a length enough to store elements count elements. Upon completion of the source sequence, this buffer is drained on the result sequence. This causes the elements to be delayed.
- seealso: [takeLast operator on reactivex.io](http://reactivex.io/documentation/operators/takelast.html)
- parameter count: Number of elements to take from the end of the source sequence.
- returns: An observable sequence containing the specified number of elements from the end of the source sequence.
*/
public func takeLast(_ count: Int)
-> Observable<E> {
return TakeLast(source: asObservable(), count: count)
}
}
// MARK: skip
extension ObservableType {
/**
Bypasses a specified number of elements in an observable sequence and then returns the remaining elements.
- seealso: [skip operator on reactivex.io](http://reactivex.io/documentation/operators/skip.html)
- parameter count: The number of elements to skip before returning the remaining elements.
- returns: An observable sequence that contains the elements that occur after the specified index in the input sequence.
*/
public func skip(_ count: Int)
-> Observable<E> {
return SkipCount(source: asObservable(), count: count)
}
}
// MARK: SkipWhile
extension ObservableType {
/**
Bypasses elements in an observable sequence as long as a specified condition is true and then returns the remaining elements.
- seealso: [skipWhile operator on reactivex.io](http://reactivex.io/documentation/operators/skipwhile.html)
- parameter predicate: A function to test each element for a condition.
- returns: An observable sequence that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate.
*/
public func skipWhile(_ predicate: @escaping (E) throws -> Bool) -> Observable<E> {
return SkipWhile(source: asObservable(), predicate: predicate)
}
/**
Bypasses elements in an observable sequence as long as a specified condition is true and then returns the remaining elements.
The element's index is used in the logic of the predicate function.
- seealso: [skipWhile operator on reactivex.io](http://reactivex.io/documentation/operators/skipwhile.html)
- parameter predicate: A function to test each element for a condition; the second parameter of the function represents the index of the source element.
- returns: An observable sequence that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate.
*/
public func skipWhileWithIndex(_ predicate: @escaping (E, Int) throws -> Bool) -> Observable<E> {
return SkipWhile(source: asObservable(), predicate: predicate)
}
}
// MARK: map aka select
extension ObservableType {
/**
Projects each element of an observable sequence into a new form.
- seealso: [map operator on reactivex.io](http://reactivex.io/documentation/operators/map.html)
- parameter transform: A transform function to apply to each source element.
- returns: An observable sequence whose elements are the result of invoking the transform function on each element of source.
*/
public func map<R>(_ transform: @escaping (E) throws -> R)
-> Observable<R> {
return self.asObservable().composeMap(transform)
}
/**
Projects each element of an observable sequence into a new form by incorporating the element's index.
- seealso: [map operator on reactivex.io](http://reactivex.io/documentation/operators/map.html)
- parameter selector: A transform function to apply to each source element; the second parameter of the function represents the index of the source element.
- returns: An observable sequence whose elements are the result of invoking the transform function on each element of source.
*/
public func mapWithIndex<R>(_ selector: @escaping (E, Int) throws -> R)
-> Observable<R> {
return MapWithIndex(source: asObservable(), selector: selector)
}
}
// MARK: flatMap
extension ObservableType {
/**
Projects each element of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence.
- seealso: [flatMap operator on reactivex.io](http://reactivex.io/documentation/operators/flatmap.html)
- parameter selector: A transform function to apply to each element.
- returns: An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence.
*/
public func flatMap<O: ObservableConvertibleType>(_ selector: @escaping (E) throws -> O)
-> Observable<O.E> {
return FlatMap(source: asObservable(), selector: selector)
}
/**
Projects each element of an observable sequence to an observable sequence by incorporating the element's index and merges the resulting observable sequences into one observable sequence.
- seealso: [flatMap operator on reactivex.io](http://reactivex.io/documentation/operators/flatmap.html)
- parameter selector: A transform function to apply to each element; the second parameter of the function represents the index of the source element.
- returns: An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence.
*/
public func flatMapWithIndex<O: ObservableConvertibleType>(_ selector: @escaping (E, Int) throws -> O)
-> Observable<O.E> {
return FlatMapWithIndex(source: asObservable(), selector: selector)
}
}
// MARK: flatMapFirst
extension ObservableType {
/**
Projects each element of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence.
If element is received while there is some projected observable sequence being merged it will simply be ignored.
- seealso: [flatMapFirst operator on reactivex.io](http://reactivex.io/documentation/operators/flatmap.html)
- parameter selector: A transform function to apply to element that was observed while no observable is executing in parallel.
- returns: An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence that was received while no other sequence was being calculated.
*/
public func flatMapFirst<O: ObservableConvertibleType>(_ selector: @escaping (E) throws -> O)
-> Observable<O.E> {
return FlatMapFirst(source: asObservable(), selector: selector)
}
}
// MARK: flatMapLatest
extension ObservableType {
/**
Projects each element of an observable sequence into a new sequence of observable sequences and then
transforms an observable sequence of observable sequences into an observable sequence producing values only from the most recent observable sequence.
It is a combination of `map` + `switchLatest` operator
- seealso: [flatMapLatest operator on reactivex.io](http://reactivex.io/documentation/operators/flatmap.html)
- parameter selector: A transform function to apply to each element.
- returns: An observable sequence whose elements are the result of invoking the transform function on each element of source producing an
Observable of Observable sequences and that at any point in time produces the elements of the most recent inner observable sequence that has been received.
*/
public func flatMapLatest<O: ObservableConvertibleType>(_ selector: @escaping (E) throws -> O)
-> Observable<O.E> {
return FlatMapLatest(source: asObservable(), selector: selector)
}
}
// MARK: elementAt
extension ObservableType {
/**
Returns a sequence emitting only element _n_ emitted by an Observable
- seealso: [elementAt operator on reactivex.io](http://reactivex.io/documentation/operators/elementat.html)
- parameter index: The index of the required element (starting from 0).
- returns: An observable sequence that emits the desired element as its own sole emission.
*/
public func elementAt(_ index: Int)
-> Observable<E> {
return ElementAt(source: asObservable(), index: index, throwOnEmpty: true)
}
}
// MARK: single
extension ObservableType {
/**
The single operator is similar to first, but throws a `RxError.noElements` or `RxError.moreThanOneElement`
if the source Observable does not emit exactly one element before successfully completing.
- seealso: [single operator on reactivex.io](http://reactivex.io/documentation/operators/first.html)
- returns: An observable sequence that emits a single element or throws an exception if more (or none) of them are emitted.
*/
public func single()
-> Observable<E> {
return SingleAsync(source: asObservable())
}
/**
The single operator is similar to first, but throws a `RxError.NoElements` or `RxError.MoreThanOneElement`
if the source Observable does not emit exactly one element before successfully completing.
- seealso: [single operator on reactivex.io](http://reactivex.io/documentation/operators/first.html)
- parameter predicate: A function to test each source element for a condition.
- returns: An observable sequence that emits a single element or throws an exception if more (or none) of them are emitted.
*/
public func single(_ predicate: @escaping (E) throws -> Bool)
-> Observable<E> {
return SingleAsync(source: asObservable(), predicate: predicate)
}
}
// MARK: groupBy
extension ObservableType {
/*
Groups the elements of an observable sequence according to a specified key selector function.
- seealso: [groupBy operator on reactivex.io](http://reactivex.io/documentation/operators/groupby.html)
- parameter keySelector: A function to extract the key for each element.
- returns: A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value.
*/
public func groupBy<K: Hashable>(keySelector: @escaping (E) throws -> K)
-> Observable<GroupedObservable<K,E>> {
return GroupBy(source: self.asObservable(), selector: keySelector)
}
}

258
RxSwift/Observables/Observable+Time.swift
View File

@ -1,258 +0,0 @@
//
// Observable+Time.swift
// RxSwift
//
// Created by Krunoslav Zaher on 3/22/15.
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
// MARK: throttle
extension ObservableType {
/**
Returns an Observable that emits the first and the latest item emitted by the source Observable during sequential time windows of a specified duration.
This operator makes sure that no two elements are emitted in less then dueTime.
- seealso: [debounce operator on reactivex.io](http://reactivex.io/documentation/operators/debounce.html)
- parameter dueTime: Throttling duration for each element.
- parameter latest: Should latest element received in a dueTime wide time window since last element emission be emitted.
- parameter scheduler: Scheduler to run the throttle timers on.
- returns: The throttled sequence.
*/
public func throttle(_ dueTime: RxTimeInterval, latest: Bool = true, scheduler: SchedulerType)
-> Observable<E> {
return Throttle(source: self.asObservable(), dueTime: dueTime, latest: latest, scheduler: scheduler)
}
/**
Ignores elements from an observable sequence which are followed by another element within a specified relative time duration, using the specified scheduler to run throttling timers.
- seealso: [debounce operator on reactivex.io](http://reactivex.io/documentation/operators/debounce.html)
- parameter dueTime: Throttling duration for each element.
- parameter scheduler: Scheduler to run the throttle timers on.
- returns: The throttled sequence.
*/
public func debounce(_ dueTime: RxTimeInterval, scheduler: SchedulerType)
-> Observable<E> {
return Debounce(source: self.asObservable(), dueTime: dueTime, scheduler: scheduler)
}
}
// MARK: sample
extension ObservableType {
/**
Samples the source observable sequence using a sampler observable sequence producing sampling ticks.
Upon each sampling tick, the latest element (if any) in the source sequence during the last sampling interval is sent to the resulting sequence.
**In case there were no new elements between sampler ticks, no element is sent to the resulting sequence.**
- seealso: [sample operator on reactivex.io](http://reactivex.io/documentation/operators/sample.html)
- parameter sampler: Sampling tick sequence.
- returns: Sampled observable sequence.
*/
public func sample<O: ObservableType>(_ sampler: O)
-> Observable<E> {
return Sample(source: self.asObservable(), sampler: sampler.asObservable())
}
}
extension Observable where Element : SignedInteger {
/**
Returns an observable sequence that produces a value after each period, using the specified scheduler to run timers and to send out observer messages.
- seealso: [interval operator on reactivex.io](http://reactivex.io/documentation/operators/interval.html)
- parameter period: Period for producing the values in the resulting sequence.
- parameter scheduler: Scheduler to run the timer on.
- returns: An observable sequence that produces a value after each period.
*/
public static func interval(_ period: RxTimeInterval, scheduler: SchedulerType)
-> Observable<E> {
return Timer(dueTime: period,
period: period,
scheduler: scheduler
)
}
}
// MARK: timer
extension Observable where Element: SignedInteger {
/**
Returns an observable sequence that periodically produces a value after the specified initial relative due time has elapsed, using the specified scheduler to run timers.
- seealso: [timer operator on reactivex.io](http://reactivex.io/documentation/operators/timer.html)
- parameter dueTime: Relative time at which to produce the first value.
- parameter period: Period to produce subsequent values.
- parameter scheduler: Scheduler to run timers on.
- returns: An observable sequence that produces a value after due time has elapsed and then each period.
*/
public static func timer(_ dueTime: RxTimeInterval, period: RxTimeInterval? = nil, scheduler: SchedulerType)
-> Observable<E> {
return Timer(
dueTime: dueTime,
period: period,
scheduler: scheduler
)
}
}
// MARK: take
extension ObservableType {
/**
Takes elements for the specified duration from the start of the observable source sequence, using the specified scheduler to run timers.
- seealso: [take operator on reactivex.io](http://reactivex.io/documentation/operators/take.html)
- parameter duration: Duration for taking elements from the start of the sequence.
- parameter scheduler: Scheduler to run the timer on.
- returns: An observable sequence with the elements taken during the specified duration from the start of the source sequence.
*/
public func take(_ duration: RxTimeInterval, scheduler: SchedulerType)
-> Observable<E> {
return TakeTime(source: self.asObservable(), duration: duration, scheduler: scheduler)
}
}
// MARK: skip
extension ObservableType {
/**
Skips elements for the specified duration from the start of the observable source sequence, using the specified scheduler to run timers.
- seealso: [skip operator on reactivex.io](http://reactivex.io/documentation/operators/skip.html)
- parameter duration: Duration for skipping elements from the start of the sequence.
- parameter scheduler: Scheduler to run the timer on.
- returns: An observable sequence with the elements skipped during the specified duration from the start of the source sequence.
*/
public func skip(_ duration: RxTimeInterval, scheduler: SchedulerType)
-> Observable<E> {
return SkipTime(source: self.asObservable(), duration: duration, scheduler: scheduler)
}
}
// MARK: delaySubscription
extension ObservableType {
/**
Time shifts the observable sequence by delaying the subscription with the specified relative time duration, using the specified scheduler to run timers.
- seealso: [delay operator on reactivex.io](http://reactivex.io/documentation/operators/delay.html)
- parameter dueTime: Relative time shift of the subscription.
- parameter scheduler: Scheduler to run the subscription delay timer on.
- returns: Time-shifted sequence.
*/
public func delaySubscription(_ dueTime: RxTimeInterval, scheduler: SchedulerType)
-> Observable<E> {
return DelaySubscription(source: self.asObservable(), dueTime: dueTime, scheduler: scheduler)
}
}
// MARK: buffer
extension ObservableType {
/**
Projects each element of an observable sequence into a buffer that's sent out when either it's full or a given amount of time has elapsed, using the specified scheduler to run timers.
A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first.
- seealso: [buffer operator on reactivex.io](http://reactivex.io/documentation/operators/buffer.html)
- parameter timeSpan: Maximum time length of a buffer.
- parameter count: Maximum element count of a buffer.
- parameter scheduler: Scheduler to run buffering timers on.
- returns: An observable sequence of buffers.
*/
public func buffer(timeSpan: RxTimeInterval, count: Int, scheduler: SchedulerType)
-> Observable<[E]> {
return BufferTimeCount(source: self.asObservable(), timeSpan: timeSpan, count: count, scheduler: scheduler)
}
}
// MARK: window
extension ObservableType {
/**
Projects each element of an observable sequence into a window that is completed when either it’s full or a given amount of time has elapsed.
- seealso: [window operator on reactivex.io](http://reactivex.io/documentation/operators/window.html)
- parameter timeSpan: Maximum time length of a window.
- parameter count: Maximum element count of a window.
- parameter scheduler: Scheduler to run windowing timers on.
- returns: An observable sequence of windows (instances of `Observable`).
*/
public func window(timeSpan: RxTimeInterval, count: Int, scheduler: SchedulerType)
-> Observable<Observable<E>> {
return WindowTimeCount(source: self.asObservable(), timeSpan: timeSpan, count: count, scheduler: scheduler)
}
}
// MARK: timeout
extension ObservableType {
/**
Applies a timeout policy for each element in the observable sequence. If the next element isn't received within the specified timeout duration starting from its predecessor, a TimeoutError is propagated to the observer.
- seealso: [timeout operator on reactivex.io](http://reactivex.io/documentation/operators/timeout.html)
- parameter dueTime: Maximum duration between values before a timeout occurs.
- parameter scheduler: Scheduler to run the timeout timer on.
- returns: An observable sequence with a `RxError.timeout` in case of a timeout.
*/
public func timeout(_ dueTime: RxTimeInterval, scheduler: SchedulerType)
-> Observable<E> {
return Timeout(source: self.asObservable(), dueTime: dueTime, other: Observable.error(RxError.timeout), scheduler: scheduler)
}
/**
Applies a timeout policy for each element in the observable sequence, using the specified scheduler to run timeout timers. If the next element isn't received within the specified timeout duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on.
- seealso: [timeout operator on reactivex.io](http://reactivex.io/documentation/operators/timeout.html)
- parameter dueTime: Maximum duration between values before a timeout occurs.
- parameter other: Sequence to return in case of a timeout.
- parameter scheduler: Scheduler to run the timeout timer on.
- returns: The source sequence switching to the other sequence in case of a timeout.
*/
public func timeout<O: ObservableConvertibleType>(_ dueTime: RxTimeInterval, other: O, scheduler: SchedulerType)
-> Observable<E> where E == O.E {
return Timeout(source: self.asObservable(), dueTime: dueTime, other: other.asObservable(), scheduler: scheduler)
}
}
// MARK: delay
extension ObservableType {
/**
Returns an observable sequence by the source observable sequence shifted forward in time by a specified delay. Error events from the source observable sequence are not delayed.
- seealso: [delay operator on reactivex.io](http://reactivex.io/documentation/operators/delay.html)
- parameter dueTime: Relative time shift of the source by.
- parameter scheduler: Scheduler to run the subscription delay timer on.
- returns: the source Observable shifted in time by the specified delay.
*/
public func delay(_ dueTime: RxTimeInterval, scheduler: SchedulerType)
-> Observable<E> {
return Delay(source: self.asObservable(), dueTime: dueTime, scheduler: scheduler)
}
}

1
Sources/RxSwift/AnonymousObservable.swift
View File

@ -1 +0,0 @@
../../RxSwift/Observables/Implementations/AnonymousObservable.swift

1
Sources/RxSwift/Create.swift Symbolic link
View File

@ -0,0 +1 @@
../../RxSwift/Observables/Implementations/Create.swift

1
Sources/RxSwift/Observable+Aggregate.swift
View File

@ -1 +0,0 @@
../../RxSwift/Observables/Observable+Aggregate.swift

1
Sources/RxSwift/Observable+Binding.swift
View File

@ -1 +0,0 @@
../../RxSwift/Observables/Observable+Binding.swift

1
Sources/RxSwift/Observable+Concurrency.swift
View File

@ -1 +0,0 @@
../../RxSwift/Observables/Observable+Concurrency.swift

1
Sources/RxSwift/Observable+Creation.swift
View File

@ -1 +0,0 @@
../../RxSwift/Observables/Observable+Creation.swift

1
Sources/RxSwift/Observable+Debug.swift
View File

@ -1 +0,0 @@
../../RxSwift/Observables/Observable+Debug.swift

1
Sources/RxSwift/Observable+Multiple.swift
View File

@ -1 +0,0 @@
../../RxSwift/Observables/Observable+Multiple.swift

1
Sources/RxSwift/Observable+Single.swift
View File

@ -1 +0,0 @@
../../RxSwift/Observables/Observable+Single.swift

1
Sources/RxSwift/Observable+StandardSequenceOperators.swift
View File

@ -1 +0,0 @@
../../RxSwift/Observables/Observable+StandardSequenceOperators.swift

1
Sources/RxSwift/Observable+Time.swift
View File

@ -1 +0,0 @@
../../RxSwift/Observables/Observable+Time.swift

1
Sources/RxSwift/ObserveOnSerialDispatchQueue.swift
View File

@ -1 +0,0 @@
../../RxSwift/Observables/Implementations/ObserveOnSerialDispatchQueue.swift

1
Sources/RxSwift/RefCount.swift
View File

@ -1 +0,0 @@
../../RxSwift/Observables/Implementations/RefCount.swift