RACSequence
RACSequence是继承于RACStream，用来方便实现数据处理的，他一共有9个子类，分别是：
- RACArraySequence,用来处理数组
- RACEagerSequence，继承于RACArraySequence，用来处理积极运算。
- RACDynamicSequence,用来初始化的类
- RACEmptySequence，空类
- RACIndexSetSequence,用来处理index
- RACStringSequence，用来处理字符串
- RACSignalSequence,用来处理信号
- RACTupleSequence，用来处理元组
- RACUnarySequence,用来处理一元数据
接下来从父类RACSequence开始分析：
自身的方法
@interface RACSequence<__covariant ValueType> : RACStream
//第一个元素
@property (nonatomic, strong, readonly, nullable) ValueType head;
//后面的元素
@property (nonatomic, strong, readonly, nullable) RACSequence *tail;
//总数组
@property (nonatomic, copy, readonly) NSArray *array;
//快速枚举
@property (nonatomic, copy, readonly) NSEnumerator *objectEnumerator;
//积极运算
@property (nonatomic, copy, readonly) RACSequence *eagerSequence;
//惰性运算
@property (nonatomic, copy, readonly) RACSequence *lazySequence;
//信号
- (RACSignal *)signal;
//
- (RACSignal *)signalWithScheduler:(RACScheduler *)scheduler;
//
- (id)foldLeftWithStart:(nullable id)start reduce:(id _Nullable (^)(id _Nullable accumulator, ValueType _Nullable value))reduce;
//
- (id)foldRightWithStart:(nullable id)start reduce:(id _Nullable (^)(id _Nullable first, RACSequence *rest))reduce;
//
- (BOOL)any:(BOOL (^)(ValueType _Nullable value))block;
//
- (BOOL)all:(BOOL (^)(ValueType _Nullable value))block;
//
- (nullable ValueType)objectPassingTest:(BOOL (^)(ValueType _Nullable value))block;
//
+ (RACSequence *)sequenceWithHeadBlock:(ValueType _Nullable (^)(void))headBlock tailBlock:(nullable RACSequence *(^)(void))tailBlock;
接下来我们看看这些属性和方法都做了什么。
一、初始化--sequenceWithHeadBlock: tailBlock:
+ (RACSequence *)sequenceWithHeadBlock:(id (^)(void))headBlock tailBlock:(RACSequence *(^)(void))tailBlock {
return [[RACDynamicSequence sequenceWithHeadBlock:headBlock tailBlock:tailBlock] setNameWithFormat:@"+sequenceWithHeadBlock:tailBlock:"];
}
用子类完成初始化，传入一个block
二、- (NSUInteger)countByEnumeratingWithState:(NSFastEnumerationState *)state objects:(__unsafe_unretained id *)stackbuf count:(NSUInteger)len
实现NSFastEnumration协议，使自定义对象支持for循环，在此方法视线中，将每一个sequence的head去了出来放到缓冲区中，for循环实际是for循环了所有的head
三、- (NSArray *)array
返回的是一个包含所有head的数组
四、- (NSEnumerator *)objectEnumerator
@interface RACSequenceEnumerator : NSEnumerator
// The sequence the enumerator is enumerating.
//
// This will change as the enumerator is exhausted. This property should only be
// accessed while synchronized on self.
@property (nonatomic, strong) RACSequence *sequence;
@end
@implementation RACSequenceEnumerator
- (id)nextObject {
id object = nil;
@synchronized (self) {
object = self.sequence.head;
self.sequence = self.sequence.tail;
}
return object;
}
@end
可以看到，这是一个自定义快速枚举，nextObject返回的是当前sequence的tail
- (NSEnumerator *)objectEnumerator {
RACSequenceEnumerator *enumerator = [[RACSequenceEnumerator alloc] init];
enumerator.sequence = self;
return enumerator;
}
在初始化的时候设置sequence为当前值
五、- (RACSignal *)signalWithScheduler:(RACScheduler *)scheduler
- (RACSignal *)signal {
return [[self signalWithScheduler:[RACScheduler scheduler]] setNameWithFormat:@"[%@] -signal", self.name];
}
- (RACSignal *)signalWithScheduler:(RACScheduler *)scheduler {
return [[RACSignal createSignal:^(id subscriber) {
__block RACSequence *sequence = self;
return [scheduler scheduleRecursiveBlock:^(void (^reschedule)(void)) {
if (sequence.head == nil) {
[subscriber sendCompleted];
return;
}
[subscriber sendNext:sequence.head];
sequence = sequence.tail;
reschedule();
}];
}] setNameWithFormat:@"[%@] -signalWithScheduler: %@", self.name, scheduler];
}
生成一个signal对象，这个对象可以遍历返回head，遍历完成后发送sendCompleted信号。
六、- (id)foldLeftWithStart:(id)start reduce:(id (^)(id, id))reduce
- (id)foldLeftWithStart:(id)start reduce:(id (^)(id, id))reduce {
NSCParameterAssert(reduce != NULL);
if (self.head == nil) return start;
for (id value in self) {
start = reduce(start, value);
}
return start;
}
从左开始根据reduceblock处理的结果，start累加左边，最后返回start
七、- (id)foldRightWithStart:(id)start reduce:(id (^)(id, RACSequence *))reduce
- (id)foldRightWithStart:(id)start reduce:(id (^)(id, RACSequence *))reduce {
NSCParameterAssert(reduce != NULL);
if (self.head == nil) return start;
RACSequence *rest = [RACSequence sequenceWithHeadBlock:^{
if (self.tail) {
return [self.tail foldRightWithStart:start reduce:reduce];
} else {
return start;
}
} tailBlock:nil];
return reduce(self.head, rest);
}
同上，从右边累加
八、- (BOOL)any:(BOOL (^)(id))block
是否包含数据
- (BOOL)any:(BOOL (^)(id))block {
NSCParameterAssert(block != NULL);
return [self objectPassingTest:block] != nil;
}
四、- (id)objectPassingTest:(BOOL (^)(id))block
返回过滤的那个head
- (id)objectPassingTest:(BOOL (^)(id))block {
NSCParameterAssert(block != NULL);
return [self filter:block].head;
}
在RACSignal章节，我们知道父类RACStream的filter方法是用来过滤信息的。
五、- (BOOL)all:(BOOL (^)(id))block
- (BOOL)all:(BOOL (^)(id))block {
NSCParameterAssert(block != NULL);
NSNumber *result = [self foldLeftWithStart:@YES reduce:^(NSNumber *accumulator, id value) {
return @(accumulator.boolValue && block(value));
}];
return result.boolValue;
}
判断所有值是否满足要求
六、- (RACSequence *)lazySequence
返回自身
七、- (RACSequence *)eagerSequence
- (RACSequence *)eagerSequence {
return [RACEagerSequence sequenceWithArray:self.array offset:0];
}
返回一个积极的数组
父类的方法
+ (RACSequence *)return:(nullable ValueType)value;
+ (RACSequence *)empty;
typedef RACSequence * _Nullable (^RACSequenceBindBlock)(ValueType _Nullable value, BOOL *stop);
- (RACSequence *)bind:(RACSequenceBindBlock (^)(void))block;
- (RACSequence *)concat:(RACSequence *)sequence;
- (RACSequence *)zipWith:(RACSequence *)sequence
一、+ (RACSequence *)empty
+ (RACSequence *)empty {
return RACEmptySequence.empty;
}
返回一个空的对象
二、+ (RACSequence *)return:(id)value
返回RACUnarySequence，head值设为value
三、- (RACSequence *)bind:(RACSequenceBindBlock (^)(void))block
通过block回调一个RACSequence，并执行（五）方法
四、- (RACSequence *)bind:(RACSequenceBindBlock)bindBlock passingThroughValuesFromSequence:(RACSequence *)passthroughSequence
- (RACSequence *)bind:(RACSequenceBindBlock)bindBlock passingThroughValuesFromSequence:(RACSequence *)passthroughSequence {
__block RACSequence *valuesSeq = self;
__block RACSequence *current = passthroughSequence;//依赖的序列
__block BOOL stop = NO;//状态记录
RACSequence *sequence = [RACDynamicSequence sequenceWithLazyDependency:^ id {
while (current.head == nil) {//如果currnet的head有值，跳出循环
if (stop) return nil;//如果要停止，则返回nil
id value = valuesSeq.head;
if (value == nil) {//如果head为nil跳出循环
stop = YES;
return nil;
}
current = (id)bindBlock(value, &stop);
if (current == nil) {////如果head为nil跳出循环
stop = YES;
return nil;
}
valuesSeq = valuesSeq.tail;
}
NSCAssert([current isKindOfClass:RACSequence.class], @"-bind: block returned an object that is not a sequence: %@", current);
return nil;
} headBlock:^(id _) {
return current.head;
} tailBlock:^ id (id _) {
if (stop) return nil;
return [valuesSeq bind:bindBlock passingThroughValuesFromSequence:current.tail];
}];
sequence.name = self.name;
return sequence;
}
这个函数用递归的方式，创建了一个sequence.通过传入的block和stop来确定转换值和是否停止，block需要返回一个RACSequence对象。
流程图
点击放大
递归创建
示例用法
RACSequence *sequence = [RACDynamicSequence sequenceWithHeadBlock:^id _Nullable{
return @"1";
} tailBlock:^RACSequence * _Nonnull{
return @[@"2",@"3",@"4"].rac_sequence;
}];
NSLog(@"%@ %@",sequence.head,sequence.tail);
sequence = [sequence bind:^RACSequenceBindBlock _Nonnull{
return ^ (NSString *value,BOOL *stop){
return [RACSequence return:@([value integerValue] + 1)];
};
}];
NSLog(@"%@ %@",sequence.head,[sequence.tail tail]);