ZFProtocol.h

Go to the documentation of this file.

 
#ifndef _ZFI_ZFProtocol_h_
#define _ZFI_ZFProtocol_h_
 
#include "ZFObject.h"
ZF_NAMESPACE_GLOBAL_BEGIN
 
// ============================================================
ZFENUM_BEGIN(ZFLIB_ZFCore, ZFProtocolLevel)
    ZFENUM_VALUE(Default = 1000)
    ZFENUM_VALUE(SystemLow = 2000)
    ZFENUM_VALUE(SystemNormal = 3000)
    ZFENUM_VALUE(SystemHigh = 4000)
    ZFENUM_VALUE(AppLow = 5000)
    ZFENUM_VALUE(AppNormal = 6000)
    ZFENUM_VALUE(AppHigh = 7000)
ZFENUM_SEPARATOR()
    ZFENUM_VALUE_REGISTER(Default)
    ZFENUM_VALUE_REGISTER(SystemLow)
    ZFENUM_VALUE_REGISTER(SystemNormal)
    ZFENUM_VALUE_REGISTER(SystemHigh)
    ZFENUM_VALUE_REGISTER(AppLow)
    ZFENUM_VALUE_REGISTER(AppNormal)
    ZFENUM_VALUE_REGISTER(AppHigh)
ZFENUM_END(ZFLIB_ZFCore, ZFProtocolLevel)
ZFENUM_REG(ZFLIB_ZFCore, ZFProtocolLevel)

ZFENUM_BEGIN(ZFLIB_ZFCore, ZFProtocolInstanceState)
    ZFENUM_VALUE(OnInit = 0x01)
    ZFENUM_VALUE(OnInitFinish = 0x03)
    ZFENUM_VALUE(Idle = 0)
    ZFENUM_VALUE(OnDeallocPrepare = 0x30)
    ZFENUM_VALUE(OnDealloc = 0x10)
ZFENUM_SEPARATOR()
    ZFENUM_VALUE_REGISTER(OnInit)
    ZFENUM_VALUE_REGISTER(OnInitFinish)
    ZFENUM_VALUE_REGISTER(Idle)
    ZFENUM_VALUE_REGISTER(OnDeallocPrepare)
    ZFENUM_VALUE_REGISTER(OnDealloc)
ZFENUM_END(ZFLIB_ZFCore, ZFProtocolInstanceState)
ZFENUM_REG(ZFLIB_ZFCore, ZFProtocolInstanceState)
 
// ============================================================
zfclassNotPOD ZFLIB_ZFCore ZFProtocol {
    ZFCLASS_DISALLOW_COPY_CONSTRUCTOR(ZFProtocol)
 
public:
    virtual void protocolOnInit(void) {
    }

    virtual void protocolOnInitFinish(void) {
    }

    virtual void protocolOnDeallocPrepare(void) {
    }

    virtual void protocolOnDealloc(void) {
    }
 
public:
    virtual ZFProtocolInstanceState protocolInstanceState(void) {
        return _ZFP_ZFProtocol_protocolInstanceState;
    }
    ZFProtocolInstanceState _ZFP_ZFProtocol_protocolInstanceState;
 
public:
    virtual const zfchar *protocolName(void) const {
        return zfnull;
    }

    virtual const zfchar *protocolImplName(void) const {
        return zfnull;
    }

    virtual ZFProtocolLevel protocolImplLevel(void) const {
        return v_ZFProtocolLevel::e_Default;
    }

    virtual const zfchar *protocolImplPlatformHint(void) const {
        return "";
    }
 
public:
    virtual void objectInfoT(ZF_IN_OUT zfstring &ret) const {
        zfstringAppend(ret, "<[%s] %s%s>",
            this->protocolName(),
            this->protocolImplName(),
            (!zfstringIsEmpty(this->protocolImplPlatformHint()) ? zfstr(" (%s)", this->protocolImplPlatformHint()).cString() : "")
            );
    }

    virtual inline zfstring objectInfo(void) const {
        zfstring ret;
        this->objectInfoT(ret);
        return ret;
    }
 
public:
    virtual zfbool _ZFP_ZFProtocol_checkImplDependency(
            ZF_OUT const zfchar *&desiredImplPlatformHint
            , ZF_OUT const zfchar *&mismatchProtocolName
            , ZF_OUT ZFProtocol *&mismatchImpl
            ) const {
        return zftrue;
    }
protected:
    static zfbool _ZFP_ZFProtocolOptional(void) {
        return zffalse;
    }
 
public:
    ZFProtocol(void) : _ZFP_ZFProtocol_protocolInstanceState(v_ZFProtocolInstanceState::e_OnInit) {}
    virtual ~ZFProtocol(void) {}
};
ZFTYPEID_ACCESS_ONLY_DECLARE(ZFLIB_ZFCore, ZFProtocol, ZFProtocol *)
ZFTYPEID_ACCESS_ONLY_REG(ZFLIB_ZFCore, ZFProtocol, ZFProtocol *)
ZFOUTPUT_TYPE(ZFProtocol, {v.objectInfoT(s);})
 
