//打印方法名
#define LOG_METHOD_NAME {NSLog(@"%@", NSStringFromSelector(_cmd));}
//打印对象的类名，以及对象本身的地址
#define LOG_OBJ_ADDRESS(obj) {NSLog(@"%@ : %p",NSStringFromClass([obj class]), obj);}
//打印空行
#define LOG_END {NSLog(@"%@", @" ");}

- (void)stringCopyTest
{
    LOG_METHOD_NAME
    NSString *str = @"Hello";
    LOG_OBJ_ADDRESS(str);
    NSString *cpStr = [str copy];
    LOG_OBJ_ADDRESS(cpStr);
    NSMutableString *mutCpStr = [str mutableCopy];
    LOG_OBJ_ADDRESS(mutCpStr);
    LOG_END
}

- (void)mutableStringCopyTest
{
    LOG_METHOD_NAME
    NSMutableString *mutStr = [@"OC" mutableCopy];
    LOG_OBJ_ADDRESS(mutStr);
    NSMutableString *cpMutStr = [mutStr copy];
    LOG_OBJ_ADDRESS(cpMutStr);
    NSMutableString *mutCpMutStr = [mutStr mutableCopy];
    LOG_OBJ_ADDRESS(mutCpMutStr);
    LOG_END
}

@property (nonatomic, copy) id cpID;
@property (nonatomic, strong) id stID;

- (void)setCpID:(id)cpID {
    _cpID = [cpID copy];
}

- (id)cpID {
    return _cpID;
}

- (void)setStID:(id)stID {
    _stID = stID;
}

- (id)stID {
    return _stID;
}

@property (nonatomic, copy) NSString *cpStr;
@property (nonatomic, strong) NSString *stStr;

- (void)stringPropertyTest
{
    LOG_METHOD_NAME
    NSMutableString *mutStr = [@"123" mutableCopy];
    LOG_OBJ_ADDRESS(mutStr);
    self.cpStr = mutStr;
    LOG_OBJ_ADDRESS(self.cpStr);
    self.stStr = mutStr;
    LOG_OBJ_ADDRESS(self.stStr);
    
    NSLog(@"修改前");
    NSLog(@"mutStr：%@", mutStr);
    NSLog(@"copy：%@", self.cpStr);
    NSLog(@"strong：%@", self.stStr);
    
    [mutStr appendString:@"456"];
    NSLog(@"修改后");
    NSLog(@"mutStr：%@", mutStr);
    NSLog(@"copy：%@", self.cpStr);
    NSLog(@"strong：%@", self.stStr);
    
    LOG_END
}

@property (nonatomic, copy) NSMutableString *cpMutStr;
@property (nonatomic, strong) NSMutableString *stMutStr;

- (void)mutableStringPropertyTest
{
    LOG_METHOD_NAME
    NSMutableString *mutStr = [@"123" mutableCopy];
    LOG_OBJ_ADDRESS(mutStr);
    self.cpMutStr = mutStr;
    LOG_OBJ_ADDRESS(self.cpMutStr);
    self.stMutStr = mutStr;
    LOG_OBJ_ADDRESS(self.stMutStr);
    
    NSLog(@"修改前");
    NSLog(@"mutStr：%@", mutStr);
    NSLog(@"copy：%@", self.cpMutStr);
    NSLog(@"strong：%@", self.stMutStr);
    
    [mutStr appendString:@"456"];
    NSLog(@"修改后");
    NSLog(@"mutStr：%@", mutStr);
    NSLog(@"copy：%@", self.cpMutStr);
    NSLog(@"strong：%@", self.stMutStr);
    LOG_END
}

[self.cpMutStr appendString:@"789"];

- (void)viewDidLoad;
- (void)viewDidUnload;
- (void)viewWillAppear:(BOOL)animated;
- (void)viewDidAppear:(BOOL)animated;
- (void)viewWillDisappear:(BOOL)animated;
- (void)viewDidDisappear:(BOOL)animated;

@interface BaseViewController : UIViewController
@end

@implementation BaseViewController

- (void)viewWillAppear:(BOOL)animated {
    [super viewWillAppear:animated];
    
    //其他代码...
    
    //设置导航条外观
    [self setNavigationBarAppearance];
    
    //其他代码...
}

- (void) hellWorld {
    [super helloWo];
}

@end

@interface MyViewController : BaseViewController
@end

@implementation MyViewController

- (void)viewWillAppear:(BOOL)animated {
    //[super viewWillAppear:animated];
    
    //其他代码...
}

@end

- (void)didReceiveMemoryWarning {
  [super didReceiveMemoryWarning];
  if ([[UIDevice currentDevice].systemVersion floatValue] >= 6.0) {
    if (self.isViewLoaded && !self.view.window) {
      self.view = nil;
    }
  }
}

