draw.io mac版 非常好用的画图软件

// // RACSignal+Operations.h // ReactiveCocoa // // Created by Justin Spahr-Summers on 2012-09-06. // Copyright (c) 2012 GitHub, Inc. All rights reserved. // #import <Foundation/Foundation.h> #import "RACSignal.h" /// The domain for errors originating in RACSignal operations. extern NSString * const RACSignalErrorDomain; /// The error code used with -timeout:. extern const NSInteger RACSignalErrorTimedOut; /// The error code used when a value passed into +switch:cases:default: does not /// match any of the cases, and no default was given. extern const NSInteger RACSignalErrorNoMatchingCase; @class RACCommand; @class RACDisposable; @class RACMulticastConnection; @class RACScheduler; @class RACSequence; @class RACSubject; @class RACTuple; @protocol RACSubscriber; @interface RACSignal (Operations) /// Do the given block on `next`. This should be used to inject side effects into /// the signal. - (RACSignal *)doNext:(void (^)(id x))block; /// Do the given block on `error`. This should be used to inject side effects /// into the signal. - (RACSignal *)doError:(void (^)(NSError *error))block; /// Do the given block on `completed`. This should be used to inject side effects /// into the signal. - (RACSignal *)doCompleted:(void (^)(void))block; /// Sends `next`s only if we don't receive another `next` in `interval` seconds. /// /// If a `next` is received, and then another `next` is received before /// `interval` seconds have passed, the first value is discarded. /// /// After `interval` seconds have passed since the most recent `next` was sent, /// the most recent `next` is forwarded on the scheduler that the value was /// originally received on. If +[RACScheduler currentScheduler] was nil at the /// time, a private background scheduler is used. /// /// Returns a signal which sends throttled and delayed `next` events. Completion /// and errors are always forwarded immediately. - (RACSignal *)throttle:(NSTimeInterval)interval; /// Throttles `next`s for which `predicate` returns YES. /// /// When `predicate` returns YES for a `next`: /// /// 1. If another `next` is received before `interval` seconds have passed, the /// prior value is discarded. This happens regardless of whether the new /// value will be throttled. /// 2. After `interval` seconds have passed since the value was originally /// received, it will be forwarded on the scheduler that it was received /// upon. If +[RACScheduler currentScheduler] was nil at the time, a private /// background scheduler is used. /// /// When `predicate` returns NO for a `next`, it is forwarded immediately, /// without any throttling. /// /// interval - The number of seconds for which to buffer the latest value that /// passes `predicate`. /// predicate - Passed each `next` from the receiver, this block returns /// whether the given value should be throttled. This argument must /// not be nil. /// /// Returns a signal which sends `next` events, throttled when `predicate` /// returns YES. Completion and errors are always forwarded immediately. - (RACSignal *)throttle:(NSTimeInterval)interval valuesPassingTest:(BOOL (^)(id next))predicate; /// Forwards `next` and `completed` events after delaying for `interval` seconds /// on the current scheduler (on which the events were delivered). /// /// If +[RACScheduler currentScheduler] is nil when `next` or `completed` is /// received, a private background scheduler is used. /// /// Returns a signal which sends delayed `next` and `completed` events. Errors /// are always forwarded immediately. - (RACSignal *)delay:(NSTimeInterval)interval; /// Resubscribes when the signal completes. - (RACSignal *)repeat; /// Executes the given block each time a subscription is created. /// /// block - A block which defines the subscription side effects. Cannot be `nil`. /// /// Example: /// /// // Write new file, with backup. /// [[[[fileManager /// rac_createFileAtPath:path contents:data] /// initially:^{ /// // 2. Second, backup current file /// [fileManager moveItemAtPath:path toPath:backupPath error:nil]; /// }] /// initially:^{ /// // 1. First, acquire write lock. /// [writeLock lock]; /// }] /// finally:^{ /// [writeLock unlock]; /// }]; /// /// Returns a signal that passes through all events of the receiver, plus /// introduces side effects which occur prior to any subscription side effects /// of the receiver. - (RACSignal *)initially:(void (^)(void))block; /// Executes the given block when the signal completes or errors. - (RACSignal *)finally:(void (^)(void))block; /// Divides the receiver's `next`s into buffers which deliver every `interval` /// seconds. /// /// interval - The interval in which values are grouped into one buffer. /// scheduler - The scheduler upon which the returned signal will deliver its /// values. This must not be nil or +[RACScheduler /// immediateScheduler]. /// /// Returns a signal which sends RACTuples of the buffered values at each /// interval on `scheduler`. When the receiver completes, any currently-buffered /// values will be sent immediately. - (RACSignal *)bufferWithTime:(NSTimeInterval)interval onScheduler:(RACScheduler *)scheduler; /// Collects all receiver's `next`s into a NSArray. Nil values will be converted /// to NSNull. /// /// This corresponds to the `ToArray` method in Rx. /// /// Returns a signal which sends a single NSArray when the receiver completes /// successfully. - (RACSignal *)collect; /// Takes the last `count` `next`s after the receiving signal completes. - (RACSignal *)takeLast:(NSUInteger)count; /// Combines the latest values from the receiver and the given signal into /// RACTuples, once both have sent at least one `next`. /// /// Any additional `next`s will result in a new RACTuple with the latest values /// from both signals. /// /// signal - The signal to combine with. This argument must not be nil. /// /// Returns a signal which sends RACTuples of the combined values, forwards any /// `error` events, and completes when both input signals complete. - (RACSignal *)combineLatestWith:(RACSignal *)signal; /// Combines the latest values from the given signals into RACTuples, once all /// the signals have sent at least one `next`. /// /// Any additional `next`s will result in a new RACTuple with the latest values /// from all signals. /// /// signals - The signals to combine. If this collection is empty, the returned /// signal will immediately complete upon subscription. /// /// Returns a signal which sends RACTuples of the combined values, forwards any /// `error` events, and completes when all input signals complete. + (RACSignal *)combineLatest:(id<NSFastEnumeration>)signals; /// Combines signals using +combineLatest:, then reduces the resulting tuples /// into a single value using -reduceEach:. /// /// signals - The signals to combine. If this collection is empty, the /// returned signal will immediately complete upon subscription. /// reduceBlock - The block which reduces the latest values from all the /// signals into one value. It must take as many arguments as the /// number of signals given. Each argument will be an object /// argument. The return value must be an object. This argument /// must not be nil. /// /// Example: /// /// [RACSignal combineLatest:@[ stringSignal, intSignal ] reduce:^(NSString *string, NSNumber *number) { /// return [NSString stringWithFormat:@"%@: %@", string, number]; /// }]; /// /// Returns a signal which sends the results from each invocation of /// `reduceBlock`. + (RACSignal *)combineLatest:(id<NSFastEnumeration>)signals reduce:(id (^)())reduceBlock; /// Merges the receiver and the given signal with `+merge:` and returns the /// resulting signal. - (RACSignal *)merge:(RACSignal *)signal; /// Sen