ZFClass.h

Go to the documentation of this file.

 
#ifndef _ZFI_ZFClass_h_
#define _ZFI_ZFClass_h_
 
#include "zfautoFwd.h"
#include "ZFObjectObserver.h"
ZF_NAMESPACE_GLOBAL_BEGIN
 
// ============================================================
typedef zfbool (*zfconvImpl)(ZF_OUT zfauto &ret, ZF_IN const zfany &obj);
 
// ============================================================
typedef ZFObject *(*_ZFP_ZFObjectConstructor)(void);
typedef void (*_ZFP_ZFObjectDestructor)(ZF_IN ZFObject *obj);
typedef void (*_ZFP_ZFObjectCheckInitImplementationListCallback)(ZF_IN_OUT ZFClass *cls);
typedef ZFInterface * (*_ZFP_ZFObjectToInterfaceCastCallback)(ZF_IN ZFObject *obj);
 
// ============================================================
zffinal zfclassLikePOD ZFLIB_ZFCore ZFClassInstanceObserverAddParam {
    ZFCORE_PARAM_DECLARE_SELF(ZFClassInstanceObserverAddParam)
 
    
    ZFCORE_PARAM(ZFListener, observer)

    ZFCORE_PARAM(zfany, owner, zfnull)

    ZFCORE_PARAM(ZFLevel, observerLevel, ZFLevelAppNormal)

    ZFCORE_PARAM(zfbool, observeAllChildType, zftrue)
 
public:
    zfbool operator == (ZF_IN ZFClassInstanceObserverAddParam const &ref) const {
        return (zftrue
                && this->observer() == ref.observer()
                && this->owner() == ref.owner()
                && this->observerLevel() == ref.observerLevel()
                && this->observeAllChildType() == ref.observeAllChildType()
            );
    }
    zfbool operator != (ZF_IN ZFClassInstanceObserverAddParam const &ref) const {
        return !(this->operator == (ref));
    }
};
 