@interface MyViewController : BaseViewController
@end

@implementation MyViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    [[NSNotificationCenter defaultCenter] addObserver:self
                                             selector:@selector(p_onFooNotification:)
                                                 name:@"FooNotification"
                                               object:nil];
    //其他代码...
}

- (void)p_onFooNotification:(NSNotification *)notify {
    //其他代码
}

@end

long st = [[NSDate date] timeIntervalSince1970] * 1000;
NSString *strSt = [@(st) stringValue];

long long st = [[NSDate date] timeIntervalSince1970] * 1000;
NSString *strSt = [@(st) stringValue];

AppData *appData = [[AppData alloc] initWithAppId:[dic[@"app_id"] integerValue]
                                            iconURL:dic[@"app_icon"]
                                            appName:dic[@"app_name"]
                                            linkUrl:urlStr
                                            webType:(BOOL)dic[@"wap_type"]
                                              appTip:dic[@"app_desc"]
                                        andAppMarks:appMarks];

//例1

NSArray *testAry = [[NSArray alloc] init] ;
id firstObj = [testAry objectAtIndex:0];
id lastObj = [testAry objectAtIndex:testAry.cout - 1];

//例2

@interface TestClass : NSObject 

- (id)createObj;

@end

@implementation TestClass

- (id)createObj {
    id obj = [[NSObject alloc] init];
    return obj;
}

@end

// {外部调用代码
TestClass * __weak weakTestObj = someStrongTestObj;
[self foo:^{
    NSMutableArray *ary = [[NSMutableArray alloc] init];
    [ary addObject:[weakTestObj createObj]];
}];
// 外部调用代码}

//例1
NSString *test = [@"123" mutableCopy] ;
NSLog(@"%@", test == @"123" ? @"相等" : @"不等");
NSLog(@"%@", [test isEqualToString:@"123"] ? @"相等" : @"不等");

//例2
NSMutableString *str = [@"123" mutableCopy];
[str appendString:nil];

//例3
NSString *str = [@"123" mutableCopy];
NSString *subStr = [str substringFromIndex:str.length + 1];

NSString *topicId = dic[@"tId"]; //dic是NSJSONSerialization解析json串得到的字典

//判断topicId是否为空
if (![topicId length]) {
//对于一个NSString对象调用length判空可以判断两种情况，一种是该对象为nil，另一种是该对象是空串@""
    
} else {

}

//串行遍历容器中所有元素
- (void)bk_each:(void (^)(id obj))block; 
//并发遍历容器中所有元素（不要求容器中元素顺次遍历的时候可以使用此种遍历方式来提高遍历速度）
- (void)bk_apply:(void (^)(id obj))block;
//返回第一个符合block条件（让block返回YES）的对象
- (id)bk_match:(BOOL (^)(id obj))block;
//返回所有符合block条件（让block返回YES）的对象
- (NSArray *)bk_select:(BOOL (^)(id obj))block;
//返回所有！！！不符合block条件（让block返回YES）的对象
- (NSArray *)bk_reject:(BOOL (^)(id obj))block;
//返回对象的block映射数组
- (NSArray *)bk_map:(id (^)(id obj))block;

//查看容器是否有符合block条件的对象
//判断是否容器中至少有一个元素符合block条件
- (BOOL)bk_any:(BOOL (^)(id obj))block; 
//判断是否容器中所有元素都！！！不符合block条件
- (BOOL)bk_none:(BOOL (^)(id obj))block;
//判断是否容器中所有元素都符合block条件
- (BOOL)bk_all:(BOOL (^)(id obj))block;

- (BOOL)bk_all:(BOOL (^)(id obj))block
{
    NSParameterAssert(block != nil);

    __block BOOL result = YES;

    [self enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
        if (!block(obj)) {
            result = NO;
            *stop = YES;
        }
    }];

    return result;
}

/** Filters a mutable array to the objects matching the block.

 @param block A single-argument, BOOL-returning code block.
 @see <NSArray(BlocksKit)>bk_reject:
 */
//删除容器中!!!不符合block条件的对象，即只保留符合block条件的对象
- (void)bk_performSelect:(BOOL (^)(id obj))block;

//删除容器中符合block条件的对象
- (void)bk_performReject:(BOOL (^)(id obj))block;

//容器中的对象变换为自己的block映射对象
- (void)bk_performMap:(id (^)(id obj))block;

//@interface NSObject (BKAssociatedObjects)

