Qt MetaObject System-- 元对象系统

一、简介
Qt meta-object系统基于三个方面：
1 QObject提供一个基类，方便派生类使用meta-object系统的功能。
2 Q_OBJECT宏，在类的声明体内激活meta-object功能，比如动态属性，信号，槽
3 Meta Object编译器（MOC），为每个QObject派生类生成代码， 以支持meta-object功能


QObject定义了从一个QObject对象访问meta-object功能的接口，
Q_OBJECT宏用来告诉编译器该类需要激活meta- object功能，编译器在扫描一个源文件时，
如果发现类的声明中有这个宏，就会生成一些代码来为支持meta-object功能——主要是生成
该类对应 MetaObject类以及对QObject的函数override。


QObject和QMetaObject:
QMeatObject包含了QObject的所谓的元数据，也就是QObject信息的一些描述信息：除
了类型信息外,还包含QT中特有的signal&slot信息。
QObject::metaObject ()方法返回一个QObject对象对应的metaobject对象，注意这个
方法是virtual方法。如上文所说，如果一个类的声明中包含了 Q_OBJECT宏，编译器
会生成代码来实现这个类对应的QMetaObject类，并重载QObject::metaObject()
方法来返回这个 QMetaObject类的实例引用。这样当通过QObject类型的引用调用
metaObejct方法时，返回的是这个引用的所指的真实对象的metaobject。


如果一个类从QObject派生，确没有声明Q_OBJECT宏，那么这个类的metaobject对象不
会被生成，这样这个类所声明的 signal slot都不能使用，而这个类实例调用metaObject()
返回的就是其父类的metaobject对象，这样导致的后果就是你从这个类实例获得的元 数据其
实都是父类的数据，这显然给你的代码埋下隐患。因此如果一个类从QOBject派生，它都应该
声明Q_OBJECT宏，不管这个类有没有定义 signal&slot和Property。


这样每个QObject类都有一个对应的QMetaObject类，形成一个平行的类型层次。


QMetaObject提供的信息：
下面通过QMetaObject的接口来解读QMetaObject提供的信息：


1、基本信息
     const char * className () const；
     const QMetaObject * superClass () const
2、classinfo： 提供额外的类信息。其实就是一些名值对。 用户可以在类的声明中以Q_CLASSINFO(name, value)方式添加。
      int classInfoCount () const
      int classInfoOffset () const
      QMetaClassInfo classInfo ( int index ) const
      int indexOfClassInfo ( const char * name ) const
3、contructor：提供该类的构造方法信息
     QMetaMethod constructor ( int index ) const
     int constructorCount () const
     int indexOfConstructor ( const char * constructor ) const
4、enum：描述该类声明体中所包含的枚举类型信息
    QMetaEnum enumerator ( int index ) const
    int enumeratorCount () const
    int enumeratorOffset () const
    int indexOfEnumerator ( const char * name ) const
5、method：描述类中所包含方法信息：包括property,signal,slot等，包括祖先类，如何组织暂时不确定。
    QMetaMethod method ( int index ) const
    int methodCount () const
    int methodOffset () const
    int indexOfMethod ( const char * method ) const
    int indexOfSignal ( const char * signal ) const
    int indexOfSlot ( const char * slot ) const
6、property：类型的属性信息
     QMetaProperty property ( int index ) const
     int propertyCount () const
     int propertyOffset () const
     int indexOfProperty ( const char * name ) const
     QMetaProperty userProperty () const  //返回类中设置了USER flag的属性，（难道只能有一个这样的属性？）
注意：对于类里面定义的函数，构造函数，枚举，只有加上一些宏才表示你希望为方法提供meta信息。
比如 Q_ENUMS用来注册宏，Q_INVACABLE用来注册方法（包括构造函数）。
Qt这么设计的原因应该是避免meta信息的臃肿。


二、meta数据和数据结构
如果一个类的声明中包含Q_OBJECT宏，那么qmake将为这个类生成meta信息，这个信息将保存在moc文件中。
QMetaObject包含唯一的数据成员如下（见头文件qobjectdefs.h）


struct QMetaObject
{
private：
struct { // private data
       const QMetaObject *superdata;  //父类QMetaObject实例的指针
       const char *stringdata;        //一段字符串内存块，包含MetaObject信息之字符串信息
       const uint *data;              //一段二级制内存块，包含MetaObject信息之二进制信息
       const void *extradata;         //额外字段，暂未使用
   } d;
}