// ============================================================
zfclassFwd _ZFP_ZFClassPrivate;
zfclassFwd _ZFP_ZFObjectPrivate;
zffinal zfclassNotPOD ZFLIB_ZFCore ZFClass {
    ZFCLASS_DISALLOW_COPY_CONSTRUCTOR(ZFClass)
 
    // ============================================================
    // static methods
public:
    static const ZFClass *classForName(ZF_IN const zfstring &classNameOrFullName);
    static const ZFClass *classForName(
            ZF_IN const zfstring &className
            , ZF_IN const zfstring &classNamespace
            );
 
    // ============================================================
    // instance observer
public:
    void instanceObserverAdd(
            ZF_IN const ZFListener &observer
            , ZF_IN_OPT ZFObject *owner = zfnull
            , ZF_IN_OPT ZFLevel observerLevel = ZFLevelAppNormal
            , ZF_IN_OPT zfbool observeAllChildType = zftrue
            ) const;
    inline void instanceObserverAdd(ZF_IN const ZFClassInstanceObserverAddParam &param) const {
        this->instanceObserverAdd(param.observer(), param.owner(), param.observerLevel(), param.observeAllChildType());
    }

    void instanceObserverRemove(ZF_IN const ZFListener &observer) const;
    void instanceObserverRemoveByOwner(ZF_IN ZFObject *owner) const;
    void instanceObserverRemoveAll(void) const;
    void _ZFP_ZFClass_instanceObserverNotify(ZF_IN ZFObject *obj) const;
 
    // ============================================================
    // class info
public:
    void objectInfoT(ZF_IN_OUT zfstring &ret) const;
    zfstring objectInfo(void) const {
        zfstring ret;
        this->objectInfoT(ret);
        return ret;
    }

    void objectInfoOfInheritTreeT(ZF_IN_OUT zfstring &ret) const;
    zfstring objectInfoOfInheritTree(void) const {
        zfstring ret;
        this->objectInfoOfInheritTreeT(ret);
        return ret;
    }
 
public:
    zfbool classIsTypeOf(ZF_IN const ZFClass *cls) const;
 
public:
    const ZFCoreArray<zfstring> &classAliasTo(void) const;

    inline const zfstring &classNamespace(void) const {
        return this->_classNamespace;
    }

    inline const zfstring &className(void) const {
        return this->_className;
    }

    inline const zfstring &classNameFull(void) const {
        return this->_classNameFull;
    }

    inline const ZFClass *classParent(void) const {
        return this->_classParent;
    }

    zfbool classContainDynamicRegister(void) const {
        return ZFBitTest(_stateFlags, _stateFlags_classContainDynamicRegister);
    }

    zfbool classIsDynamicRegister(void) const {
        return ZFBitTest(_stateFlags, _stateFlags_classIsDynamicRegister);
    }

    zfany classDynamicRegisterUserData(void) const;
    inline zfbool classIsAbstract(void) const {
        return ZFBitTest(_stateFlags, _stateFlags_classIsAbstract);
    }

    inline zfbool classIsInterface(void) const {
        return ZFBitTest(_stateFlags, _stateFlags_classIsInterface);
    }

    inline zfbool classIsInternal(void) const {
        return ZFBitTest(_stateFlags, _stateFlags_classIsInternal);
    }

    inline zfbool classIsInternalPrivate(void) const {
        return ZFBitTest(_stateFlags, _stateFlags_classIsInternalPrivate);
    }

    inline zfbool classCanAllocPublic(void) const {
        return !this->_ZFP_ZFClass_classCanNotAllocPublic();
    }

    zfauto newInstance(void) const;
 
    /* ZFMETHOD_MAX_PARAM */
    zfauto newInstance(
            ZF_IN ZFObject *param0
            , ZF_IN_OPT ZFObject *param1 = ZFMP_DEF()
            , ZF_IN_OPT ZFObject *param2 = ZFMP_DEF()
            , ZF_IN_OPT ZFObject *param3 = ZFMP_DEF()
            , ZF_IN_OPT ZFObject *param4 = ZFMP_DEF()
            , ZF_IN_OPT ZFObject *param5 = ZFMP_DEF()
            , ZF_IN_OPT ZFObject *param6 = ZFMP_DEF()
            , ZF_IN_OPT ZFObject *param7 = ZFMP_DEF()
            ) const;
    zfauto newInstanceDetail(
            ZF_IN const ZFCoreArray<zfauto> &params
            , ZF_OUT_OPT zfbool *success = zfnull
            , ZF_OUT_OPT zfstring *errorHint = zfnull
            ) const;

    void *newInstanceGenericBegin(void) const;
    zfbool newInstanceGenericCheck(
            ZF_IN void *&token
            , ZF_IN const ZFMethod *objectOnInitMethod
            , ZF_IN_OUT const ZFArgs &zfargs
            ) const;
    zfauto newInstanceGenericEnd(
            ZF_IN void *&token
            , ZF_IN zfbool objectOnInitMethodInvokeSuccess
            ) const;
 
    zffinal zfauto _ZFP_ZFClass_newInstance(ZF_IN _ZFP_ZFObjectPrivate *dObj) const;

    zfindex implementedInterfaceCount(void) const;
    const ZFClass *implementedInterfaceAt(ZF_IN zfindex index) const;
    zfindex dynamicInterfaceCount(void) const;
    const ZFClass *dynamicInterfaceAt(ZF_IN zfindex index) const;
    zfbool dynamicImplementOf(ZF_IN const ZFClass *parent) const;

    ZFCoreArray<const ZFClass *> childGetAll(void) const;
    ZFCoreArray<const ZFClass *> parentGetAll(void) const;
 
    // ============================================================
    // ZFMethod
public:
    zfindex methodCount(void) const;
    zfiter methodIter(void) const;
    const ZFMethod *methodIterValue(ZF_IN const zfiter &it) const;

    void methodGetAllIgnoreParentT(ZF_IN_OUT ZFCoreArray<const ZFMethod *> &ret) const;
    ZFCoreArray<const ZFMethod *> methodGetAllIgnoreParent(void) const {
        ZFCoreArray<const ZFMethod *> ret;
        this->methodGetAllIgnoreParentT(ret);
        return ret;
    }

    void methodGetAllT(ZF_IN_OUT ZFCoreArray<const ZFMethod *> &ret) const;
    ZFCoreArray<const ZFMethod *> methodGetAll(void) const {
        ZFCoreArray<const ZFMethod *> ret;
        this->methodGetAllT(ret);
        return ret;
    }
 
    /* ZFMETHOD_MAX_PARAM */
    const ZFMethod *methodForNameIgnoreParent(
            ZF_IN const zfstring &methodName
            , ZF_IN const zfchar *paramTypeId0
            , ZF_IN_OPT const zfchar *paramTypeId1 = zfnull
            , ZF_IN_OPT const zfchar *paramTypeId2 = zfnull
            , ZF_IN_OPT const zfchar *paramTypeId3 = zfnull
            , ZF_IN_OPT const zfchar *paramTypeId4 = zfnull
            , ZF_IN_OPT const zfchar *paramTypeId5 = zfnull
            , ZF_IN_OPT const zfchar *paramTypeId6 = zfnull
            , ZF_IN_OPT const zfchar *paramTypeId7 = zfnull
            ) const;
    const ZFMethod *methodForNameIgnoreParent(ZF_IN const zfstring &methodName) const;
    void methodForNameGetAllIgnoreParentT(
            ZF_IN_OUT ZFCoreArray<const ZFMethod *> &ret
            , ZF_IN const zfstring &methodName
            ) const;
    ZFCoreArray<const ZFMethod *> methodForNameGetAllIgnoreParent(ZF_IN const zfstring &methodName) const {
        ZFCoreArray<const ZFMethod *> ret;
        this->methodForNameGetAllIgnoreParentT(ret, methodName);
        return ret;
    }

    const ZFMethod *methodForName(
            ZF_IN const zfstring &methodName
            , ZF_IN const zfchar *paramTypeId0
            , ZF_IN_OPT const zfchar *paramTypeId1 = zfnull
            , ZF_IN_OPT const zfchar *paramTypeId2 = zfnull
            , ZF_IN_OPT const zfchar *paramTypeId3 = zfnull
            , ZF_IN_OPT const zfchar *paramTypeId4 = zfnull
            , ZF_IN_OPT const zfchar *paramTypeId5 = zfnull
            , ZF_IN_OPT const zfchar *paramTypeId6 = zfnull
            , ZF_IN_OPT const zfchar *paramTypeId7 = zfnull
            ) const;
    const ZFMethod *methodForName(ZF_IN const zfstring &methodName) const;
    void methodForNameGetAllT(
            ZF_IN_OUT ZFCoreArray<const ZFMethod *> &ret
            , ZF_IN const zfstring &methodName
            ) const;
    ZFCoreArray<const ZFMethod *> methodForNameGetAll(ZF_IN const zfstring &methodName) const {
        ZFCoreArray<const ZFMethod *> ret;
        this->methodForNameGetAllT(ret, methodName);
        return ret;
    }
 
    // ============================================================
    // ZFProperty
public:
    zfindex propertyCount(void) const;
    zfiter propertyIter(void) const;
    const ZFProperty *propertyIterValue(ZF_IN const zfiter &it) const;

    void propertyGetAllIgnoreParentT(ZF_IN_OUT ZFCoreArray<const ZFProperty *> &ret) const;
    ZFCoreArray<const ZFProperty *> propertyGetAllIgnoreParent(void) const {
        ZFCoreArray<const ZFProperty *> ret;
        this->propertyGetAllIgnoreParentT(ret);
        return ret;
    }

    void propertyGetAllT(ZF_IN_OUT ZFCoreArray<const ZFProperty *> &ret) const;
    ZFCoreArray<const ZFProperty *> propertyGetAll(void) const {
        ZFCoreArray<const ZFProperty *> ret;
        this->propertyGetAllT(ret);
        return ret;
    }

    const ZFProperty *propertyForNameIgnoreParent(ZF_IN const zfstring &propertyName) const;
    const ZFProperty *propertyForName(ZF_IN const zfstring &propertyName) const;

    const ZFMethod *propertySetterForNameIgnoreParent(ZF_IN const zfstring &propertyName) const;
    const ZFMethod *propertySetterForName(ZF_IN const zfstring &propertyName) const;
    const ZFMethod *propertyGetterForNameIgnoreParent(ZF_IN const zfstring &propertyName) const;
    const ZFMethod *propertyGetterForName(ZF_IN const zfstring &propertyName) const;

    zfbool propertyInitStepExist(void) const;
    zfbool propertyInitStepExist(ZF_IN const ZFProperty *property) const;

    zfbool propertyInitStepIsEqual(
            ZF_IN const ZFProperty *property
            , ZF_IN const ZFClass *refClass
            ) const;
 
public:
    void zfconvRegister(ZF_IN const ZFClass *dstCls, ZF_IN zfconvImpl impl) const;
    void zfconvUnregister(ZF_IN const ZFClass *dstCls) const;
    zfconvImpl zfconvCheck(ZF_IN const zfstring &dstCls) const;
    zfconvImpl zfconvCheck(ZF_IN const ZFClass *dstCls) const;
 
    // ============================================================
    // class instance methods
public:
    void classTag(
            ZF_IN const zfstring &key
            , ZF_IN ZFObject *tag
            ) const;
    zfany classTag(ZF_IN const zfstring &key) const;
    zffinal void classTagGetAllKeyValue(
            ZF_IN_OUT ZFCoreArray<zfstring> &allKey
            , ZF_IN_OUT ZFCoreArray<zfauto> &allValue
            ) const;
    inline void classTagRemove(ZF_IN const zfstring &key) const {
        this->classTag(key, zfnull);
    }

    zffinal zfauto classTagRemoveAndGet(ZF_IN const zfstring &key) const;
    zffinal void classTagRemoveAll(void) const;
 
    // ============================================================
    void dataCache(
            ZF_IN const zfstring &key
            , ZF_IN ZFObject *tag
            ) const;
    zfany dataCache(ZF_IN const zfstring &key) const;
    zffinal void dataCacheGetAllKeyValue(
            ZF_IN_OUT ZFCoreArray<zfstring> &allKey
            , ZF_IN_OUT ZFCoreArray<zfauto> &allValue
            ) const;
    inline void dataCacheRemove(ZF_IN const zfstring &key) const {
        this->dataCache(key, zfnull);
    }

    zffinal zfauto dataCacheRemoveAndGet(ZF_IN const zfstring &key) const;
    zffinal void dataCacheRemoveAll(void) const;
 
    // ============================================================
    zffinal zfidentity classId(void) const {
        return _classNameFull.sigId();
    }
 
    // ============================================================
    // private
public:
    static ZFClass *_ZFP_ZFClassRegister(
            ZF_IN const zfstring &classNamespace
            , ZF_IN const zfstring &className
            , ZF_IN const ZFClass *parent
            , ZF_IN const ZFClass *outer
            , ZF_IN zfbool classCanAllocPublic
            , ZF_IN _ZFP_ZFObjectConstructor constructor
            , ZF_IN _ZFP_ZFObjectDestructor destructor
            , ZF_IN _ZFP_ZFObjectCheckInitImplementationListCallback checkInitImplListCallback
            , ZF_IN zfbool classIsInterface
            , ZF_IN zfbool classIsDynamicRegister
            , ZF_IN ZFObject *classDynamicRegisterUserData
            );
    static void _ZFP_ZFClassUnregister(ZF_IN const ZFClass *cls);
    ZFClass(void);
    ~ZFClass(void);
    void _ZFP_ZFClass_release(void);
    void _ZFP_ZFClass_autoRegister(void) const;
    inline zfbool _ZFP_ZFClass_interfaceHasRegisterCk(void) const {
        return ZFBitTest(_stateFlags, _stateFlags_interfaceHasRegisterCk);
    }
    inline void _ZFP_ZFClass_interfaceHasRegisterCk(ZF_IN zfbool v) {
        if(v) {
            ZFBitSet(_stateFlags, _stateFlags_interfaceHasRegisterCk);
        }
        else {
            ZFBitUnset(_stateFlags, _stateFlags_interfaceHasRegisterCk);
        }
    }
    zfbool _ZFP_ZFClass_interfaceHasRegister(void) {
        return ZFBitTest(_stateFlags, _stateFlags_interfaceHasRegister);
    }
    void _ZFP_ZFClass_interfaceRegister(
            ZF_IN zfint dummy
            , ZF_IN const ZFClass *cls
            , ZF_IN _ZFP_ZFObjectToInterfaceCastCallback callback
            , ...
            );
    ZFInterface *_ZFP_ZFClass_interfaceCast(
            ZF_IN ZFObject *obj
            , ZF_IN const ZFClass *interfaceClass
            ) const;
    ZFObject *_ZFP_ZFClass_objectCast(
            ZF_IN ZFObject *obj
            , ZF_IN const ZFClass *objectClass
            ) const;
    ZFObject *_ZFP_ZFClass_objectCastNoExt(
            ZF_IN ZFObject *obj
            , ZF_IN const ZFClass *objectClass
            ) const;
 
    zfbool _ZFP_ZFClass_ZFImplementDynamicRegister(ZF_IN const ZFClass *clsToImplement) const;
    void _ZFP_ZFClass_ZFImplementDynamicUnregister(ZF_IN const ZFClass *clsToImplement) const;
 
    void _ZFP_ZFClass_objectDesctuct(ZF_IN ZFObject *obj) const;
    inline ZFClass *_ZFP_ZFClass_removeConst(void) const {
        return const_cast<ZFClass *>(this);
    }
 
    void _ZFP_ZFClass_methodRegister(ZF_IN const ZFMethod *method) const;
    void _ZFP_ZFClass_methodUnregister(ZF_IN const ZFMethod *method) const;
    void _ZFP_ZFClass_propertyRegister(ZF_IN const ZFProperty *zfproperty) const;
    void _ZFP_ZFClass_propertyUnregister(ZF_IN const ZFProperty *zfproperty) const;
    void _ZFP_ZFClass_propertyAutoInitRegister(ZF_IN const ZFProperty *property) const;
    void _ZFP_ZFClass_propertyAutoInitAction(ZF_IN ZFObject *owner) const;
    void _ZFP_ZFClass_propertyInitStepRegister(ZF_IN const ZFProperty *property) const;
 
    _ZFP_ZFObjectConstructor _ZFP_objectConstructor(void) const;
    _ZFP_ZFObjectDestructor _ZFP_objectDestructor(void) const;
    void _ZFP_classDynamicRegisterObjectInstanceDetach(ZF_IN ZFObject *obj) const;
 
    inline zfbool _ZFP_ZFClass_classCanNotAllocPublic(void) const {
        return ZFBitTest(_stateFlags, _stateFlags_classCanNotAllocPublic);
    }
    inline void _ZFP_ZFClass_classCanNotAllocPublic(ZF_IN zfbool v) {
        if(v) {
            ZFBitSet(_stateFlags, _stateFlags_classCanNotAllocPublic);
        }
        else {
            ZFBitUnset(_stateFlags, _stateFlags_classCanNotAllocPublic);
        }
    }
 
private:
    friend zfclassFwd _ZFP_ZFClassPrivate;
    enum {
        _stateFlags_classIsAbstract = 1 << 0,
        _stateFlags_classIsInterface = 1 << 1,
        _stateFlags_classIsInternal = 1 << 2,
        _stateFlags_classIsInternalPrivate = 1 << 3,
        _stateFlags_classIsDynamicRegister = 1 << 4,
        _stateFlags_classContainDynamicRegister = 1 << 5,
        _stateFlags_classCanNotAllocPublic = 1 << 6,
        _stateFlags_interfaceHasRegisterCk = 1 << 7,
        _stateFlags_interfaceHasRegister = 1 << 8,
        _stateFlags_methodAndPropertyCacheNeedUpdate = 1 << 9,
        _stateFlags_hasAutoRegister = 1 << 10,
    };
private:
    _ZFP_ZFClassPrivate *d;
    zfuint _refCount;
    zfuint _stateFlags;
    const ZFClass *_classParent;
    ZFSigName _classNamespace;
    ZFSigName _className;
    ZFSigName _classNameFull;
};