//以OBJC_ASSOCIATION_RETAIN_NONATOMIC方式绑定关联对象
- (void)bk_associateValue:(id)value withKey:(const void *)key;
//以OBJC_ASSOCIATION_COPY_NONATOMIC方式绑定关联对象
- (void)bk_associateCopyOfValue:(id)value withKey:(const void *)key;
//以OBJC_ASSOCIATION_RETAIN方式绑定关联对象
- (void)bk_atomicallyAssociateValue:(id)value withKey:(const void *)key;
//以OBJC_ASSOCIATION_COPY方式绑定关联对象
- (void)bk_atomicallyAssociateCopyOfValue:(id)value withKey:(const void *)key;
//弱绑定
- (void)bk_weaklyAssociateValue:(__autoreleasing id)value withKey:(const void *)key;
//删除所有绑定的关联对象
- (void)bk_removeAllAssociatedObjects;

@interface _BKWeakAssociatedObject : NSObject

@property (nonatomic, weak) id value;

@end

- (void)bk_weaklyAssociateValue:(__autoreleasing id)value withKey:(const void *)key
{
    _BKWeakAssociatedObject *assoc = objc_getAssociatedObject(self, key);
    if (!assoc) {
        assoc = [_BKWeakAssociatedObject new];
        //做一个_BKWeakAssociatedObject对象中间层
        //以非原子持有的方式绑定一个_BKWeakAssociatedObject对象
        //_BKWeakAssociatedObject该对象又有真实对象的弱引用
        [self bk_associateValue:assoc withKey:key];
    }
    //_BKWeakAssociatedObject的weak property设置为真正应该关联的对象
    assoc.value = value;
}

//@interface NSObject (BKBlockExecution)

//主线程执行block方法，延迟时间可选
- (id)bk_performBlock:(void (^)(id obj))block afterDelay:(NSTimeInterval)delay
//后台线程执行block方法，延迟时间可选
- (id)bk_performBlockInBackground:(void (^)(id obj))block afterDelay:(NSTimeInterval)delay

//所有执行block相关的方法都是此方法的简化版，该函数在指定的block队列上以指定的时间延迟执行block
- (id)bk_performBlock:(void (^)(id obj))block onQueue:(dispatch_queue_t)queue afterDelay:(NSTimeInterval)delay;

//取消block，非常牛逼！！！一般来说一个block加到block queue上是没法取消的，此方法实现了block的取消操作（必须是用BlocksKit投放的block）
+ (void)bk_cancelBlock:(id)block;

- (id)bk_performBlock:(void (^)(id obj))block onQueue:(dispatch_queue_t)queue afterDelay:(NSTimeInterval)delay
{
    NSParameterAssert(block != nil);
    //cancelled是个__block变量，使得该block在加入queue后能够逻辑上取消。注意，仅仅是逻辑上取消，不能把block从queue中剔除。
    __block BOOL cancelled = NO;
    
    //在外部block之上加一层能够逻辑取消的代码，使其变为一个wrapper block
    //当调用wrapper(YES)的时候就让__block BOOL cancelled = YES,使得以后每次block主体都被跳过。
    void (^wrapper)(BOOL) = ^(BOOL cancel) {
    //cancel参数是为了在外部能够控制cancelled _block变量
        if (cancel) {
            cancelled = YES;
            return;
        }
        if (!cancelled) block(self);
    };
    
    //每个投入queue中的block实际上是wraper版的block
    dispatch_after(BKTimeDelay(delay), queue, ^{
        //把cancel设置为NO,block能够逻辑执行
        wrapper(NO);
    });
    
    //返回wraper block，以便bk_cancelBlock的时候使用
    return [wrapper copy];
}

+ (void)bk_cancelBlock:(id)block
{
    NSParameterAssert(block != nil);
    void (^wrapper)(BOOL) = block;
    //把cancel设置为YES,修改block中_block cancelled变量，如果此时block未执行则，block在执行的时候其逻辑主体会被跳过
    wrapper(YES);
}

//添加观察者
- (void)addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options context:(void *)context;
//删除观察者
- (void)removeObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath context:(void *)context;

//观察到对象发生变化后的回调函数（观察回调）
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context;

@interface _BKObserver : NSObject {
    BOOL _isObserving;
}

//存储“被观察的对象”
@property (nonatomic, readonly, unsafe_unretained) id observee;
@property (nonatomic, readonly) NSMutableArray *keyPaths;
//存储回调block
@property (nonatomic, readonly) id task;
@property (nonatomic, readonly) BKObserverContext context;

- (id)initWithObservee:(id)observee keyPaths:(NSArray *)keyPaths context:(BKObserverContext)context task:(id)task;

@end

static void *BKObserverBlocksKey = &BKObserverBlocksKey;
static void *BKBlockObservationContext = &BKBlockObservationContext;

@implementation _BKObserver

