反射（二）

通过上一节的例子，在反射里加入数据成员，属性等，实现更加复杂的对象。

1.实现

#define DATAPROP(n) {&self::n,#n,0}
#define ATTRPROP(n) {&self::get##n,&self::set##n,#n,0}
#define FUNCPROP(n) {&self::n,#n,0}
    class ObjectClass : public Object
    {
        DECL_RTTI(ObjectClass, Object);
        DECL_TPLT(ObjectClass);
    private:
        static  const ClassProperty& GetPropertys()
        {
            const static ClassProperty::BaseProperty bp[] = { &base::GetPropertys,vNull };
            const static DataProperty dp[] =
            {
                DATAPROP(intValue),
                DATAPROP(blValue),
                DATAPROP(sintValue),
                DATAPROP(floatValue),
                DataProperty()
            };
            const static AttrProperty ap[] = 
            { 
                ATTRPROP(Int),
                AttrProperty()
            };
            const static FuncProperty fp[] = { FuncProperty() };
            const static ClassProperty prop(bp, dp, ap, fp);
            return prop;
        }
    private:
        int  getInt()const { return intValue; }
        void setInt(int i) { intValue = i; }
    public:
        int intValue;
        bool blValue;
        sint sintValue;
        f32  floatValue;
    };
    class ClassWithProperty : public Object
    {
        DECL_RTTI(ClassWithProperty, Object);
        DECL_TPLT(ClassWithProperty);
    public:
        static  const ClassProperty& GetPropertys()
        {
            const static ClassProperty::BaseProperty bp[] = { &base::GetPropertys,vNull };
            const static DataProperty dp[] = 
            { 
                DATAPROP(rawString),
                DATAPROP(intValue),
                DATAPROP(blValue),
                DATAPROP(sintValue),
                DATAPROP(floatValue),
                DATAPROP(strValue),
                DATAPROP(objClassPointer),
                DATAPROP(objClassValue),
                DataProperty() 
            };
            const static AttrProperty ap[] = 
            {
                ATTRPROP(Int),
                ATTRPROP(Bool),
                ATTRPROP(Float),
                ATTRPROP(String),
                AttrProperty() 
            };
            const static FuncProperty fp[] = 
            { 
                {&self::getValString,"ValString",0},
                {&self::getPtrString,"PtrString",0},
                {&self::getRefString,"RefString",0},
                FuncProperty() 
            };
            const static ClassProperty prop(bp,dp,ap,fp);
            return prop;
        }
    public: void displayProperty(int depth,const ClassProperty* props)
    {
        if (props == nullptr)return;
            const DataProperty* dp = props->getDataProperty();
            while (dp->type != Type::vNone)
            {
                int n = depth;
                while (n-- >= 0)LOG_P("  ");
                LOG_P("%s %s\n", dp->type.getName(),dp->desc);
                const Type currType = dp->type;
                if (currType != Type::vNone)
                {
                    displayProperty(depth + 1, currType.getPropertys());
                }
                const Type* baseTypes = dp->type.getBaseTypes();
                while (*baseTypes != vNull)
                {
                    displayProperty(depth + 1,baseTypes->getPropertys());
                    baseTypes++;
                }
                dp++;
            }

            const AttrProperty* ap = props->getAttrProperty();
            while (ap->type != Type::vNone)
            {
                int n = depth;
                while (n-- >= 0)LOG_P(" ");
                LOG_P("%s %s\n", ap->type.getName(), ap->desc);
                const Type* baseTypes = ap->type.getBaseTypes();
                ap++;
            }

            const FuncProperty* fp = props->getFuncProperty();
            while (fp->type != Type::vNone) 
            {
                int n = depth;
                while (n-- >= 0)LOG_P(" ");
                LOG_P("%s %s\n", fp->type.getName(), fp->desc);
                const Type* baseTypes = fp->type.getBaseTypes();
                fp++;
            }
        }
    public:
        int  getInt()const { return intValue; }
        void setInt(int i) { intValue = i; }
        bool getBool()const { return blValue; }
        void setBool(bool b) { blValue = b; }
        sint getLong()const { return sintValue; }
        void setLong(sint l) { sintValue = l; }
        f32  getFloat()const { return floatValue; }
        void setFloat(f32 f) { floatValue = f; }
        void setString(AString s) { strValue = s; }
        AString getString()const { return strValue; }
    public:
        const AString& getRefString(const AString& i)
        {
            LOG_P("RefString:%s\n", i.getRawString());
            static AString as = AtomString("atomString"); 
            return as;
        }
        const AString  getValString(const AString  i)
        {
            LOG_P("ValString:%s\n", i.getRawString());
            return AtomString("atomString"); 
        }
        const AString* getPtrString(const AString* i)
        { 
            LOG_P("PtrString:%s\n", i->getRawString());
            static AString as = AtomString("atomString"); return &as; 
        }
    private:
        char* rawString;
        AString strValue;
        int intValue;
        bool blValue;
        sint sintValue;
        f32  floatValue;
        ObjectClass* objClassPointer;
        ObjectClass  objClassValue;
    };

 

 

2.使用

        ClassWithProperty ct;
        ct.displayProperty(0, &ct.getProperty());
        ct.DataMember["blValue"] = "true";
        bool bl = ct.DataMember["blValue"];
        std::cout << bl << std::endl;
        ct.DataMember["objClassValue"]["intValue"] = "12";
        int rf = ct.DataMember["objClassValue"]["intValue"];
        std::cout << rf << std::endl;
        Object& subObj = ct.DataMember["objClassValue"];
        subObj.DataMember["intValue"] = 13.5f;
        unsigned int rf2 = ct.DataMember["objClassValue"]["intValue"];
        std::cout << rf2 << std::endl;
        u32 iv = ct.DataMember["objClassValue"]["intValue"];
        std::cout << iv << std::endl;
        float rfu8 = ct.DataMember["objClassValue"]["intValue"];
        std::cout << rfu8 << std::endl;
        double rfud = ct.DataMember["objClassValue"]["intValue"];
        std::cout << rfud << std::endl;

        FuncProperty fp = ct.getProperty().getFuncProperty("ValString");
        AString s = fp.invoke<AString, AString>(&ct,"value");
        LOG_P("ValString ret:%s\n", s.getRawString());

        fp = ct.getProperty().getFuncProperty("RefString");
        AString& rs = fp.invoke<AString&>(&ct, &AString("reff"));
        LOG_P("RefString ret:%s\n", rs.getRawString());

        fp = ct.getProperty().getFuncProperty("PtrString");
        AString* ps = fp.invoke<AString*, AString*>(&ct, &AString("pointer"));
        LOG_P("PtrString ret:%s\n", ps->getRawString());

3.结果