0001    //
0002    //  Signal.swift
0003    //  Signals
0004    //
0005    //  Created by Tuomas Artman on 8/16/2014.
0006    //  Copyright (c) 2014 Tuomas Artman. All rights reserved.
0007    //
0008    
0009    import Foundation
0010    
0011    /// Create instances of Signal and assign them to public constants on your class for each event type that can
0012    /// be observed by listeners.
0013    public class Signal
Signal.swift:248
public func =><T> (signal: Signal<T>, data: T) -> Void {
<T
Signal.swift:19
    public var lastDataFired: T? = nil
Signal.swift:37
    private var signalListeners = [SignalListener<T>]()
Signal.swift:57
    public func listen(listener: AnyObject, callback: (T) -> Void) -> SignalListener<T> {
Signal.swift:57
    public func listen(listener: AnyObject, callback: (T) -> Void) -> SignalListener<T> {
Signal.swift:59
        let signalListener = SignalListener<T>(listener: listener, callback: callback);
Signal.swift:68
    public func listenOnce(listener: AnyObject, callback: (T) -> Void) -> SignalListener<T> {
Signal.swift:68
    public func listenOnce(listener: AnyObject, callback: (T) -> Void) -> SignalListener<T> {
Signal.swift:79
    public func listenPast(listener: AnyObject, callback: (T) -> Void) -> SignalListener<T> {
Signal.swift:79
    public func listenPast(listener: AnyObject, callback: (T) -> Void) -> SignalListener<T> {
Signal.swift:93
    public func listenPastOnce(listener: AnyObject, callback: (T) -> Void) -> SignalListener<T> {
Signal.swift:93
    public func listenPastOnce(listener: AnyObject, callback: (T) -> Void) -> SignalListener<T> {
Signal.swift:107
    public func fire(data: T) {
> {
0014    
0015        /// The number of times the signal has fired.
0016        public var fireCount
Signal.swift:34
        fireCount = 0
Signal.swift:81
        if fireCount > 0 {
Signal.swift:95
        if fireCount > 0 {
Signal.swift:108
        fireCount += 1
: Int = 0
0017    
0018        /// The last data that the signal was fired with.
0019        public var lastDataFired
Signal.swift:82
            signalListener.callback(lastDataFired!)
Signal.swift:96
            signalListener.callback(lastDataFired!)
Signal.swift:109
        lastDataFired = data
: T? = nil
0020    
0021        /// All the listeners listening to the Signal.
0022        public var listeners:[AnyObject] {
0023            get {
0024                return signalListeners.filter {
0025                    return $0.listener != nil
0026                }.map {
0027                    (signal) -> AnyObject in
0028                    return signal.listener!
0029                }
0030            }
0031        }
0032    
0033        public init() {
0034            fireCount = 0
0035        }
0036    
0037        private var signalListeners
Signal.swift:24
            return signalListeners.filter {
Signal.swift:41
        for signalListener in signalListeners {
Signal.swift:47
            signalListeners = signalListeners.filter {
Signal.swift:47
            signalListeners = signalListeners.filter {
Signal.swift:60
        signalListeners.append(signalListener)
Signal.swift:112
        for signalListener in signalListeners {
Signal.swift:123
        signalListeners = signalListeners.filter {
Signal.swift:123
        signalListeners = signalListeners.filter {
Signal.swift:133
        signalListeners.removeAll(keepCapacity: false)
 = [SignalListener<T>]()
0038    
0039        private func dumpCancelledListeners
Signal.swift:58
        dumpCancelledListeners()
Signal.swift:110
        dumpCancelledListeners()
() {
0040            var removeListeners = false
0041            for signalListener in signalListeners {
0042                if signalListener.listener == nil {
0043                    removeListeners = true
0044                }
0045            }
0046            if removeListeners {
0047                signalListeners = signalListeners.filter {
0048                    return $0.listener != nil
0049                }
0050            }
0051        }
0052    
0053        /// Attaches a listener to the signal
0054        ///
0055        /// - parameter listener: The listener object. Sould the listener be deallocated, its associated callback is automatically removed.
0056        /// - parameter callback: The closure to invoke whenever the signal fires.
0057        public func listen
Signal.swift:69
        let signalListener = self.listen(listener, callback: callback)
Signal.swift:80
        let signalListener = self.listen(listener, callback: callback)
Signal.swift:94
        let signalListener = self.listen(listener, callback: callback)
(listener: AnyObject, callback: (T) -> Void) -> SignalListener<T> {
0058            dumpCancelledListeners()
0059            let signalListener = SignalListener<T>(listener: listener, callback: callback);
0060            signalListeners.append(signalListener)
0061            return signalListener
0062        }
0063    
0064        /// Attaches a listener to the signal that is removed after the signal has fired once
0065        ///
0066        /// - parameter listener: The listener object. Sould the listener be deallocated, its associated callback is automatically removed.
0067        /// - parameter callback: The closure to invoke when the signal fires for the first time.
0068        public func listenOnce(listener: AnyObject, callback: (T) -> Void) -> SignalListener<T> {
0069            let signalListener = self.listen(listener, callback: callback)
0070            signalListener.once = true
0071            return signalListener
0072        }
0073    
0074        /// Attaches a listener to the signal and invokes the callback immediately with the last data fired by the signal
0075        /// if it has fired at least once.
0076        ///
0077        /// - parameter listener: The listener object. Sould the listener be deallocated, its associated callback is automatically removed.
0078        /// - parameter callback: The closure to invoke whenever the signal fires.
0079        public func listenPast(listener: AnyObject, callback: (T) -> Void) -> SignalListener<T> {
0080            let signalListener = self.listen(listener, callback: callback)
0081            if fireCount > 0 {
0082                signalListener.callback(lastDataFired!)
0083            }
0084            return signalListener
0085        }
0086    
0087        /// Attaches a listener to the signal and invokes the callback immediately with the last data fired by the signal
0088        /// if it has fired at least once. If it has not been fired yet, it will continue listening until it fires for the
0089        /// first time
0090        ///
0091        /// - parameter listener: The listener object. Sould the listener be deallocated, its associated callback is automatically removed.
0092        /// - parameter callback: The closure to invoke whenever the signal fires.
0093        public func listenPastOnce(listener: AnyObject, callback: (T) -> Void) -> SignalListener<T> {
0094            let signalListener = self.listen(listener, callback: callback)
0095            if fireCount > 0 {
0096                signalListener.callback(lastDataFired!)
0097                signalListener.cancel()
0098            } else {
0099                signalListener.once = true
0100            }
0101            return signalListener
0102        }
0103    
0104        /// Fires the singal.
0105        ///
0106        /// - parameter data: The data to fire the signal with.
0107        public func fire
Signal.swift:249
    signal.fire(data)
(data: T) {
0108            fireCount += 1
0109            lastDataFired = data
0110            dumpCancelledListeners()
0111    
0112            for signalListener in signalListeners {
0113                if signalListener.filter == nil || signalListener.filter!(data) == true {
0114                    signalListener.dispatch(data)
0115                }
0116            }
0117        }
0118    
0119        /// Removes an object as a listener of the Signal.
0120        ///
0121        /// - parameter listener: The listener to remove.
0122        public func removeListener(listener: AnyObject) {
0123            signalListeners = signalListeners.filter {
0124                if let definiteListener:AnyObject = $0.listener {
0125                    return definiteListener !== listener
0126                }
0127                return false
0128            }
0129        }
0130    
0131        /// Removes all listeners from the Signal
0132        public func removeAllListeners() {
0133            signalListeners.removeAll(keepCapacity: false)
0134        }
0135    }
0136    
0137    /// A SignalLister represenents an instance and its association with a Signal.
0138    public class SignalListener
Signal.swift:37
    private var signalListeners = [SignalListener<T>]()
Signal.swift:57
    public func listen(listener: AnyObject, callback: (T) -> Void) -> SignalListener<T> {
Signal.swift:59
        let signalListener = SignalListener<T>(listener: listener, callback: callback);
Signal.swift:68
    public func listenOnce(listener: AnyObject, callback: (T) -> Void) -> SignalListener<T> {
Signal.swift:79
    public func listenPast(listener: AnyObject, callback: (T) -> Void) -> SignalListener<T> {
Signal.swift:93
    public func listenPastOnce(listener: AnyObject, callback: (T) -> Void) -> SignalListener<T> {
Signal.swift:213
    public func filter(filter: (T) -> Bool) -> SignalListener {
Signal.swift:223
    public func queueAndDelayBy(delay: NSTimeInterval) -> SignalListener {
Signal.swift:234
    public func dispatchOnQueue(queue: dispatch_queue_t) -> SignalListener {
<T
Signal.swift:150
    private var queuedData: T?
Signal.swift:151
    private var filter: ((T) -> Bool)?
Signal.swift:152
    private var callback: (T) -> Void
Signal.swift:154
    private init (listener: AnyObject, callback: (T) -> Void) {
Signal.swift:159
    private func dispatch(data: T) -> Bool {
Signal.swift:213
    public func filter(filter: (T) -> Bool) -> SignalListener {
> {
0139    
0140        // The listener
0141        weak public var listener
Signal.swift:25
                return $0.listener != nil
Signal.swift:28
                return signal.listener!
Signal.swift:42
            if signalListener.listener == nil {
Signal.swift:48
                return $0.listener != nil
Signal.swift:124
            if let definiteListener:AnyObject = $0.listener {
Signal.swift:155
        self.listener = listener
Signal.swift:160
        guard listener != nil else {
Signal.swift:165
            listener = nil
Signal.swift:182
                            if definiteSelf.listener != nil {
Signal.swift:201
        return listener != nil
Signal.swift:242
        self.listener = nil
: AnyObject?
0142    
0143        /// Whether the listener should be removed once it observes the Signal firing once
0144        public var once
Signal.swift:70
        signalListener.once = true
Signal.swift:99
            signalListener.once = true
Signal.swift:164
        if once {
 = false
0145    
0146    #if os(OSX) || os(iOS) || os(watchOS) || os(tvOS)
0147        private var dispatchQueue
Signal.swift:176
                let dispatchQueue = self.dispatchQueue == nil ? dispatch_get_main_queue() : self.dispatchQueue
Signal.swift:176
                let dispatchQueue = self.dispatchQueue == nil ? dispatch_get_main_queue() : self.dispatchQueue
Signal.swift:189
            if let queue = self.dispatchQueue {
Signal.swift:235
        self.dispatchQueue = queue
: dispatch_queue_t?
0148        private var delay
Signal.swift:169
        if delay != nil {
Signal.swift:177
                dispatch_after(dispatch_time(DISPATCH_TIME_NOW, Int64(delay! * Double(NSEC_PER_SEC))),
Signal.swift:224
        self.delay = delay
: NSTimeInterval?
0149    #endif
0150        private var queuedData
Signal.swift:170
            if queuedData != nil {
Signal.swift:172
                queuedData = data
Signal.swift:175
                queuedData = data
Signal.swift:180
                            let data = definiteSelf.queuedData!
Signal.swift:181
                            definiteSelf.queuedData = nil
: T?
0151        private var filter
Signal.swift:113
            if signalListener.filter == nil || signalListener.filter!(data) == true {
Signal.swift:113
            if signalListener.filter == nil || signalListener.filter!(data) == true {
Signal.swift:214
        self.filter = filter
: ((T) -> Bool)?
0152        private var callback
Signal.swift:82
            signalListener.callback(lastDataFired!)
Signal.swift:96
            signalListener.callback(lastDataFired!)
Signal.swift:156
        self.callback = callback
Signal.swift:183
                                definiteSelf.callback(data)
Signal.swift:191
                    self.callback(data)
Signal.swift:194
                callback(data)
: (T) -> Void
0153    
0154        private init (listener: AnyObject, callback: (T) -> Void) {
0155            self.listener = listener
0156            self.callback = callback
0157        }
0158    
0159        private func dispatch
Signal.swift:114
                signalListener.dispatch(data)
(data: T) -> Bool {
0160            guard listener != nil else {
0161                return false
0162            }
0163    
0164            if once {
0165                listener = nil
0166            }
0167    
0168    #if os(OSX) || os(iOS) || os(watchOS) || os(tvOS)
0169            if delay != nil {
0170                if queuedData != nil {
0171                    // Already queueing
0172                    queuedData = data
0173                } else {
0174                    // Set up queue
0175                    queuedData = data
0176                    let dispatchQueue = self.dispatchQueue == nil ? dispatch_get_main_queue() : self.dispatchQueue
0177                    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, Int64(delay! * Double(NSEC_PER_SEC))),
0178                        dispatchQueue) { [weak self] () -> Void in
0179                            if let definiteSelf = self {
0180                                let data = definiteSelf.queuedData!
0181                                definiteSelf.queuedData = nil
0182                                if definiteSelf.listener != nil {
0183                                    definiteSelf.callback(data)
0184                                }
0185                            }
0186                    }
0187                }
0188            } else {
0189                if let queue = self.dispatchQueue {
0190                    dispatch_async(queue) {
0191                        self.callback(data)
0192                    }
0193                } else {
0194                    callback(data)
0195                }
0196            }
0197    #else
0198            callback(data)
0199    #endif
0200    
0201            return listener != nil
0202        }
0203    
0204        /// Assigns a filter to the SignalListener. This lets you define conditions under which a listener should actually
0205        /// receive the firing of a Singal. The closure that is passed an argument can decide whether the firing of a Signal
0206        /// should actually be dispatched to its listener depending on the data fired.
0207        ///
0208        /// If the closeure returns true, the listener is informed of the fire. The default implementation always
0209        /// returns true.
0210        ///
0211        /// - parameter filter: A closure that can decide whether the Signal fire should be dispatched to its listener.
0212        /// - returns: Returns self so you can chain calls.
0213        public func filter(filter: (T) -> Bool) -> SignalListener {
0214            self.filter = filter
0215            return self
0216        }
0217    
0218    #if os(OSX) || os(iOS) || os(watchOS) || os(tvOS)
0219        /// Tells the listener to queue up all signal fires until the elapsed time has passed and only once dispatch the last received
0220        /// data. A delay of 0 will wait until the next runloop to dispatch the signal fire to the listener.
0221        /// - parameter delay: The number of seconds to delay dispatch
0222        /// - returns: Returns self so you can chain calls.
0223        public func queueAndDelayBy(delay: NSTimeInterval) -> SignalListener {
0224            self.delay = delay
0225            return self
0226        }
0227    
0228        /// Assigns a dispatch queue to the SignalListener. The queue is used for scheduling the listener calls. If not nil,
0229        /// the callback is fired asynchronously on the specified queue. Otherwise, the block is run synchronously on the
0230        /// posting thread (default behaviour).
0231        ///
0232        /// - parameter queue: A queue for performing the listener's calls.
0233        /// - returns: Returns self so you can chain calls.
0234        public func dispatchOnQueue(queue: dispatch_queue_t) -> SignalListener {
0235            self.dispatchQueue = queue
0236            return self
0237        }
0238    #endif
0239    
0240        /// Cancels the listener. This will detach the listening object from the Signal.
0241        public func cancel
Signal.swift:97
            signalListener.cancel()
() {
0242            self.listener = nil
0243        }
0244    }
0245    
0246    infix operator => { associativity left precedence 0 }
0247    
0248    public func =><T> (signal: Signal<T>, data: T) -> Void {
0249        signal.fire(data)
0250    }
0251