- (id)initWithObservee:(id)observee keyPaths:(NSArray *)keyPaths context:(BKObserverContext)context task:(id)task
{
    if ((self = [super init])) {
        _observee = observee;
        _keyPaths = [keyPaths mutableCopy];
        _context = context;
        _task = [task copy];
    }
    return self;
}

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context
{
    //观察者回调，在KV改变的时候调用相关block
    if (context != BKBlockObservationContext) return;

    @synchronized(self) {
        switch (self.context) {
            case BKObserverContextKey: {
                void (^task)(id) = self.task;
                task(object);
                break;
            }
            case BKObserverContextKeyWithChange: {
                void (^task)(id, NSDictionary *) = self.task;
                task(object, change);
                break;
            }
            case BKObserverContextManyKeys: {
                void (^task)(id, NSString *) = self.task;
                task(object, keyPath);
                break;
            }
            case BKObserverContextManyKeysWithChange: {
                void (^task)(id, NSString *, NSDictionary *) = self.task;
                task(object, keyPath, change);
                break;
            }
        }
    }
}

//开启KV观察
- (void)startObservingWithOptions:(NSKeyValueObservingOptions)options
{
    @synchronized(self) {
        if (_isObserving) return;

        [self.keyPaths bk_each:^(NSString *keyPath) {
        //observee的被观察对象，observer是自己，
            [self.observee addObserver:self forKeyPath:keyPath options:options context:BKBlockObservationContext];
        }];

        _isObserving = YES;
    }
}

//停止KV观察
- (void)stopObservingKeyPath:(NSString *)keyPath
{
    NSParameterAssert(keyPath);

    @synchronized (self) {
        if (!_isObserving) return;
        if (![self.keyPaths containsObject:keyPath]) return;

        NSObject *observee = self.observee;
        if (!observee) return;

        [self.keyPaths removeObject: keyPath];
        keyPath = [keyPath copy];

        if (!self.keyPaths.count) {
            _task = nil;
            _observee = nil;
            _keyPaths = nil;
        }

        [observee removeObserver:self forKeyPath:keyPath context:BKBlockObservationContext];
    }
}

//添加观察block
- (void)bk_addObserverForKeyPaths:(NSArray *)keyPaths identifier:(NSString *)identifier options:(NSKeyValueObservingOptions)options context:(BKObserverContext)context task:(id)task
{
    NSParameterAssert(keyPaths.count);
    NSParameterAssert(identifier.length);
    NSParameterAssert(task);

    Class classToSwizzle = self.class;
    NSMutableSet *classes = self.class.bk_observedClassesHash;
    @synchronized (classes) {
        NSString *className = NSStringFromClass(classToSwizzle);
        if (![classes containsObject:className]) {
            SEL deallocSelector = sel_registerName("dealloc");
            
            __block void (*originalDealloc)(__unsafe_unretained id, SEL) = NULL;
            
            //勾住类的dealloc方法，并且在其中添加bk_removeAllBlockObservers方法
            id newDealloc = ^(__unsafe_unretained id objSelf) {
                [objSelf bk_removeAllBlockObservers];
                
                if (originalDealloc == NULL) {
                    struct objc_super superInfo = {
                        .receiver = objSelf,
                        .super_class = class_getSuperclass(classToSwizzle)
                    };
                    
                    void (*msgSend)(struct objc_super *, SEL) = (__typeof__(msgSend))objc_msgSendSuper;
                    msgSend(&superInfo, deallocSelector);
                } else {
                    originalDealloc(objSelf, deallocSelector);
                }
            };
            
            IMP newDeallocIMP = imp_implementationWithBlock(newDealloc);
            
            if (!class_addMethod(classToSwizzle, deallocSelector, newDeallocIMP, "v@:")) {
                // The class already contains a method implementation.
                Method deallocMethod = class_getInstanceMethod(classToSwizzle, deallocSelector);
                
                // We need to store original implementation before setting new implementation
                // in case method is called at the time of setting.
                originalDealloc = (void(*)(__unsafe_unretained id, SEL))method_getImplementation(deallocMethod);
                
                // We need to store original implementation again, in case it just changed.
                originalDealloc = (void(*)(__unsafe_unretained id, SEL))method_setImplementation(deallocMethod, newDeallocIMP);
            }
            
            [classes addObject:className];
        }
    }

   //生成_BKObserver对象（真正的KV Observer）
    NSMutableDictionary *dict;
    _BKObserver *observer = [[_BKObserver alloc] initWithObservee:self keyPaths:keyPaths context:context task:task];
    //启动观察
    [observer startObservingWithOptions:options];

   //将新生成的_BKObserver对象添加到dic中
    @synchronized (self) {
        dict = [self bk_observerBlocks];

        if (dict == nil) {
            dict = [NSMutableDictionary dictionary];
            [self bk_setObserverBlocks:dict];
        }
    }

    dict[identifier] = observer;
}

