initial

Pods/RxRelay/RxRelay/BehaviorRelay.swift

@@ -0,0 +1,42 @@
+//
+//  BehaviorRelay.swift
+//  RxRelay
+//
+//  Created by Krunoslav Zaher on 10/7/17.
+//  Copyright © 2017 Krunoslav Zaher. All rights reserved.
+//
+
+import RxSwift
+
+/// BehaviorRelay is a wrapper for `BehaviorSubject`.
+///
+/// Unlike `BehaviorSubject` it can't terminate with error or completed.
+public final class BehaviorRelay<Element>: ObservableType {
+    private let subject: BehaviorSubject<Element>
+
+    /// Accepts `event` and emits it to subscribers
+    public func accept(_ event: Element) {
+        self.subject.onNext(event)
+    }
+
+    /// Current value of behavior subject
+    public var value: Element {
+        // this try! is ok because subject can't error out or be disposed
+        return try! self.subject.value()
+    }
+
+    /// Initializes behavior relay with initial value.
+    public init(value: Element) {
+        self.subject = BehaviorSubject(value: value)
+    }
+
+    /// Subscribes observer
+    public func subscribe<Observer: ObserverType>(_ observer: Observer) -> Disposable where Observer.Element == Element {
+        self.subject.subscribe(observer)
+    }
+
+    /// - returns: Canonical interface for push style sequence
+    public func asObservable() -> Observable<Element> {
+        self.subject.asObservable()
+    }
+}

Pods/RxRelay/RxRelay/Observable+Bind.swift

@@ -0,0 +1,149 @@
+//
+//  Observable+Bind.swift
+//  RxRelay
+//
+//  Created by Shai Mishali on 09/04/2019.
+//  Copyright © 2019 Krunoslav Zaher. All rights reserved.
+//
+
+import RxSwift
+
+extension ObservableType {
+    /**
+     Creates new subscription and sends elements to publish relay(s).
+     In case error occurs in debug mode, `fatalError` will be raised.
+     In case error occurs in release mode, `error` will be logged.
+     - parameter relays: Target publish relays for sequence elements.
+     - returns: Disposable object that can be used to unsubscribe the observer.
+     */
+    public func bind(to relays: PublishRelay<Element>...) -> Disposable {
+        bind(to: relays)
+    }
+
+    /**
+     Creates new subscription and sends elements to publish relay(s).
+
+     In case error occurs in debug mode, `fatalError` will be raised.
+     In case error occurs in release mode, `error` will be logged.
+
+     - parameter relays: Target publish relays for sequence elements.
+     - returns: Disposable object that can be used to unsubscribe the observer.
+     */
+    public func bind(to relays: PublishRelay<Element?>...) -> Disposable {
+        self.map { $0 as Element? }.bind(to: relays)
+    }
+
+    /**
+     Creates new subscription and sends elements to publish relay(s).
+     In case error occurs in debug mode, `fatalError` will be raised.
+     In case error occurs in release mode, `error` will be logged.
+     - parameter relays: Target publish relays for sequence elements.
+     - returns: Disposable object that can be used to unsubscribe the observer.
+     */
+    private func bind(to relays: [PublishRelay<Element>]) -> Disposable {
+        subscribe { e in
+            switch e {
+            case let .next(element):
+                relays.forEach {
+                    $0.accept(element)
+                }
+            case let .error(error):
+                rxFatalErrorInDebug("Binding error to publish relay: \(error)")
+            case .completed:
+                break
+            }
+        }
+    }
+
+    /**
+     Creates new subscription and sends elements to behavior relay(s).
+     In case error occurs in debug mode, `fatalError` will be raised.
+     In case error occurs in release mode, `error` will be logged.
+     - parameter relays: Target behavior relay for sequence elements.
+     - returns: Disposable object that can be used to unsubscribe the observer.
+     */
+    public func bind(to relays: BehaviorRelay<Element>...) -> Disposable {
+        self.bind(to: relays)
+    }
+
+    /**
+     Creates new subscription and sends elements to behavior relay(s).
+
+     In case error occurs in debug mode, `fatalError` will be raised.
+     In case error occurs in release mode, `error` will be logged.
+
+     - parameter relays: Target behavior relay for sequence elements.
+     - returns: Disposable object that can be used to unsubscribe the observer.
+     */
+    public func bind(to relays: BehaviorRelay<Element?>...) -> Disposable {
+        self.map { $0 as Element? }.bind(to: relays)
+    }
+
+    /**
+     Creates new subscription and sends elements to behavior relay(s).
+     In case error occurs in debug mode, `fatalError` will be raised.
+     In case error occurs in release mode, `error` will be logged.
+     - parameter relays: Target behavior relay for sequence elements.
+     - returns: Disposable object that can be used to unsubscribe the observer.
+     */
+    private func bind(to relays: [BehaviorRelay<Element>]) -> Disposable {
+        subscribe { e in
+            switch e {
+            case let .next(element):
+                relays.forEach {
+                    $0.accept(element)
+                }
+            case let .error(error):
+                rxFatalErrorInDebug("Binding error to behavior relay: \(error)")
+            case .completed:
+                break
+            }
+        }
+    }
+
+    /**
+     Creates new subscription and sends elements to replay relay(s).
+     In case error occurs in debug mode, `fatalError` will be raised.
+     In case error occurs in release mode, `error` will be logged.
+     - parameter relays: Target replay relay for sequence elements.
+     - returns: Disposable object that can be used to unsubscribe the observer.
+     */
+    public func bind(to relays: ReplayRelay<Element>...) -> Disposable {
+        self.bind(to: relays)
+    }
+
+    /**
+     Creates new subscription and sends elements to replay relay(s).
+
+     In case error occurs in debug mode, `fatalError` will be raised.
+     In case error occurs in release mode, `error` will be logged.
+
+     - parameter relays: Target replay relay for sequence elements.
+     - returns: Disposable object that can be used to unsubscribe the observer.
+     */
+    public func bind(to relays: ReplayRelay<Element?>...) -> Disposable {
+        self.map { $0 as Element? }.bind(to: relays)
+    }
+
+    /**
+     Creates new subscription and sends elements to replay relay(s).
+     In case error occurs in debug mode, `fatalError` will be raised.
+     In case error occurs in release mode, `error` will be logged.
+     - parameter relays: Target replay relay for sequence elements.
+     - returns: Disposable object that can be used to unsubscribe the observer.
+     */
+    private func bind(to relays: [ReplayRelay<Element>]) -> Disposable {
+        subscribe { e in
+            switch e {
+            case let .next(element):
+                relays.forEach {
+                    $0.accept(element)
+                }
+            case let .error(error):
+                rxFatalErrorInDebug("Binding error to behavior relay: \(error)")
+            case .completed:
+                break
+            }
+        }
+    }
+}