// ============================================================
zfclassFwd _ZFP_ZFProtocolData;
typedef ZFProtocol *(*_ZFP_ZFProtocolTryAccessCallback)(void);
typedef ZFProtocol *(*_ZFP_ZFProtocolConstructor)(void);
typedef zfbool (*_ZFP_ZFProtocolIsAvailableCkCallback)(void);
typedef void (*_ZFP_ZFProtocolCleanupCallback)(ZF_IN _ZFP_ZFProtocolData *implData);
zfclassLikePOD ZFLIB_ZFCore _ZFP_ZFProtocolData {
public:
    zfstring protocolName;
    zfbool protocolOptional;
    _ZFP_ZFProtocolTryAccessCallback implTryAccessCallback;
    _ZFP_ZFProtocolConstructor implConstructor;
    _ZFP_ZFProtocolIsAvailableCkCallback isAvailableCk;
    zfstring implName;
    ZFProtocolLevel implLevel;
    _ZFP_ZFProtocolCleanupCallback implCleanupCallback;
    ZFProtocol *implInstance;
};
extern ZFLIB_ZFCore _ZFP_ZFProtocolData &_ZFP_ZFProtocolImplDataRegister(
        ZF_IN const zfchar *protocolName
        , ZF_IN _ZFP_ZFProtocolTryAccessCallback implTryAccessCallback
        , ZF_IN zfbool protocolOptional
        );
extern ZFLIB_ZFCore void _ZFP_ZFProtocolImplDataUnregister(const zfchar *protocolName);
extern ZFLIB_ZFCore void _ZFP_ZFProtocolImplAccess(void);
 
// ============================================================
#define ZFPROTOCOL_INTERFACE_CLASS(ModuleName) \
    ZFPInterface_##ModuleName
 