//删除观察block
- (void)bk_removeAllBlockObservers
{
    NSDictionary *dict;

    @synchronized (self) {
        dict = [[self bk_observerBlocks] copy];
        [self bk_setObserverBlocks:nil];
    }

    [dict.allValues bk_each:^(_BKObserver *trampoline) {
        [trampoline stopObserving];
    }];
}

+ (id)bk_scheduledTimerWithTimeInterval:(NSTimeInterval)inTimeInterval block:(void (^)(NSTimer *timer))block repeats:(BOOL)inRepeats
{
    NSParameterAssert(block != nil);
    return [self scheduledTimerWithTimeInterval:inTimeInterval target:self selector:@selector(bk_executeBlockFromTimer:) userInfo:[block copy] repeats:inRepeats];
}

+ (id)bk_timerWithTimeInterval:(NSTimeInterval)inTimeInterval block:(void (^)(NSTimer *timer))block repeats:(BOOL)inRepeats
{
    NSParameterAssert(block != nil);
    return [self timerWithTimeInterval:inTimeInterval target:self selector:@selector(bk_executeBlockFromTimer:) userInfo:[block copy] repeats:inRepeats];
}

+ (void)bk_executeBlockFromTimer:(NSTimer *)aTimer {
    void (^block)(NSTimer *) = [aTimer userInfo];
    if (block) block(aTimer);
}

