YYModel 源码解读（二）之YYClassInfo.h (1)

 NS_ASSUME_NONNULL_BEGIN
 NS_ASSUME_NONNULL_END

为了兼容Swift 中的 ? 和 ! oc 在6.3引入了两个新的类型注释：__nullable和__nonnull ， 在字面上很好理解 可能为空， 不为空，

在上面代码中间则表示 默认的所有的属性都不能为空，这样我们在敲码的过程中只需要手写__nullable的类型就可以了 

 /**
  Type encoding's type.
  */
 typedef NS_OPTIONS(NSUInteger, YYEncodingType) {
     YYEncodingTypeMask       = 0xFF, ///< mask of type value
     YYEncodingTypeUnknown    = 0, ///< unknown
     YYEncodingTypeVoid       = 1, ///< void
     YYEncodingTypeBool       = 2, ///< bool
     YYEncodingTypeInt8       = 3, ///< char / BOOL
     YYEncodingTypeUInt8      = 4, ///< unsigned char
     YYEncodingTypeInt16      = 5, ///< short
     YYEncodingTypeUInt16     = 6, ///< unsigned short
     YYEncodingTypeInt32      = 7, ///< int
     YYEncodingTypeUInt32     = 8, ///< unsigned int
     YYEncodingTypeInt64      = 9, ///< long long
     YYEncodingTypeUInt64     = 10, ///< unsigned long long
     YYEncodingTypeFloat      = 11, ///< float
     YYEncodingTypeDouble     = 12, ///< double
     YYEncodingTypeLongDouble = 13, ///< long double
     YYEncodingTypeObject     = 14, ///< id
     YYEncodingTypeClass      = 15, ///< Class
     YYEncodingTypeSEL        = 16, ///< SEL
     YYEncodingTypeBlock      = 17, ///< block
     YYEncodingTypePointer    = 18, ///< void*
     YYEncodingTypeStruct     = 19, ///< struct
     YYEncodingTypeUnion      = 20, ///< union
     YYEncodingTypeCString    = 21, ///< char*
     YYEncodingTypeCArray     = 22, ///< char[10] (for example)

     YYEncodingTypeQualifierMask   = 0xFF00,   ///< mask of qualifier
     YYEncodingTypeQualifierConst  = 1 << 8,  ///< const
     YYEncodingTypeQualifierIn     = 1 << 9,  ///< in
     YYEncodingTypeQualifierInout  = 1 << 10, ///< inout
     YYEncodingTypeQualifierOut    = 1 << 11, ///< out
     YYEncodingTypeQualifierBycopy = 1 << 12, ///< bycopy
     YYEncodingTypeQualifierByref  = 1 << 13, ///< byref
     YYEncodingTypeQualifierOneway = 1 << 14, ///< oneway

     YYEncodingTypePropertyMask         = 0xFF0000, ///< mask of property
     YYEncodingTypePropertyReadonly     = 1 << 16, ///< readonly
     YYEncodingTypePropertyCopy         = 1 << 17, ///< copy
     YYEncodingTypePropertyRetain       = 1 << 18, ///< retain
     YYEncodingTypePropertyNonatomic    = 1 << 19, ///< nonatomic
     YYEncodingTypePropertyWeak         = 1 << 20, ///< weak
     YYEncodingTypePropertyCustomGetter = 1 << 21, ///< getter=
     YYEncodingTypePropertyCustomSetter = 1 << 22, ///< setter=
     YYEncodingTypePropertyDynamic      = 1 << 23, ///< @dynamic
 };

上边的代码 就涉及到了运行时中的类型解码方面的知识了，在此总结一下

关于Type Encodings 的官方解释 ， @encode 是一个编译器指令，返回个内部表示的字符串 ， 比如： @encode(int)→ i ，作用就是可以加快运行时库的消息分发，

需要注意的是：

• 指针的标准编码是加一个前置的 ^，而 char * 拥有自己的编码 *。这在概念上是很好理解的，因为 C 的字符串被认为是一个实体，而不是指针。
• BOOL 是 c，而不是某些人以为的 i。原因是 char 比 int 小，且在 80 年代 Objective-C 最开始设计的时候，每一个 bit 位都比今天的要值钱（就像美元一样）。BOOL 更确切地说是 signed char （即使设置了 -funsigned-char 参数），以在不同编译器之间保持一致，因为 char 可以是 signed 或者 unsigned。
• 直接传入 NSObject 将产生 #。但是传入 [NSObject class] 产生一个名为 NSObject 只有一个类字段的结构体。很明显，那就是 isa 字段，所有的 NSObject 实例都用它来表示自己的类型。