#define ZFObjectTagKeyword_newInstanceGenericFailed zftext("_ZFP_NIGFail")
 
// ============================================================
zfclassLikePOD ZFLIB_ZFCore _ZFP_ZFClassRegisterHolder {
public:
    _ZFP_ZFClassRegisterHolder(
            ZF_IN const zfstring &classNamespace
            , ZF_IN const zfstring &className
            , ZF_IN const ZFClass *parent
            , ZF_IN const ZFClass *outer
            , ZF_IN zfbool classCanAllocPublic
            , ZF_IN _ZFP_ZFObjectConstructor constructor
            , ZF_IN _ZFP_ZFObjectDestructor destructor
            , ZF_IN _ZFP_ZFObjectCheckInitImplementationListCallback checkInitImplListCallback
            , ZF_IN_OPT zfbool classIsInterface = zffalse
            , ZF_IN_OPT zfbool classIsDynamicRegister = zffalse
            , ZF_IN_OPT ZFObject *classDynamicRegisterUserData = zfnull
            );
    ~_ZFP_ZFClassRegisterHolder(void);
public:
    ZFClass *cls;
};
 
// ============================================================
extern ZFLIB_ZFCore void ZFClassGetAllT(ZF_IN_OUT ZFCoreArray<const ZFClass *> &ret);
inline ZFCoreArray<const ZFClass *> ZFClassGetAll(void) {
    ZFCoreArray<const ZFClass *> ret;
    ZFClassGetAllT(ret);
    return ret;
}
 