- (IBAction) annoyUser
{
    // 创建一个alert view
    UIAlertView *alertView = [[UIAlertView alloc]
                              initWithTitle:@"Hello World!"
                              message:@"This alert's delegate is implemented using blocks. That's so cool!"
                              delegate:nil
                              cancelButtonTitle:@"Meh."
                              otherButtonTitles:@"Woo!", nil];

    // 获取该alert view的动态代理对象（什么是动态代理对象稍后会说）
    A2DynamicDelegate *dd = alertView.bk_dynamicDelegate;
    
    // 调用动态代理对象的 - (void)implementMethod:(SEL)selector withBlock:(id)block;方法，使得SEL映射一个block对象(假设叫做block1)
    [dd implementMethod:@selector(alertViewShouldEnableFirstOtherButton:) withBlock:^(UIAlertView *alertView) {
        NSLog(@"Message: %@", alertView.message);
        return YES;
    }];

    // 同上，让映射-alertView:willDismissWithButtonIndex:的SEL到另外一个block对象(假设叫做block2)
    [dd implementMethod:@selector(alertView:willDismissWithButtonIndex:) withBlock:^(UIAlertView *alertView, NSInteger buttonIndex) {
        NSLog(@"You pushed button #%d (%@)", buttonIndex, [alertView buttonTitleAtIndex:buttonIndex]);
    }];

    // 把alertView的delegate设置为动态代理
    alertView.delegate = dd;
    
    [alertView show];
}
 // 那么，alert view在显示的时候收到alertViewShouldEnableFirstOtherButton:消息调用block1；alert view在消失的时候收到alertView:willDismissWithButtonIndex:消息，调用block2

 // File:NSObject+A2DynamicDelegate.m
 - (id)bk_dynamicDelegateWithClass:(Class)cls forProtocol:(Protocol *)protocol
{
    /**
     * Storing the dynamic delegate as an associated object of the delegating
     * object not only allows us to later retrieve the delegate, but it also
     * creates a strong relationship to the delegate. Since delegates are weak
     * references on the part of the delegating object, a dynamic delegate
     * would be deallocated immediately after its declaring scope ends.
     * Therefore, this strong relationship is required to ensure that the
     * delegate's lifetime is at least as long as that of the delegating object.
     **/

    __block A2DynamicDelegate *dynamicDelegate;

    dispatch_sync(a2_backgroundQueue(), ^{
        dynamicDelegate = objc_getAssociatedObject(self, (__bridge const void *)protocol);
        
        if (!dynamicDelegate)
        {
            dynamicDelegate = [[cls alloc] initWithProtocol:protocol];
            objc_setAssociatedObject(self, (__bridge const void *)protocol, dynamicDelegate, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
        }
    });

    return dynamicDelegate;
}

//testTableView is a UITableView
//_model is a NITableViewModel instance
//_actions is a NITableViewActions instance
self.testTableView.delegate = _actions;
self.testTableView.dataSource = _model;

@interface NITableViewModel : NSObject <UITableViewDataSource>
    - (id)initWithDelegate:(id<NITableViewModelDelegate>)delegate;
    - (id)initWithListArray:(NSArray *)sectionedArray delegate:(id<NITableViewModelDelegate>)delegate;
    - (id)initWithSectionedArray:(NSArray *)sectionedArray delegate:(id<NITableViewModelDelegate>)delegate;
@end

/*
 * @code
 * NSArray* contents =
 * [NSArray arrayWithObjects:
 *  @"Section 1",
 *  [NSDictionary dictionaryWithObject:@"Row 1" forKey:@"title"],
 *  [NSDictionary dictionaryWithObject:@"Row 2" forKey:@"title"],
 *  @"Section 2",
 *  // This section is empty.
 *  @"Section 3",
 *  [NSDictionary dictionaryWithObject:@"Row 3" forKey:@"title"],
 *  [NITableViewModelFooter footerWithTitle:@"Footer"],
 *  nil];
 * [[NIStaticTableViewModel alloc] initWithSectionedArray:contents delegate:self];
 */

- (UITableViewCell *)tableViewModel: (NITableViewModel *)tableViewModel
                   cellForTableView: (UITableView *)tableView
                        atIndexPath: (NSIndexPath *)indexPath
                         withObject: (id)object
{
    id object = [tableViewModel objectAtIndexPath:indexPath];
    //从数据源获取cell上的数据
    //object就是该cell对应的数据，也就是你在model的sectionedArray里面设置的东西
    //如上例子，若indexPath为section0 row0则object是[NSDictionary dictionaryWithObject:@"Row 1" forKey:@"title"]
    //得到这些信息后，我们再通过平时的策略来生成cell
}

@protocol NICellObject <NSObject>
@required
/** The class of cell to be created when this object is passed to the cell factory. */
- (Class)cellClass;
@optional
/** The style of UITableViewCell to be used when initializing the cell for the first time. */
- (UITableViewCellStyle)cellStyle;
@end

@interface NICellObject : NSObject <NICellObject>
// Designated initializer.
- (id)initWithCellClass:(Class)cellClass userInfo:(id)userInfo;
- (id)initWithCellClass:(Class)cellClass;
+ (id)objectWithCellClass:(Class)cellClass userInfo:(id)userInfo;
+ (id)objectWithCellClass:(Class)cellClass;
@property (nonatomic, strong) id userInfo;
@end

+ (UITableViewCell *)tableViewModel:(NITableViewModel *)tableViewModel
               cellForTableView:(UITableView *)tableView
                    atIndexPath:(NSIndexPath *)indexPath
                     withObject:(id)object {
  UITableViewCell* cell = nil;

  // Only NICellObject-conformant objects may pass.
  if ([object respondsToSelector:@selector(cellClass)]) {
    //1拿cellClass
    Class cellClass = [object cellClass];
    //2根据cellClass来生成cell
    cell = [self cellWithClass:cellClass tableView:tableView object:object];

  } else if ([object respondsToSelector:@selector(cellNib)]) {
    UINib* nib = [object cellNib];
    cell = [self cellWithNib:nib tableView:tableView indexPath:indexPath object:object];
  }

  // If this assertion fires then your app is about to crash. You need to either add an explicit
  // binding in a NICellFactory object or implement the NICellObject protocol on this object and
  // return a cell class.
  NIDASSERT(nil != cell);

  return cell;
}

+ (UITableViewCell *)cellWithClass:(Class)cellClass
                     tableView:(UITableView *)tableView
                        object:(id)object {
  UITableViewCell* cell = nil;

  NSString* identifier = NSStringFromClass(cellClass);

  if ([cellClass respondsToSelector:@selector(shouldAppendObjectClassToReuseIdentifier)]
      && [cellClass shouldAppendObjectClassToReuseIdentifier]) {
    identifier = [identifier stringByAppendingFormat:@".%@", NSStringFromClass([object class])];
  }

  cell = [tableView dequeueReusableCellWithIdentifier:identifier];

  if (nil == cell) {
    UITableViewCellStyle style = UITableViewCellStyleDefault;
    if ([object respondsToSelector:@selector(cellStyle)]) {
      style = [object cellStyle];
    }
    cell = [[cellClass alloc] initWithStyle:style reuseIdentifier:identifier];
  }

  // Allow the cell to configure itself with the object's information.
  // 调用cell类的shouldAppendObjectClassToReuseIdentifier函数，给自定义的cell一个改变自己的机会
  if ([cell respondsToSelector:@selector(shouldUpdateCellWithObject:)]) {
    [(id<NICell>)cell shouldUpdateCellWithObject:object];
  }

  return cell;
}

//自定义的cell
@interface TestCell : UITableViewCell <NICell>
@end

@interface TestCell ()
@property (nonatomic, weak) UILabel* lbl;
@end

@implementation TestCell
- (BOOL)shouldUpdateCellWithObject:(id)object
{
    if (!_lbl) {
        UILabel* tmp = [[UILabel alloc] initWithFrame:self.bounds];
        self.lbl = tmp;
        [self.contentView addSubview:_lbl];
    }
    NSDictionary* data = ((NICellObject*)object).userInfo;
    _lbl.text = data[@"title"];
    return YES;
}
@end

//一气呵成生成cell的相关代码
UITableView* tmpView = [[UITableView alloc] initWithFrame:self.view.bounds style:UITableViewStyleGrouped];
self.testView = tmpView;
[self.view addSubview:_testView];
NSArray* contentAry = @[ [NICellObject objectWithCellClass:[TestCell class] userInfo:@{ @"title" : @"hello" }],
                         [NICellObject objectWithCellClass:[TestCell class] userInfo:@{ @"title" : @"nimbus" }],
                         [NICellObject objectWithCellClass:[TestCell class] userInfo:@{ @"title" : @"what" }],
                         [NICellObject objectWithCellClass:[TestCell class] userInfo:@{ @"title" : @"are" }] ];

self.model = [[NITableViewModel alloc] initWithSectionedArray:contentAry
                                                     delegate:(id)[NICellFactory class]];
self.testView.dataSource = _model;

@interface NITableViewActions : NIActions <UITableViewDelegate>

#pragma mark Forwarding

- (id<UITableViewDelegate>)forwardingTo:(id<UITableViewDelegate>)forwardDelegate;
- (void)removeForwarding:(id<UITableViewDelegate>)forwardDelegate;

#pragma mark Object state

- (UITableViewCellAccessoryType)accessoryTypeForObject:(id)object;
- (UITableViewCellSelectionStyle)selectionStyleForObject:(id)object;

#pragma mark Configurable Properties

@property (nonatomic, assign) UITableViewCellSelectionStyle tableViewCellSelectionStyle;

@end

@interface NIActions : NSObject

// Designated initializer.
- (id)initWithTarget:(id)target;

#pragma mark Mapping Objects

- (id)attachToObject:(id<NSObject>)object tapBlock:(NIActionBlock)action;
- (id)attachToObject:(id<NSObject>)object detailBlock:(NIActionBlock)action;
- (id)attachToObject:(id<NSObject>)object navigationBlock:(NIActionBlock)action;

- (id)attachToObject:(id<NSObject>)object tapSelector:(SEL)selector;
- (id)attachToObject:(id<NSObject>)object detailSelector:(SEL)selector;
- (id)attachToObject:(id<NSObject>)object navigationSelector:(SEL)selector;

#pragma mark Mapping Classes

- (void)attachToClass:(Class)aClass tapBlock:(NIActionBlock)action;
- (void)attachToClass:(Class)aClass detailBlock:(NIActionBlock)action;
- (void)attachToClass:(Class)aClass navigationBlock:(NIActionBlock)action;

- (void)attachToClass:(Class)aClass tapSelector:(SEL)selector;
- (void)attachToClass:(Class)aClass detailSelector:(SEL)selector;
- (void)attachToClass:(Class)aClass navigationSelector:(SEL)selector;

#pragma mark Object State

- (BOOL)isObjectActionable:(id<NSObject>)object;

+ (id)objectFromKeyClass:(Class)keyClass map:(NSMutableDictionary *)map;

@end

@interface NIActions ()

@property (nonatomic, strong) NSMutableDictionary* objectToAction;
@property (nonatomic, strong) NSMutableDictionary* classToAction;
@property (nonatomic, strong) NSMutableSet* objectSet;

@end

- (id)attachToObject:(id<NSObject>)object tapBlock:(NIActionBlock)action {
  [self.objectSet addObject:object];
  //获取该object对应的action数据结构，并且设置该数据结构对应项的值
  [self actionForObject:object].tapAction = action;
  return object;
}

- (NIObjectActions *)actionForObject:(id<NSObject>)object {
  //获取object的hash key
  id key = [self keyForObject:object];
  //通过object hash key在内部dic中查询NIObjectActions对象，如果没有找到，则新建一个
  NIObjectActions* action = [self.objectToAction objectForKey:key];
  if (nil == action) {
    action = [[NIObjectActions alloc] init];
    [self.objectToAction setObject:action forKey:key];
  }
  return action;
}

@interface NIObjectActions : NSObject

@property (nonatomic, copy) NIActionBlock tapAction;
@property (nonatomic, copy) NIActionBlock detailAction;
@property (nonatomic, copy) NIActionBlock navigateAction;

@property (nonatomic) SEL tapSelector;
@property (nonatomic) SEL detailSelector;
@property (nonatomic) SEL navigateSelector;

@end

- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath {
  NIDASSERT([tableView.dataSource isKindOfClass:[NITableViewModel class]]);
  if ([tableView.dataSource isKindOfClass:[NITableViewModel class]]) {
    NITableViewModel* model = (NITableViewModel *)tableView.dataSource;
    //从model中获取cell内容对象
    id object = [model objectAtIndexPath:indexPath];

    if ([self isObjectActionable:object]) {
      //查询cell内容对象的action对象（NIObjectActions）
      NIObjectActions* action = [self actionForObjectOrClassOfObject:object];

      //如果action对象中设置了tapAction block ，调用之

      BOOL shouldDeselect = NO;
      if (action.tapAction) {
        // Tap actions can deselect the row if they return YES.
        shouldDeselect = action.tapAction(object, self.target, indexPath);
      }

      //如果action对象中设置了tapSelector，并且目标对象（由NITableViewActions对象保存）能响应tapSelector，调用之
      if (action.tapSelector && [self.target respondsToSelector:action.tapSelector]) {
        //多参数不能直接performSelector
        NSMethodSignature *methodSignature = [self.target methodSignatureForSelector:action.tapSelector];
        NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:methodSignature];
        invocation.selector = action.tapSelector;
        if (methodSignature.numberOfArguments >= 3) {
          [invocation setArgument:&object atIndex:2];
        }
        if (methodSignature.numberOfArguments >= 4) {
          [invocation setArgument:&indexPath atIndex:3];
        }
        [invocation invokeWithTarget:self.target];

        NSUInteger length = invocation.methodSignature.methodReturnLength;
        if (length > 0) {
          char *buffer = (void *)malloc(length);
          memset(buffer, 0, sizeof(char) * length);
          [invocation getReturnValue:buffer];
          for (NSUInteger index = 0; index < length; ++index) {
            if (buffer[index]) {
              shouldDeselect = YES;
              break;
            }
          }
          free(buffer);
        }
      }
      if (shouldDeselect) {
        [tableView deselectRowAtIndexPath:indexPath animated:YES];
      }

      if (action.navigateAction) {
        action.navigateAction(object, self.target, indexPath);
      }
      //直接performSelector
      if (action.navigateSelector && [self.target respondsToSelector:action.navigateSelector]) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
        [self.target performSelector:action.navigateSelector withObject:object withObject:indexPath];
#pragma clang diagnostic pop
      }
    }
  }

  // Forward the invocation along.
  for (id<UITableViewDelegate> delegate in self.forwardDelegates) {
    if ([delegate respondsToSelector:_cmd]) {
      [delegate tableView:tableView didSelectRowAtIndexPath:indexPath];
    }
  }
}