通过打印的数据，看起来更加直观

  NSLog(@"int        : %s", @encode(int));
         NSLog(@"float      : %s", @encode(float));
         NSLog(@"float *    : %s", @encode(float*));
         NSLog(@"char       : %s", @encode(char));
         NSLog(@"char *     : %s", @encode(char *));
         NSLog(@"BOOL       : %s", @encode(BOOL));
         NSLog(@"void       : %s", @encode(void));
         NSLog(@"void *     : %s", @encode(void *));

         NSLog(@"NSObject * : %s", @encode(NSObject *));
         NSLog(@"NSObject   : %s", @encode(NSObject));
         NSLog(@"[NSObject] : %s", @encode(typeof([NSObject class])));
         NSLog(@"NSError ** : %s", @encode(typeof(NSError **)));

         int intArray[] = {, , , , };
         NSLog(@"int[]      : %s", @encode(typeof(intArray)));

         float floatArray[] = {0.1f, 0.2f, 0.3f};
         NSLog(@"float[]    : %s", @encode(typeof(floatArray)));

         typedef struct _struct {
             short a;
             long long b;
             unsigned long long c;
         } Struct;
         NSLog(@"struct     : %s", @encode(typeof(Struct)));

 -- ::00.172 ModelBenchmark[:] int        : i
 -- ::00.173 ModelBenchmark[:] float      : f
 -- ::00.173 ModelBenchmark[:] float *    : ^f
 -- ::00.173 ModelBenchmark[:] char       : c
 -- ::00.173 ModelBenchmark[:] char *     : *
 -- ::00.173 ModelBenchmark[:] BOOL       : B
 -- ::00.174 ModelBenchmark[:] void       : v
 -- ::00.174 ModelBenchmark[:] void *     : ^v
 -- ::00.174 ModelBenchmark[:] NSObject * : @
 -- ::00.174 ModelBenchmark[:] NSObject   : {NSObject=#}
 -- ::00.174 ModelBenchmark[:] [NSObject] : #
 -- ::00.174 ModelBenchmark[:] NSError ** : ^@
 -- ::00.174 ModelBenchmark[:] int[]      : [5i]
 -- ::00.174 ModelBenchmark[:] float[]    : [3f]
 -- ::00.174 ModelBenchmark[:] struct     : {_struct=sqQ}

关于 Type Property 和 Functions 的官方解释 ，可以参考官方文档获取编译后的内容

 YYEncodingType YYEncodingGetType(const char *typeEncoding);

定义一个方法 把typeEncoding 转为自定义的枚举类型，方便管理和使用，

 YYEncodingType YYEncodingGetType(const char *typeEncoding) {

     // 判断外部传入值 是不是nil，如果为空 ，返回 YYEncodingTypeUnknown
     // 转换const 限定符
     char *type = (char *)typeEncoding;
     if (!type) return YYEncodingTypeUnknown;
     size_t len = strlen(type);
     if (len == ) return YYEncodingTypeUnknown;

     // 找出修饰语
     YYEncodingType qualifier = ;
     bool prefix = true;

     // 可能多个修饰符
     while (prefix) {

         switch (*type) {
             case 'r': {
                 qualifier |= YYEncodingTypeQualifierConst;
                 type++;
             } break;
             case 'n': {
                 qualifier |= YYEncodingTypeQualifierIn;
                 type++;
             } break;
             case 'N': {
                 qualifier |= YYEncodingTypeQualifierInout;
                 type++;
             } break;
             case 'o': {
                 qualifier |= YYEncodingTypeQualifierOut;
                 type++;
             } break;
             case 'O': {
                 qualifier |= YYEncodingTypeQualifierBycopy;
                 type++;
             } break;
             case 'R': {
                 qualifier |= YYEncodingTypeQualifierByref;
                 type++;
             } break;
             case 'V': {
                 qualifier |= YYEncodingTypeQualifierOneway;
                 type++;
             } break;
             default: { prefix = false; } break;
         }
     }

     // 是否还存在后续的字符
     len = strlen(type);
     if (len == ) return YYEncodingTypeUnknown | qualifier;

     // 查找数据类型
     switch (*type) {
         case 'v': return YYEncodingTypeVoid | qualifier;
         case 'B': return YYEncodingTypeBool | qualifier;
         case 'c': return YYEncodingTypeInt8 | qualifier;
         case 'C': return YYEncodingTypeUInt8 | qualifier;
         case 's': return YYEncodingTypeInt16 | qualifier;
         case 'S': return YYEncodingTypeUInt16 | qualifier;
         case 'i': return YYEncodingTypeInt32 | qualifier;
         case 'I': return YYEncodingTypeUInt32 | qualifier;
         case 'l': return YYEncodingTypeInt32 | qualifier;
         case 'L': return YYEncodingTypeUInt32 | qualifier;
         case 'q': return YYEncodingTypeInt64 | qualifier;
         case 'Q': return YYEncodingTypeUInt64 | qualifier;
         case 'f': return YYEncodingTypeFloat | qualifier;
         case 'd': return YYEncodingTypeDouble | qualifier;
         case 'D': return YYEncodingTypeLongDouble | qualifier;
         case '#': return YYEncodingTypeClass | qualifier;
         case ':': return YYEncodingTypeSEL | qualifier;
         case '*': return YYEncodingTypeCString | qualifier;
         case '^': return YYEncodingTypePointer | qualifier;
         case '[': return YYEncodingTypeCArray | qualifier;
         case '(': return YYEncodingTypeUnion | qualifier;
         case '{': return YYEncodingTypeStruct | qualifier;
         case '@': {
             if (len ==  && *(type + ) == '?')
                 return YYEncodingTypeBlock | qualifier;
             else
                 return YYEncodingTypeObject | qualifier;
         }
         default: return YYEncodingTypeUnknown | qualifier;
     }
 }

上边的方法 主要是找出所有的和属性相关的信息，并转换为自定义的类型