ZFObjectInterface.h

Go to the documentation of this file.

 
#ifndef _ZFI_ZFObjectInterface_h_
#define _ZFI_ZFObjectInterface_h_
 
#include "zfany.h"
#include "ZFClass.h"
 
ZF_NAMESPACE_GLOBAL_BEGIN
 
zfclassFwd ZFObject;
zfclassFwd ZFClass;

#define zfinterface class
#define zfimplement public
 
// ============================================================
zfclassNotPOD ZFLIB_ZFCore _ZFP_ObjI_Base {
protected:
    virtual ~_ZFP_ObjI_Base(void) {}
 
public:
    static const ZFClass *ClassData(void) {return zfnull;}
public:
    static void _ZFP_ObjI_reg(ZFClass *cls) {}
public:
    static void _ZFP_ObjI_ICk(void) {}
};
#define _ZFP_ZFINTERFACE_DECLARE(InterfaceName, ParentInterface, OuterClass, ...) \
    ZFCLASS_DISALLOW_COPY_CONSTRUCTOR(InterfaceName) \
    public: \
        static void _ZFP_zftIsZFObject(void) {} \
        static void _ZFP_zftIsZFInterface(void) {} \
    protected: \
 \
        typedef ParentInterface zfsuper; \
 \
        typedef InterfaceName zfself; \
    private: \
        static void _ZFP_ObjI_regCk(ZF_IN ZFClass *cls) { \
            if(!cls->_ZFP_ZFClass_interfaceHasRegisterCk()) { \
                cls->_ZFP_ZFClass_interfaceHasRegisterCk(zftrue); \
                if(zfself::_ZFP_ObjI_reg != zfsuper::_ZFP_ObjI_reg) { \
                    zfself::_ZFP_ObjI_reg(cls); \
                } \
            } \
        } \
    public: \
 \
        static const ZFClass *ClassData(void) { \
            static _ZFP_ZFClassRegisterHolder h( \
                    ZF_NAMESPACE_CURRENT() \
                    , zftext(#InterfaceName) \
                    , ParentInterface::ClassData() \
                    , OuterClass::ClassData() \
                    , zftrue \
                    , zfnull \
                    , zfnull \
                    , &zfself::_ZFP_ObjI_regCk \
                    , zftrue \
                    ); \
            return h.cls; \
        } \
    protected: \
        virtual void _ZFP_ObjI_ICk(void) { \
            /* used to ensure inherit from ZFInterface */ \
            _ZFP_ObjI_Base::_ZFP_ObjI_ICk(); \
        } \
    public: \
 \
        template<typename T_ZFObject> \
        inline T_ZFObject to(void) { \
            return zfcast(T_ZFObject, this); \
        } \
 \
    public:
#define ZFINTERFACE_DECLARE_WITH_CUSTOM_CTOR(InterfaceName, ParentInterface, ...) \
        ZFM_VA_APPEND(_ZFP_ZFINTERFACE_DECLARE, _ZFP_ObjI_Base, InterfaceName, ParentInterface, ##__VA_ARGS__) \
    public:

#define ZFINTERFACE_DECLARE(InterfaceName, ParentInterface, ...) \
        ZFM_VA_APPEND(_ZFP_ZFINTERFACE_DECLARE, _ZFP_ObjI_Base, InterfaceName, ParentInterface, ##__VA_ARGS__) \
    protected: \
 \
        InterfaceName(void) {} \
        virtual ~InterfaceName(void) {} \
 \
    public:
 
template<typename T_FromZFObjectOrZFInterface, typename T_ToZFInterface, int isFromInterface>
zfclassNotPOD _ZFP_ObjICW { // interface cast wrapper
};
template<typename T_FromZFObjectOrZFInterface, typename T_ToZFInterface>
zfclassNotPOD _ZFP_ObjICW<T_FromZFObjectOrZFInterface, T_ToZFInterface, 0> {
public:
    static ZFInterface *_ZFP_cast(ZF_IN ZFObject *obj) {
        return (T_ToZFInterface *)zfcast(T_FromZFObjectOrZFInterface *, obj);
    }
};
template<typename T_FromZFObjectOrZFInterface, typename T_ToZFInterface>
zfclassNotPOD _ZFP_ObjICW<T_FromZFObjectOrZFInterface, T_ToZFInterface, 1> {
public:
    template<typename T_ZFObject>
    static inline ZFInterface *_ZFP_cast(ZF_IN T_ZFObject *obj) {
        return zfcast(T_ToZFInterface *, obj->toObject());
    }
};
template<typename T_FromZFObjectOrZFInterface>
zfclassNotPOD _ZFP_ObjICW<T_FromZFObjectOrZFInterface, ZFInterface, 0> {
public:
    template<typename T_ZFObject>
    static inline ZFInterface *_ZFP_cast(ZF_IN T_ZFObject *obj) {
        return zfnull;
    }
};
template<typename T_FromZFObjectOrZFInterface>
zfclassNotPOD _ZFP_ObjICW<T_FromZFObjectOrZFInterface, ZFInterface, 1> {
public:
    template<typename T_ZFObject>
    static inline ZFInterface *_ZFP_cast(ZF_IN T_ZFObject *obj) {
        return zfnull;
    }
};
#define _ZFP_ZFIMPLEMENT_DECLARE_EXPAND_PARAM(Interface) \
    , Interface::ClassData(), &zfself::_ZFP_ObjICCb_##Interface
#define _ZFP_ZFIMPLEMENT_DECLARE_EXPAND_CAST_CALLBACK(Interface) \
    static ZFInterface *_ZFP_ObjICCb_##Interface(ZF_IN ZFObject *obj) { \
        return _ZFP_ObjICW<zfself, Interface, (zftIsTypeOf<zfself, ZFObject>::Value ? 0 : 1)>::_ZFP_cast(obj); \
    }
#define _ZFP_ZFIMPLEMENT_DECLARE_EXPAND_INTERFACE_ON_INIT(Interface) \
    Interface::_ZFP_ObjI_onInit();
#define _ZFP_ZFIMPLEMENT_DECLARE_EXPAND_INTERFACE_ON_DEALLOC(Interface) \
    Interface::_ZFP_ObjI_onDealloc();
#define _ZFP_ZFIMPLEMENT_DECLARE(ImplementedInterfaces, ...) \
    public: \
        static void _ZFP_ObjI_reg(ZFClass *cls) { \
            if(!cls->_ZFP_ZFClass_interfaceHasRegister()) { \
                cls->_ZFP_ZFClass_interfaceRegister(0 \
                    ZFM_FIX_PARAM(_ZFP_ZFIMPLEMENT_DECLARE_EXPAND_PARAM, ZFM_EMPTY, ImplementedInterfaces, ##__VA_ARGS__) \
                    , (const ZFClass *)zfnull \
                    ); \
            } \
        } \
    public: \
        ZFM_FIX_PARAM(_ZFP_ZFIMPLEMENT_DECLARE_EXPAND_CAST_CALLBACK, ZFM_EMPTY, ImplementedInterfaces, ##__VA_ARGS__) \
    public:
#define ZFIMPLEMENT_DECLARE(ImplementedInterfaces, ...) \
        _ZFP_ZFIMPLEMENT_DECLARE(ImplementedInterfaces, ##__VA_ARGS__) \
    public: \
        virtual inline void _ZFP_ObjI_ctor(void) { \
            zfsuper::_ZFP_ObjI_ctor(); \
            ZFM_FIX_PARAM(_ZFP_ZFIMPLEMENT_DECLARE_EXPAND_INTERFACE_ON_INIT, ZFM_EMPTY, ImplementedInterfaces, ##__VA_ARGS__) \
        } \
        virtual inline void _ZFP_ObjI_dtor(void) { \
            ZFM_FIX_PARAM(_ZFP_ZFIMPLEMENT_DECLARE_EXPAND_INTERFACE_ON_DEALLOC, ZFM_EMPTY, ImplementedInterfaces, ##__VA_ARGS__) \
            zfsuper::_ZFP_ObjI_dtor(); \
        } \
    public:

zfinterface ZFLIB_ZFCore ZFInterface {
    _ZFP_ZFINTERFACE_DECLARE(ZFInterface, _ZFP_ObjI_Base, _ZFP_ObjI_Base)
 
protected:
    ZFInterface(void) {}
    virtual ~ZFInterface(void) {}
 
public:
    static void _ZFP_ObjI_reg(ZFClass *cls) {}
    zffinal inline void _ZFP_ObjI_onInit(void) {}
    zffinal inline void _ZFP_ObjI_onDealloc(void) {}
 
public:
    virtual const ZFClass *classData(void) zfpurevirtual;

    virtual ZFObject *toObject(void) zfpurevirtual;
};

#define ZFINTERFACE_ON_INIT_DECLARE() \
    public: \
        zffinal void _ZFP_ObjI_onInit(void)

#define ZFINTERFACE_ON_INIT_DEFINE(YourInterface) \
    void YourInterface::_ZFP_ObjI_onInit(void)

#define ZFINTERFACE_ON_DEALLOC_DECLARE() \
    public: \
        zffinal void _ZFP_ObjI_onDealloc(void)

#define ZFINTERFACE_ON_DEALLOC_DEFINE(YourInterface) \
    void YourInterface::_ZFP_ObjI_onDealloc(void)
 
ZF_NAMESPACE_GLOBAL_END
 
#endif // #ifndef _ZFI_ZFObjectInterface_h_