self.actions = [[NITableViewActions alloc] initWithTarget:self];
self.testView.delegate = _actions;

NSArray* contentAry = @[
    [_actions attachToObject:[NICellObject objectWithCellClass:[TestCell class] userInfo:@{ @"title" : @"hello" }]
                    tapBlock:^BOOL(id object, id target, NSIndexPath* indexPath) {
                        NSLog(@"%@", indexPath);
                        return YES;
                    }],
    [NICellObject objectWithCellClass:[TestCell class] userInfo:@{ @"title" : @"nimbus" }],
    [NICellObject objectWithCellClass:[TestCell class] userInfo:@{ @"title" : @"what" }],
    [NICellObject objectWithCellClass:[TestCell class] userInfo:@{ @"title" : @"are" }]
];

self.model = [[NITableViewModel alloc] initWithSectionedArray:contentAry
                                                     delegate:(id)[NICellFactory class]];
self.testView.dataSource = _model;

@interface 宿主类名（类别名）
声明方式如下：
@interface HostClass(MyCategory)
-(void) categoryFunc;
@end

//protocol definition
@protocol Myprotocol
-(void) protocolFun;
@end
//use protocol
@interface MyClass : NSObject<Myprotocol>
@end

@protocol MyDelegate
-(void) delegateFunc;
@end
@interface HostClass
{
NSObject<MyDelegate>  *delegate;
}
@end

- (void)setValue:(id)value forKey:(NSString *)key
来设置对象中的属性
- (id)valueForKey:(NSString *)key
来获取对象中的属性
内部调用的是key名称的property，如果没有property，就就直接查找key名称或者_key名称的成员变量
路径
- (id) valueForKeyPath:(NSString *)key
获取路径上的属性值
整体操作
如果向NSArray请求一个键值，它实际上会查询数组中的每个对象来查找这个值，然后讲查询结果打包到另外一个数组并且返回给你
运算符
用- (id) valueForKeyPath:(NSString *)key可以引用一些运算符来进行运算
@count计算左侧的结果,用于计数
@sum计算总和,如:@"cars.@sum.mileage" @sum将结果拆成两部分
@agv计算平均值,如:@"cars.@avg.mileage"
@min取最小值
@max取最大值