// ============================================================
ZF_NAMESPACE_BEGIN(ZFGlobalEvent)
ZFEVENT_GLOBAL(ZFLIB_ZFCore, ClassDataUpdate)
ZF_NAMESPACE_END(ZFGlobalEvent)
 
extern ZFLIB_ZFCore ZFObserver &_ZFP_ZFClassDataUpdateObserverRef(void);
#define ZFClassDataUpdateObserver() (_ZFP_ZFClassDataUpdateObserverRef())
 
// ============================================================
zfclassNotPOD ZFLIB_ZFCore _ZFP_ZFCoreCriticalClassNotTypeOf {
public:
    static zfstring classInfo(ZF_IN const ZFClass *cls) {
        if(cls) {
            return cls->classNameFull();
        }
        else {
            return ZFTOKEN_zfnull;
        }
    }
};
#define ZFCoreCriticalClassNotTypeOf(cls, desired) \
    ZFCoreCriticalMessage("class %s not type of %s", \
        _ZFP_ZFCoreCriticalClassNotTypeOf::classInfo(cls), \
        _ZFP_ZFCoreCriticalClassNotTypeOf::classInfo(desired))

#define ZFCoreCriticalClassNotTypeOfDetail(callerInfo, cls, desired) \
    ZFCoreCriticalMessageDetail(callerInfo, "class %s not type of %s", \
        _ZFP_ZFCoreCriticalClassNotTypeOf::classInfo(cls), \
        _ZFP_ZFCoreCriticalClassNotTypeOf::classInfo(desired))
 