#define _ZFP_ZFPROTOCOL_INTERFACE_BEGIN(ZFLIB_, ModuleName) \
    zfclassNotPOD ZFLIB_ ZFPROTOCOL_INTERFACE_CLASS(ModuleName) : zfextend ZFProtocol { \
        protected: \
 \
            typedef ZFProtocol zfsuper; \
 \
            typedef ZFPROTOCOL_INTERFACE_CLASS(ModuleName) zfself; \
        public: \
            zfoverride \
            virtual const zfchar *protocolName(void) const { \
                return #ModuleName; \
            } \
        public: \
            static _ZFP_ZFProtocolData &_ZFP_ZFProtocolDataRef(void) { \
                static _ZFP_ZFProtocolData &_d = _ZFP_ZFProtocolImplDataRegister( \
                    zftext(#ModuleName), \
                    zfself::_ZFP_ZFProtocolTryAccessCallbackFunc, \
                    zfself::_ZFP_ZFProtocolOptional()); \
                return _d; \
            } \
            static void _ZFP_ZFProtocolDataRegister(void) { \
                (void)zfself::_ZFP_ZFProtocolDataRef(); \
            } \
            static ZFProtocol *_ZFP_ZFProtocolTryAccessCallbackFunc(void) { \
                return ZFPROTOCOL_TRY_ACCESS(ModuleName); \
            } \
            static void _ZFP_ZFProtocolInstanceCleanupCallback(ZF_IN _ZFP_ZFProtocolData *implData) { \
                if(implData->implInstance != zfnull) { \
                    zfdelete(implData->implInstance); \
                    implData->implInstance = zfnull; \
                } \
            } \
            static void _ZFP_ZFProtocolImplRegister( \
                    ZF_IN _ZFP_ZFProtocolConstructor implConstructor \
                    , ZF_IN _ZFP_ZFProtocolIsAvailableCkCallback isAvailableCk \
                    , ZF_IN const zfchar *implName \
                    , ZF_IN ZFProtocolLevel implLevel \
                    ) { \
                _ZFP_ZFProtocolData &_d = zfself::_ZFP_ZFProtocolDataRef(); \
                if(_d.implConstructor != zfnull) { \
                    if(_d.implLevel == implLevel) { \
                        ZFCoreCriticalMessageTrim("only one implementation is allowed for protocol \"%s\", while we have: \"%s\", \"%s\"", \
                            #ModuleName, \
                            _d.implName, \
                            implName); \
                        return; \
                    } \
                    else if(_d.implLevel > implLevel) { \
                        /* \
                        ZFCoreLogTrim("ignore implementation \"%s\" while having \"%s\" for protocol \"%s\"", \
                            implName, _d.implName, #ModuleName); \
                         */ \
                        return; \
                    } \
                    else { \
                        /* \
                        ZFCoreLogTrim("reset implementation for protocol \"%s\", old: \"%s\", new: \"%s\"", \
                            #ModuleName, _d.implName, implName); \
                         */ \
                    } \
                } \
                _d.implConstructor = implConstructor; \
                _d.isAvailableCk = isAvailableCk; \
                _d.implName = implName; \
                _d.implLevel = implLevel; \
                _d.implCleanupCallback = zfself::_ZFP_ZFProtocolInstanceCleanupCallback; \
            } \
            static void _ZFP_ZFProtocolImplChange( \
                    ZF_IN _ZFP_ZFProtocolConstructor implConstructor \
                    , ZF_IN _ZFP_ZFProtocolIsAvailableCkCallback isAvailableCk \
                    , ZF_IN const zfchar *implName \
                    , ZF_IN ZFProtocolLevel implLevel \
                    ) { \
                _ZFP_ZFProtocolData &_d = zfself::_ZFP_ZFProtocolDataRef(); \
                if(_d.implInstance != zfnull) { \
                    _d.implInstance->_ZFP_ZFProtocol_protocolInstanceState = v_ZFProtocolInstanceState::e_OnDeallocPrepare; \
                    _d.implInstance->protocolOnDeallocPrepare(); \
                    _d.implInstance->_ZFP_ZFProtocol_protocolInstanceState = v_ZFProtocolInstanceState::e_OnDealloc; \
                    _d.implInstance->protocolOnDealloc(); \
                    _d.implInstance->_ZFP_ZFProtocol_protocolInstanceState = v_ZFProtocolInstanceState::e_OnInit; \
                } \
                zfself::_ZFP_ZFProtocolInstanceCleanupCallback(&_d); \
                if(implConstructor != zfnull && !zfstringIsEmpty(implName)) { \
                    _d.implConstructor = implConstructor; \
                    _d.isAvailableCk = isAvailableCk; \
                    _d.implName = implName; \
                    _d.implLevel = implLevel; \
                } \
                else { \
                    _d.implConstructor = zfnull; \
                    _d.isAvailableCk = zfnull; \
                    _d.implName.removeAll(); \
                    _d.implLevel = v_ZFProtocolLevel::e_Default; \
                } \
            } \
            static inline zfbool _ZFP_ZFProtocolIsAvailable(void) { \
                _ZFP_ZFProtocolData &_d = zfself::_ZFP_ZFProtocolDataRef(); \
                return _d.implConstructor != zfnull && _d.isAvailableCk(); \
            } \
            static zfself *_ZFP_ZFProtocolNewInstance(void) { \
                _ZFP_ZFProtocolData &_d = zfself::_ZFP_ZFProtocolDataRef(); \
                _ZFP_ZFProtocolImplAccess(); \
                zfself *retVal = zfnull; \
                if(_d.isAvailableCk != zfnull && _d.isAvailableCk()) { \
                    retVal = (zfself *)_d.implConstructor(); \
                    if(retVal != zfnull) { \
                        retVal->_ZFP_ZFProtocol_protocolInstanceState = v_ZFProtocolInstanceState::e_OnInit; \
                        retVal->protocolOnInit(); \
                        retVal->_ZFP_ZFProtocol_protocolInstanceState = v_ZFProtocolInstanceState::e_OnInitFinish; \
                        retVal->protocolOnInitFinish(); \
                        retVal->_ZFP_ZFProtocol_protocolInstanceState = v_ZFProtocolInstanceState::e_Idle; \
                    } \
                } \
                return retVal; \
            } \
            static zfself *_ZFP_ZFProtocolAccess(void) { \
                static ZFProtocol *&impl = zfself::_ZFP_ZFProtocolDataRef().implInstance; \
                if(impl == zfnull) { \
                    _ZFP_ZFProtocolData &_d = zfself::_ZFP_ZFProtocolDataRef(); \
                    _d.implInstance = zfself::_ZFP_ZFProtocolNewInstance(); \
                    if(_d.implInstance == zfnull) { \
                        ZFCoreCriticalMessageTrim("no implementation for protocol \"%s\"", \
                            #ModuleName); \
                        return zfnull; \
                    } \
                    const zfchar *desiredImplPlatformHint = zfnull; \
                    const zfchar *mismatchProtocolName = zfnull; \
                    ZFProtocol *mismatchImpl = zfnull; \
                    if(!_d.implInstance->_ZFP_ZFProtocol_checkImplDependency(desiredImplPlatformHint, mismatchProtocolName, mismatchImpl)) { \
                        zfstring err; \
                        zfstringAppend(err, "(%s)%s depends on (%s)\"%s\"", \
                            _d.implInstance->protocolName(), \
                            _d.implInstance->protocolImplName(), \
                            mismatchProtocolName, \
                            desiredImplPlatformHint); \
                        if(mismatchImpl == zfnull) { \
                            zfstringAppend(err, " but it's not implemented"); \
                        } \
                        else { \
                            zfstringAppend(err, " but it's implementation \"%s\" mismatch", \
                                mismatchImpl->protocolImplPlatformHint()); \
                        } \
                        ZFCoreLogTrim(err); \
                        ZFCoreCriticalError(err); \
                        zfdelete(_d.implInstance); \
                        _d.implInstance = zfnull; \
                        return zfnull; \
                    } \
                } \
                return (zfself *)impl; \
            } \
            static zfself *_ZFP_ZFProtocolTryAccess(void) { \
                static ZFProtocol *&impl = zfself::_ZFP_ZFProtocolDataRef().implInstance; \
                if(impl == zfnull) { \
                    _ZFP_ZFProtocolData &_d = zfself::_ZFP_ZFProtocolDataRef(); \
                    _d.implInstance = zfself::_ZFP_ZFProtocolNewInstance(); \
                    const zfchar *desiredImplPlatformHint = zfnull; \
                    const zfchar *mismatchProtocolName = zfnull; \
                    ZFProtocol *mismatchImpl = zfnull; \
                    if(_d.implInstance != zfnull \
                            && !_d.implInstance->_ZFP_ZFProtocol_checkImplDependency(desiredImplPlatformHint, mismatchProtocolName, mismatchImpl) \
                            ) { \
                        zfdelete(_d.implInstance); \
                        _d.implInstance = zfnull; \
                    } \
                } \
                return (zfself *)impl; \
            } \
            static zfbool _ZFP_ZFProtocolIsAvailableCk(void) { \
                return zftrue; \
            }
#define _ZFP_ZFPROTOCOL_INTERFACE_END(ModuleName) \
    };

 * @endcode
 * for the difference between them, see #ZFPROTOCOL_TRY_ACCESS\n
 * for how to implement it, see #ZFPROTOCOL_IMPLEMENTATION_BEGIN\n
 * for how to access the implementation, see #ZFPROTOCOL_TRY_ACCESS
 * @note all protocol is singleton mode
 */
#define ZFPROTOCOL_INTERFACE_BEGIN(ZFLIB_, ModuleName) \
    _ZFP_ZFPROTOCOL_INTERFACE_BEGIN(ZFLIB_, ModuleName)

#define ZFPROTOCOL_INTERFACE_END(ModuleName) \
    _ZFP_ZFPROTOCOL_INTERFACE_END(ModuleName)

#define ZFPROTOCOL_INTERFACE_OPTIONAL \
    protected: \
        static zfbool _ZFP_ZFProtocolOptional(void) { \
            return zftrue; \
        } \
    public:


#define ZFPROTOCOL_INTERFACE_REGISTER(ModuleName) \
    ZF_STATIC_REGISTER_INIT(ZFProtocolInterfaceRegister_##ModuleName) { \
        ZFPROTOCOL_INTERFACE_CLASS(ModuleName)::_ZFP_ZFProtocolDataRegister(); \
    } \
    ZF_STATIC_REGISTER_END(ZFProtocolInterfaceRegister_##ModuleName)
 
// ============================================================
 * ZFPROTOCOL_TRY_ACCESS would create new instance only for the first time,
 * and the instance would be destroyed at a certain proper time\n
 * \n
 * when using ZFPROTOCOL_TRY_ACCESS, you take full responsibility to check whether
 * the implmentation is available
 */
#define ZFPROTOCOL_TRY_ACCESS(ModuleName) \
    (ZFPROTOCOL_INTERFACE_CLASS(ModuleName)::_ZFP_ZFProtocolTryAccess())

#define ZFPROTOCOL_ACCESS(ModuleName) \
    (ZFPROTOCOL_INTERFACE_CLASS(ModuleName)::_ZFP_ZFProtocolAccess())

#define ZFPROTOCOL_IS_AVAILABLE(ModuleName) \
    ZFPROTOCOL_INTERFACE_CLASS(ModuleName)::_ZFP_ZFProtocolIsAvailable()
 
typedef void (*_ZFP_ZFProtocolImplRegisterHolderClearCallback)(void);
zfclassLikePOD ZFLIB_ZFCore _ZFP_ZFProtocolImplRegisterHolder {
public:
    _ZFP_ZFProtocolImplRegisterHolder(ZF_IN _ZFP_ZFProtocolImplRegisterHolderClearCallback callback)
    : callback(callback)
    {
    }
    ~_ZFP_ZFProtocolImplRegisterHolder(void) {
        this->callback();
    }
private:
    _ZFP_ZFProtocolImplRegisterHolderClearCallback callback;
};
// ============================================================
#define _ZFP_ZFPROTOCOL_IMPLEMENTATION_BEGIN_(ImplementationName, ImplementationClass, ModuleName, implLevel) \
    zfclassNotPOD ImplementationClass : zfextend ZFPROTOCOL_INTERFACE_CLASS(ModuleName) { \
        protected: \
 \
            typedef ZFPROTOCOL_INTERFACE_CLASS(ModuleName) zfsuper; \
 \
            typedef ImplementationClass zfself; \
        public: \
            zfoverride \
            virtual const zfchar *protocolImplName(void) const { \
                return #ImplementationName; \
            } \
            zfoverride \
            virtual ZFProtocolLevel protocolImplLevel(void) const { \
                return implLevel; \
            } \
        public: \
            static ZFProtocol *_ZFP_##ImplementationClass##_ctor(void) { \
                return zfnew(ImplementationClass); \
            } \
            static void _ZFP_ZFProtocolUnregister(void) { \
                if(ZFPROTOCOL_INTERFACE_CLASS(ModuleName)::_ZFP_ZFProtocolDataRef().implConstructor == &ImplementationClass::_ZFP_##ImplementationClass##_ctor) { \
                    ZFPROTOCOL_INTERFACE_CLASS(ModuleName)::_ZFP_ZFProtocolImplChange(zfnull, zfnull, zfnull, v_ZFProtocolLevel::e_Default); \
                } \
                _ZFP_ZFProtocolImplDataUnregister(#ModuleName); \
            } \
            static void _ZFP_ZFProtocolRegister(void) { \
                ZFPROTOCOL_INTERFACE_CLASS(ModuleName)::_ZFP_ZFProtocolImplRegister( \
                    &ImplementationClass::_ZFP_##ImplementationClass##_ctor, \
                    &ImplementationClass::_ZFP_ZFProtocolIsAvailableCk, \
                    zftext(#ImplementationName), \
                    implLevel); \
                static _ZFP_ZFProtocolImplRegisterHolder _holder(&ImplementationClass::_ZFP_ZFProtocolUnregister); \
            } \
            static void _ZFP_ZFProtocolChange(void) { \
                ZFPROTOCOL_INTERFACE_CLASS(ModuleName)::_ZFP_ZFProtocolImplChange( \
                    &ImplementationClass::_ZFP_##ImplementationClass##_ctor, \
                    &ImplementationClass::_ZFP_ZFProtocolIsAvailableCk, \
                    zftext(#ImplementationName), \
                    implLevel); \
            }
#define _ZFP_ZFPROTOCOL_IMPLEMENTATION_BEGIN(ImplementationName, ImplementationClass, ModuleName, implLevel) \
    _ZFP_ZFPROTOCOL_IMPLEMENTATION_BEGIN_(ImplementationName, ImplementationClass, ModuleName, implLevel)
 
#define _ZFP_ZFPROTOCOL_IMPLEMENTATION_END_(ImplementationName, ImplementationClass) \
    }; \
    ZFOUTPUT_TYPE(ImplementationClass, {zftToStringT(s, (ZFProtocol const &)v);}) \
    ZF_STATIC_REGISTER_INIT(ZFPImplReg_##ImplementationClass) { \
        ImplementationClass::_ZFP_ZFProtocolRegister(); \
    } \
    ZF_STATIC_REGISTER_END(ZFPImplReg_##ImplementationClass)
#define _ZFP_ZFPROTOCOL_IMPLEMENTATION_END(ImplementationName, ImplementationClass) \
    _ZFP_ZFPROTOCOL_IMPLEMENTATION_END_(ImplementationName, ImplementationClass)
 
#define _ZFP_ZFPROTOCOL_IMPLEMENTATION_CHECK(CheckAction) \
    static zfbool _ZFP_ZFProtocolIsAvailableCk(void) { \
        CheckAction \
    }

 *   so that native code can use native code to reflect and access the internal types
 *
 * \n
 * if you are able to access an implementation,
 * you may check its platform hint by #ZFProtocol::protocolImplPlatformHint
 */
#define ZFPROTOCOL_IMPLEMENTATION_PLATFORM_HINT(PlatformHint) \
    public: \
        virtual const zfchar *protocolImplPlatformHint(void) const { \
            return PlatformHint; \
        }

 *           ZFPROTOCOL_IMPLEMENTATION_PLATFORM_DEPENDENCY_ITEM(ProtocolName, "DependencyPlatformHint")
 *       ZFPROTOCOL_IMPLEMENTATION_PLATFORM_DEPENDENCY_END()
 *   ZFPROTOCOL_IMPLEMENTATION_END(...)
 * @endcode
 * the DependencyPlatformHint is the string declared by #ZFPROTOCOL_IMPLEMENTATION_PLATFORM_HINT
 */
#define ZFPROTOCOL_IMPLEMENTATION_PLATFORM_DEPENDENCY_BEGIN() \
    public: \
        virtual zfbool _ZFP_ZFProtocol_checkImplDependency( \
                ZF_OUT const zfchar *&desiredImplPlatformHint \
                , ZF_OUT const zfchar *&mismatchProtocolName \
                , ZF_OUT ZFProtocol *&mismatchImpl \
                ) const { \
            if(!zfsuper::_ZFP_ZFProtocol_checkImplDependency(desiredImplPlatformHint, mismatchProtocolName, mismatchImpl)) { \
                return zffalse; \
            }
#define ZFPROTOCOL_IMPLEMENTATION_PLATFORM_DEPENDENCY_ITEM(Protocol, DependencyPlatformHint) \
            if(ZFPROTOCOL_TRY_ACCESS(Protocol) == zfnull \
                    || !zfstringIsEqual(ZFPROTOCOL_ACCESS(Protocol)->protocolImplPlatformHint(), DependencyPlatformHint) \
                    ) { \
                desiredImplPlatformHint = DependencyPlatformHint; \
                mismatchProtocolName = ZFM_TOSTRING(Protocol); \
                mismatchImpl = ZFPROTOCOL_TRY_ACCESS(Protocol); \
                return zffalse; \
            }
#define ZFPROTOCOL_IMPLEMENTATION_PLATFORM_DEPENDENCY_END() \
            return zftrue; \
        } \
    public:


#define ZFPROTOCOL_IMPLEMENTATION_CLASS(Implementation) \
    ZFPImpl_##Implementation

 *           return ZFPROTOCOL_IS_AVAILABLE(OtherProtocol);
 *       })
 *       ...
 *   ZFPROTOCOL_IMPLEMENTATION_END(YourImplementation)
 * @endcode
 */
#define ZFPROTOCOL_IMPLEMENTATION_BEGIN(ImplementationName, ModuleName, implLevel) \
    _ZFP_ZFPROTOCOL_IMPLEMENTATION_BEGIN(ImplementationName, ZFPROTOCOL_IMPLEMENTATION_CLASS(ImplementationName), ModuleName, implLevel)
 */
#define ZFPROTOCOL_IMPLEMENTATION_END(ImplementationName) \
    _ZFP_ZFPROTOCOL_IMPLEMENTATION_END(ImplementationName, ZFPROTOCOL_IMPLEMENTATION_CLASS(ImplementationName))
#define ZFPROTOCOL_IMPLEMENTATION_CHECK(CheckAction) \
    _ZFP_ZFPROTOCOL_IMPLEMENTATION_CHECK(CheckAction)
 
// ============================================================
 * @brief change the implementation at runtime
 *
 * old implementation's level is ignored and forced to be replaced\n
 * it's your responsibility to make sure old implementation isn't in use,
 * otherwise, app may crash
 */
#define ZFProtocolImplChange(ImplementationName) \
    ZFPROTOCOL_IMPLEMENTATION_CLASS(ImplementationName)::_ZFP_ZFProtocolChange()
#define ZFProtocolImplRemove(ModuleName) \
    ZFPROTOCOL_INTERFACE_CLASS(ModuleName)::_ZFP_ZFProtocolImplChange(zfnull, zfnull, zfnull, v_ZFProtocolLevel::e_Default)
 
// ============================================================
ZFMETHOD_FUNC_DECLARE_2(ZFLIB_ZFCore, ZFProtocol *, ZFProtocolForName
        , ZFMP_IN(const zfchar *, name)
        , ZFMP_IN_OPT(const zfchar *, desiredImpl, zfnull)
        )
ZFMETHOD_FUNC_DECLARE_2(ZFLIB_ZFCore, zfbool, ZFProtocolIsAvailable
        , ZFMP_IN(const zfchar *, name)
        , ZFMP_IN_OPT(const zfchar *, desiredImpl, zfnull)
        )
 
// ============================================================
zfclassLikePOD ZFLIB_ZFCore ZFProtocolImplInfo {
public:
    zfstring protocolName;
    zfbool protocolOptional;
    ZFProtocol *protocolImpl;
 
public:
    zffinal void objectInfoT(ZF_IN_OUT zfstring &ret) const;

    zffinal zfstring objectInfo(void) const {
        zfstring ret;
        this->objectInfoT(ret);
        return ret;
    }
 
public:
    zfbool operator == (ZF_IN const ZFProtocolImplInfo &ref) const {
        return (zftrue
                && this->protocolName == ref.protocolName
                && this->protocolOptional == ref.protocolOptional
                && this->protocolImpl == ref.protocolImpl
            );
    }
    zfbool operator != (ZF_IN const ZFProtocolImplInfo &ref) const {
        return !this->operator == (ref);
    }
};
ZFTYPEID_ACCESS_ONLY_DECLARE(ZFLIB_ZFCore, ZFProtocolImplInfo, ZFProtocolImplInfo)
ZFTYPEID_ACCESS_ONLY_REG(ZFLIB_ZFCore, ZFProtocolImplInfo, ZFProtocolImplInfo)
ZFOUTPUT_TYPE(ZFProtocolImplInfo, {v.objectInfoT(s);})

ZFMETHOD_FUNC_DECLARE_0(ZFLIB_ZFCore, ZFCoreArray<ZFProtocolImplInfo>, ZFProtocolImplInfoGetAll)
ZFMETHOD_FUNC_DECLARE_0(ZFLIB_ZFCore, ZFCoreArray<ZFProtocolImplInfo>, ZFProtocolImplInfoGetAllImplemented)
ZFMETHOD_FUNC_DECLARE_0(ZFLIB_ZFCore, ZFCoreArray<ZFProtocolImplInfo>, ZFProtocolImplInfoGetAllNotImplemented)
ZFMETHOD_FUNC_DECLARE_1(ZFLIB_ZFCore, void, ZFProtocolImplInfoPrint
        , ZFMP_IN_OPT(const ZFOutput &, callback, ZFOutputDefault())
        )
ZFMETHOD_FUNC_DECLARE_2(ZFLIB_ZFCore, void, ZFProtocolImplInfoPrint
        , ZFMP_IN(const ZFProtocolImplInfo &, data)
        , ZFMP_IN_OPT(const ZFOutput &, callback, ZFOutputDefault())
        )
 
ZF_NAMESPACE_GLOBAL_END
#endif // #ifndef _ZFI_ZFProtocol_h_