QMetaObjectPrivate的数据定义：
QMetaObjectPrivate是QMetaObject的私有实现类，
其数据定义部分如下（见头文件qmetaobject_p.h)。该数据结构全是int类型，一些是直接的int型信息，
比如classInfoCount、methodCount等，还有一些是用于在QMetaObject的stringdata和data内存块中定位信息的索引值。
下文结合这两个内存块的结构再分析个字段的含义。
struct QMetaObjectPrivate
{
   int revision;
   int className;
   int classInfoCount, classInfoData;
   int methodCount, methodData;
   int propertyCount, propertyData;
   int enumeratorCount, enumeratorData;
   int constructorCount, constructorData; //since revision 2
   int flags; //since revision 3
   int signalCount; //since revision 
};
moc文件
qt_meta_data_TestObject：：定义的正是QMetaObject::d.data指向的信息块；

qt_meta_stringdata_TestObject：定义的是QMetaObject::d.dataString指向的信息块；

const QMetaObject TestObject::staticMetaObject ：定义TestObject类的MetaObject
实例，从中可以看出QMetaObject各个字段是如何被赋值的；

const QMetaObject *TestObject::metaObject() const：重写了QObject::metaObject函数，
返回上述的MetaObject实例指针。

TestObject：：qt_metacall()是重写QObject的方法，依据传入的参数来调用signal&slot或
访问property，动态方法调用属性访问正是依赖于这个方法。

TestObject：：clicked（）和TestObject：：pressed（）正是对两个signal的实现，可见，
signal其实就是一种方法，只不过这种方法由qt meta system来实现，不用我们自己实现。


meta信息在moc文件中以静态数据的形式被定义，其排列有点类似可执行文件中静态数据信息的排布。


三、QMetaObject接口实现

QMetaObject::className()
inline const char *QMetaObject::className() const
{ return d.stringdata; }
从前一篇可知，d.stringdata就是那块字符串数据，包含若干c字符串（以'/0'）结尾。
这个字符串序列的第一个字符串，正是类名。


QMetaObject::superClass()
inline const QMetaObject *QMetaObject::superClass() const
{ return d.superdata; }


QMetaObject::classInfoCount()
int QMetaObject::classInfoCount() const
{
   int n = priv(d.data)->classInfoCount;
   const QMetaObject *m = d.superdata;
   while (m) {
       n += priv(m->d.data)->classInfoCount;
       m = m->d.superdata;
   }
   return n;
}
从代码可以看出，返回该类的所有classinfo数目，包括所有基类的。
函数priv是一个简单inline函数：
static inline const QMetaObjectPrivate *priv(const uint* data)
{ return reinterpret_cast<const QMetaObjectPrivate*>(data); }
由前一篇可知，d.data指向的是那块二进制信息，priv将d.data解释为QMetaObjectPrivate。


QMetaObjectPrivate是QMetaObject的私有实现类，其数据定义部分如下（见头文件qmetaobject_p.h)。
struct QMetaObjectPrivate
{
   int revision;
   int className;
   int classInfoCount, classInfoData;
   int methodCount, methodData;
   int propertyCount, propertyData;
   int enumeratorCount, enumeratorData;
   int constructorCount, constructorData; //since revision 2
   int flags; //since revision 3
   int signalCount; //since revision 
};
QMetaObject::classInfoOffset ()
int classInfoOffset () const
{
   int offset = 0;
   const QMetaObject *m = d.superdata;
   while (m) {
       offset += priv(m->d.data)->classInfoCount;
       m = m->d.superdata;
   }
   return offset;
}
该类的含义是返回这个类所定义的classinfo的起始索引值，相当于它的祖先类所定义的classinfo的数量。


QMetaObject::classInfo (int index)
QMetaClassInfo classInfo ( int index ) const
{
   int i = index;
   i -= classInfoOffset();
   if (i < 0 && d.superdata)
       return d.superdata->classInfo(index);


   QMetaClassInfo result;
   if (i >= 0 && i < priv(d.data)->classInfoCount) {
       result.mobj = this;
       result.handle = priv(d.data)->classInfoData + 2*i;
   }
   return result;
}


这个代码的流程比较简单。priv(d.data)->classInfoData是classinfo的信息在d.data中的偏移；
每条classinfo信息占2个UINT的大小，因此“priv(d.data)->classInfoData + 2*i”这个表达式的值
就是第i个classinfo的信息在d.data中的偏移。


QMetaObject::indexOfClassInfo ()
按照继承层次，从下往上寻找名字为name的classinfo。
参考前一函数的解释，表达式m->d.data[priv(m->d.data)->classInfoData + 2*i]的值是第i个classinfo信息
的第一个32位值。该值是字符信息块d.stringdata中的索引值。
因此m->d.stringdata+ m->d.data[priv(m->d.data)->classInfoData + 2*i]就是classinfo名称的字符串。


int constructorCount () const
QMetaMethod constructor ( int index ) const
int indexOfConstructor ( const char * constructor ) const