Pods/RxRelay/RxRelay/PublishRelay.swift

@@ -0,0 +1,36 @@
+//
+//  PublishRelay.swift
+//  RxRelay
+//
+//  Created by Krunoslav Zaher on 3/28/15.
+//  Copyright © 2017 Krunoslav Zaher. All rights reserved.
+//
+
+import RxSwift
+
+/// PublishRelay is a wrapper for `PublishSubject`.
+///
+/// Unlike `PublishSubject` it can't terminate with error or completed.
+public final class PublishRelay<Element>: ObservableType {
+    private let subject: PublishSubject<Element>
+    
+    // Accepts `event` and emits it to subscribers
+    public func accept(_ event: Element) {
+        self.subject.onNext(event)
+    }
+    
+    /// Initializes with internal empty subject.
+    public init() {
+        self.subject = PublishSubject()
+    }
+
+    /// Subscribes observer
+    public func subscribe<Observer: ObserverType>(_ observer: Observer) -> Disposable where Observer.Element == Element {
+        self.subject.subscribe(observer)
+    }
+    
+    /// - returns: Canonical interface for push style sequence
+    public func asObservable() -> Observable<Element> {
+        self.subject.asObservable()
+    }
+}

Pods/RxRelay/RxRelay/ReplayRelay.swift

@@ -0,0 +1,50 @@
+//
+//  ReplayRelay.swift
+//  RxRelay
+//
+//  Created by Zsolt Kovacs on 12/22/19.
+//  Copyright © 2019 Krunoslav Zaher. All rights reserved.
+//
+
+import RxSwift
+
+/// ReplayRelay is a wrapper for `ReplaySubject`.
+///
+/// Unlike `ReplaySubject` it can't terminate with an error or complete.
+public final class ReplayRelay<Element>: ObservableType {
+    private let subject: ReplaySubject<Element>
+
+    // Accepts `event` and emits it to subscribers
+    public func accept(_ event: Element) {
+        self.subject.onNext(event)
+    }
+
+    private init(subject: ReplaySubject<Element>) {
+        self.subject = subject
+    }
+
+    /// Creates new instance of `ReplayRelay` that replays at most `bufferSize` last elements sent to it.
+    ///
+    /// - parameter bufferSize: Maximal number of elements to replay to observers after subscription.
+    /// - returns: New instance of replay relay.
+    public static func create(bufferSize: Int) -> ReplayRelay<Element> {
+        ReplayRelay(subject: ReplaySubject.create(bufferSize: bufferSize))
+    }
+
+    /// Creates a new instance of `ReplayRelay` that buffers all the sent to it.
+    /// To avoid filling up memory, developer needs to make sure that the use case will only ever store a 'reasonable'
+    /// number of elements.
+    public static func createUnbound() -> ReplayRelay<Element> {
+        ReplayRelay(subject: ReplaySubject.createUnbounded())
+    }
+
+    /// Subscribes observer
+    public func subscribe<Observer: ObserverType>(_ observer: Observer) -> Disposable where Observer.Element == Element {
+        self.subject.subscribe(observer)
+    }
+
+    /// - returns: Canonical interface for push style sequence
+    public func asObservable() -> Observable<Element> {
+        self.subject.asObserver()
+    }
+}

Pods/RxRelay/RxRelay/Utils.swift

@@ -0,0 +1,17 @@
+//
+//  Utils.swift
+//  RxRelay
+//
+//  Created by Shai Mishali on 09/04/2019.
+//  Copyright © 2019 Krunoslav Zaher. All rights reserved.
+//
+
+import Foundation
+
+func rxFatalErrorInDebug(_ lastMessage: @autoclosure () -> String, file: StaticString = #file, line: UInt = #line) {
+    #if DEBUG
+    fatalError(lastMessage(), file: file, line: line)
+    #else
+    print("\(file):\(line): \(lastMessage())")
+    #endif
+}