// ============================================================
extern ZFLIB_ZFCore void ZFClassAlias(
        ZF_IN const ZFClass *cls
        , ZF_IN const zfstring &aliasNameFull
        );
extern ZFLIB_ZFCore void ZFClassAliasRemove(
        ZF_IN const ZFClass *cls
        , ZF_IN const zfstring &aliasNameFull
        );
 
// ============================================================
extern ZFLIB_ZFCore zfbool zfconvT(
        ZF_OUT zfauto &ret
        , ZF_IN const ZFClass *cls
        , ZF_IN const zfany &obj
        , ZF_IN_OPT zfbool implicitConv = zftrue
        );
inline zfauto zfconv(
        ZF_IN const ZFClass *cls
        , ZF_IN const zfany &obj
        , ZF_IN_OPT zfbool implicitConv = zftrue
        ) {
    zfauto ret;
    zfconvT(ret, cls, obj, implicitConv);
    return ret;
}

inline zfbool zfconvT(
        ZF_OUT zfauto &ret
        , ZF_IN const zfstring &cls
        , ZF_IN const zfany &obj
        , ZF_IN_OPT zfbool implicitConv = zftrue
        ) {
    return zfconvT(ret, ZFClass::classForName(cls), obj, implicitConv);
}

inline zfauto zfconv(
        ZF_IN const zfstring &cls
        , ZF_IN const zfany &obj
        , ZF_IN_OPT zfbool implicitConv = zftrue
        ) {
    zfauto ret;
    zfconvT(ret, ZFClass::classForName(cls), obj, implicitConv);
    return ret;
}

#define ZFCONV_REGISTER(dstCls, srcCls) \
    static zfbool _ZFP_zfconv_##dstCls##_##srcCls(ZF_OUT zfauto &ret, ZF_IN const zfany &obj); \
    ZF_STATIC_REGISTER_INIT(zfconv_##dstCls##_##srcCls) { \
        srcCls::ClassData()->zfconvRegister(dstCls::ClassData(), _ZFP_zfconv_##dstCls##_##srcCls); \
    } \
    ZF_STATIC_REGISTER_DESTROY(zfconv_##dstCls##_##srcCls) { \
        srcCls::ClassData()->zfconvUnregister(dstCls::ClassData()); \
    } \
    ZF_STATIC_REGISTER_END(zfconv_##dstCls##_##srcCls) \
    static zfbool _ZFP_zfconv_##dstCls##_##srcCls(ZF_OUT zfauto &ret, ZF_IN const zfany &obj)
 
ZF_NAMESPACE_GLOBAL_END
#endif // #ifndef _ZFI_ZFClass_h_