DynamicSrcMacro.h

Go to the documentation of this file.

// DynamicSrcMacro.h:
// ------------------
//
//

#ifndef __IPSDKUTIL_DYNAMICSRCMACRO_H__
#define __IPSDKUTIL_DYNAMICSRCMACRO_H__

#include <IPSDKUtil/Dynamic/DynamicObjectFactory.h>
#include <IPSDKUtil/Dynamic/DynamicCopyUtils.h>
#include <IPSDKUtil/Tools/MutexMacros.h>
#include <IPSDKUtil/Logger/IPSDKUtilLog.h>
#include <boost/thread/lock_guard.hpp>
#include <boost/make_shared.hpp>
#include <memory>

// mutex used to protect data for concurrent accesses
IPSDK_STATIC_MUTEX(TypeNameMutex);


#define IPSDK_IMPLEMENT_DYNAMIC(namespaceSeq, className)                                    \
    const std::string& className::getTypeName() {                                           \
        boost::lock_guard<boost::mutex> lock(TypeNameMutex::get());                         \
        static const std::string g_typeName(                                                \
            IPSDK_FULL_CLASSNAME_STR(namespaceSeq, className));                             \
        return g_typeName;                                                                  \
    }                                                                                       \
    const std::string& className::getClassName() const {                                    \
        return IPSDK_NAMESPACE_NAME(namespaceSeq)className::getTypeName();                  \
    }                                                                                       \
    ipsdk::BaseDynamicObject* className::createNewObject() {                                \
        return new className();                                                             \
    }                                                                                       \
    ipsdk::DynamicObjectPtr className::createSharedObject() {                               \
        return boost::make_shared<className>();                                             \
    }                                                                                       \
    ipsdk::BaseDynamicObject* className::createNew() const {                                \
        return new className();                                                             \
    }                                                                                       \
    ipsdk::DynamicObjectPtr className::createShared() const {                               \
        return boost::make_shared<className>();                                             \
    }                                                                                       \
    namespace ipsdk {                                                                       \
        template <>                                                                         \
        struct DynamicRegistrator<className> {                                              \
            static BaseDynamicObject* newCreatorFcn() {                                     \
                return className::createNewObject();                                        \
            }                                                                               \
            static DynamicObjectPtr sharedCreatorFcn() {                                    \
                return className::createSharedObject();                                     \
            }                                                                               \
            DynamicRegistrator()                                                            \
            {                                                                               \
                DynamicObjectFactory& factory = DynamicObjectFactory::getInstance();        \
                factory.registerClass(IPSDK_FULL_CLASSNAME_STR(namespaceSeq,                \
                                                               className),                  \
                                      newCreatorFcn, sharedCreatorFcn);                     \
            }                                                                               \
            ~DynamicRegistrator()                                                           \
            {                                                                               \
                DynamicObjectFactory& factory = DynamicObjectFactory::getInstance();        \
                factory.unRegisterClass(IPSDK_FULL_CLASSNAME_STR(namespaceSeq,              \
                                                                 className));               \
            }                                                                               \
            static DynamicRegistrator g_classRegistrator;                                   \
        };                                                                                  \
        DynamicRegistrator<className> DynamicRegistrator<className>::g_classRegistrator;    \
    }

#define IPSDK_IMPLEMENT_COPY_SUPPORT(className)                                 \
    className::className(const className& object) {                             \
        if (this != &object) {                                                  \
            initCtorCopy(object);                                               \
            copy(object);                                                       \
        }                                                                       \
    }                                                                           \
    className& className::operator= (const className& object) {                 \
        copy(object);                                                           \
        return *this;                                                           \
    }                                                                           \
    ipsdk::BaseDynamicObject* className::duplicate() const {                    \
        std::auto_ptr<className> pObject(new className());                      \
        pObject->copy(*this);                                                   \
        return pObject.release();                                               \
    }                                                                           \
    ipsdk::DynamicObjectPtr className::duplicateShared() const {                \
        boost::shared_ptr<className> pObject(boost::make_shared<className>());  \
        pObject->copy(*this);                                                   \
        return pObject;                                                         \
    }

#define IPSDK_IMPLEMENT_DYNAMIC_WITH_COPY(namespaceSeq, className)  \
    IPSDK_IMPLEMENT_COPY_SUPPORT(className)                         \
    IPSDK_IMPLEMENT_DYNAMIC(namespaceSeq, className)

#define IPSDK_IMPLEMENT_DYNAMIC_WITHOUT_COPY(namespaceSeq, className)   \
    void className::copy(const ipsdk::BaseDynamicObject& object) {      \
        IPSDKUTIL_THROW([ipsdk::eIPSDKUtilErrors::eCantCopyObject] %    \
                        className::getTypeName());                      \
    }                                                                   \
    ipsdk::BaseDynamicObject* className::duplicate() const {            \
        IPSDKUTIL_THROW([ipsdk::eIPSDKUtilErrors::eCantCopyObject] %    \
                        className::getTypeName());                      \
        return 0;                                                       \
    }                                                                   \
    ipsdk::DynamicObjectPtr className::duplicateShared() const {        \
        IPSDKUTIL_THROW([ipsdk::eIPSDKUtilErrors::eCantCopyObject] %    \
                        className::getTypeName());                      \
        return ipsdk::DynamicObjectPtr();                               \
    }                                                                   \
    IPSDK_IMPLEMENT_DYNAMIC(namespaceSeq, className)


#define IPSDK_IMPLEMENT_ABSTRACT_DYNAMIC(namespaceSeq, className)               \
    const std::string& className::getTypeName() {                               \
        boost::lock_guard<boost::mutex> lock(TypeNameMutex::get());             \
        static const std::string g_typeName(                                    \
            IPSDK_FULL_CLASSNAME_STR(namespaceSeq, className));                 \
        return g_typeName;                                                      \
    }                                                                           \
    const std::string& className::getClassName() const {                        \
        return className::getTypeName();                                        \
    }

#define IPSDK_IMPLEMENT_ABSTRACT_DYNAMIC_WITH_COPY(namespaceSeq, className) \
    IPSDK_IMPLEMENT_ABSTRACT_DYNAMIC(namespaceSeq, className)

#define IPSDK_IMPLEMENT_ABSTRACT_DYNAMIC_WITHOUT_COPY(namespaceSeq, className)  \
    void className::copy(const ipsdk::BaseDynamicObject& object) {              \
        IPSDKUTIL_THROW([ipsdk::eIPSDKUtilErrors::eCantCopyObject] %            \
                        className::getTypeName());                              \
    }                                                                           \
    ipsdk::BaseDynamicObject* className::duplicate() const {                    \
        IPSDKUTIL_THROW([ipsdk::eIPSDKUtilErrors::eCantCopyObject] %            \
                        className::getTypeName());                              \
        return 0;                                                               \
    }                                                                           \
    ipsdk::DynamicObjectPtr className::duplicateShared() const {                \
        IPSDKUTIL_THROW([ipsdk::eIPSDKUtilErrors::eCantCopyObject] %            \
                        className::getTypeName());                              \
        return ipsdk::DynamicObjectPtr();                                       \
    }                                                                           \
    IPSDK_IMPLEMENT_ABSTRACT_DYNAMIC(namespaceSeq, className)


#define IPSDK_IMPLEMENT_COPY(className, baseClassName)                          \
    void className::copy(const ipsdk::BaseDynamicObject& object) {              \
        const className* pObject = static_cast<const className*>(&object);      \
        baseClassName::copy(object);


#endif // __IPSDKUTIL_DYNAMICSRCMACRO_H__