int enumeratorCount () const
int enumeratorOffset () const
QMetaEnum enumerator ( int index ) const
int indexOfEnumerator ( const char * name ) const


int methodCount () const 
    int methodOffset () const
    QMetaMethod method ( int index ) const
    int indexOfMethod ( const char * method ) const
    int indexOfSignal ( const char * signal ) const
    int QMetaObjectPrivate::indexOfSignalRelative(const QMetaObject **baseObject, const char *signal)
    可以看出，查找signal的特别之处在于，通过method元数据的第五项来判断这是不是一个signal。
    int indexOfSlot ( const char * slot ) const 略；
int propertyCount () const 略；
int propertyOffset () const 略；
int indexOfProperty ( const char * name ) const 略；

QMetaProperty property ( int index ) const
该函数的特别之处在于，如果这个propery是一个枚举类型的话，就为返回值QMetaPropery赋上正确QMetaEnum属性值。
QMetaProperty userProperty () const
从这个函数的实现来看，一个QObject应该只会有一个打开USER flag的property。


四、meta call
所谓meta call就是通过object的meta system的支持来动态调用object的方法，
metacall也是signal&slot的机制的基石。
QMetaObject::invokeMethod()
bool invokeMethod ( 
QObject * obj , 
const char * member , 
Qt::ConnectionType type , 
QGenericReturnArgument ret , 
QGenericArgument val0 = QGenericArgument( 0 ), 
QGenericArgument val1 = QGenericArgument(), 
QGenericArgument val2 = QGenericArgument(), 
QGenericArgument val3 = QGenericArgument(), 
QGenericArgument val4 = QGenericArgument(), 
QGenericArgument val5 = QGenericArgument(), 
QGenericArgument val6 = QGenericArgument(), 
QGenericArgument val7 = QGenericArgument(), 
QGenericArgument val8 = QGenericArgument(), 
QGenericArgument val9 = QGenericArgument() 
)
QMetaObject这个静态方法可以动态地调用obj对象名字为member的方法，
type参数表明该调用时同步的还是异步的。ret是一个通用的用来存储返回值的类型，
后面的9个参数是用来传递调用参数的，QGenericArgument()是一种通用的存储参数值的类型。


所调用的方法必须是invocable的，也就是signal，slot或者是加了声明为Q_INVOCABLE的其他方法。


先依据传递的方法名称和参数，构造完整的函数签名（存储在局部变量sig）。
参数的类型名就是调用时传递时的参数静态类型，这里可不会有什么类型转换，
这是运行时的行为，参数类型转换是编译时的行为。
然后通过这个sig签名在obj中去查找该方法，查询的结果就是一个QMetaMethod值，
再将调用委托给QMetaMethod::invoke方法。


QMetaMethod::invoke
代码首先检查返回值的类型是否正确；再检查参数的个数是否匹配，
再依据当前线程和被调对象所属线程来调整connnection type；
如果是directconnection，直接调用 
QMetaObject::metacall(object, QMetaObject::InvokeMetaMethod, methodIndex, param)，
param是将所有参数值指针排列组成的指针数组。
如果不是directconnection，也即异步调用，
就通过一个post一个QMetaCallEvent到obj，此时须将所有的参数复制一份存入event对象。


QMetaObject::metacall
如果object->d_ptr->metaObject（QMetaObjectPrivate）存在，通过该metaobject来调用，
这个条件实际上就是object就是QObject类型，而不是派生类型。否则调用object::qt_metacall。

QMetaCallEvent


object->qt_metacall
property的动态调用的实现方式一定和invocalbe method是一致的.


五、信号和槽
宏SLOT，SIGNAL
在qobjectdefs.h中有这样的定义：


# define METHOD(a)   "0"#a
# define SLOT(a)     "1"#a
# define SIGNAL(a)   "2"#a
不过是在方法签名之前加了一个数字标记。
因为我们既可以将signal连接到slot，也可以将signal连接到signal，所有必须要有某种方法区分一下。
QObject::connect()
这段代码的做的事情就是将signal在sender的meta system中的signal索引找出，
以及接受者方法（signal或slot）在receiver的meta system中的索引找出来。
在委托QMetaObjectPrivate::connect（）执行连接
QMetaObjectPrivate::connect（）
这段代码首先在connecttype要求UniqueConnection的时候检查一下是不是有重复的连接。
然后创建一个QObjectPrivate::Connection结构，这个结构包含了sender，receiver，
接受方法的method_index，然后加入到某个连接存储表中；连接存储表可能是一种hash结构，signal_index就是key。
可以推测，当signal方法被调用时，一定会到这个结构中查找所有连接到该signal的connection，
connection保存了receiver和method index，由上一篇可知，可以很容易调用到receiver的对应method。