ProcessorSrcMacros.h

Go to the documentation of this file.

// ProcessorSrcMacros.h:
// ---------------------
//

#ifndef __IPSDKBASEPROCESSING_PROCESSORSRCMACROS_H__
#define __IPSDKBASEPROCESSING_PROCESSORSRCMACROS_H__

#include <IPSDKCore/Processing/Action/ActionSrcMacros.h>
#include <IPSDKBaseProcessing/Processor/ProcessorFactory.h>
#include <IPSDKBaseProcessing/Processor/Policy/ProcessorDispatchPolicy.h>
#include <IPSDKUtil/Tools/MutexMacros.h>
#include <boost/make_shared.hpp>
#include <boost/thread/lock_guard.hpp>


#define IPSDK_IMPLEMENT_PROCESSOR(libraryName, namespaceSeq, className,                                 \
                                  eMsgEnum, version)                                                    \
    IPSDK_STATIC_MUTEX(DispatchPolicyMutex);                                                            \
    static ipsdk::processor::ProcessorDispatchPolicy&                                                   \
        BOOST_PP_CAT(get, BOOST_PP_CAT(className, StaticDispatchPolicy))() {                            \
        boost::lock_guard<boost::mutex> lock(DispatchPolicyMutex::get());                               \
        static ipsdk::processor::ProcessorDispatchPolicy g_dispatchPolicy;                              \
        if (g_dispatchPolicy.isInit() == false)                                                         \
            g_dispatchPolicy.initDefault();                                                             \
        return g_dispatchPolicy;                                                                        \
    }                                                                                                   \
    const ipsdk::processor::ProcessorDispatchPolicy& className::getDefaultDispatchPolicy() {            \
        return BOOST_PP_CAT(get, BOOST_PP_CAT(className, StaticDispatchPolicy))();                      \
    }                                                                                                   \
    IPSDK_IMPLEMENT_ACTION(libraryName, namespaceSeq, className, eMsgEnum, version)                     \
    boost::shared_ptr<className> className::createProcessor() {                                         \
        return boost::make_shared<className>();                                                         \
    }                                                                                                   \
    ipsdk::processor::ProcessorPtr className::createBaseProcessor() {                                   \
        return boost::make_shared<className>();                                                         \
    }                                                                                                   \
    ipsdk::BoolResult className::initDerived(AttributeColl& attributeColl,                              \
                                             OutputInitializerColl& outputInitializerColl,              \
                                             ipsdk::processor::ProcessorDispatchPolicy& dispatchPolicy, \
                                             ipsdk::processor::RulePtr& pGlobalRule,                    \
                                             const ipsdk::processor::eProcessorRulePolicy& rulePolicy)  \
    {                                                                                                   \
        initAttributeColl(attributeColl, outputInitializerColl);                                        \
        dispatchPolicy = getDefaultDispatchPolicy();                                                    \
        pGlobalRule.reset();                                                                            \
        if (rulePolicy != ipsdk::processor::eProcessorRulePolicy::ePRP_DisableAll)                      \
            pGlobalRule = createRule();                                                                 \
        return true;                                                                                    \
    }                                                                                                   \
    namespace ipsdk {                                                                                   \
        namespace processor {                                                                           \
            template <typename T>                                                                       \
            struct ProcessorRegistrator;                                                                \
            template <>                                                                                 \
            struct ProcessorRegistrator<className> {                                                    \
                ProcessorRegistrator()                                                                  \
                {                                                                                       \
                    MessageMapRegistrator<eMsgEnum>::process();                                         \
                    ProcessorFactory& factory = ProcessorFactory::getInstance();                        \
                    factory.registerProcessor<className>();                                             \
                }                                                                                       \
                ~ProcessorRegistrator()                                                                 \
                {                                                                                       \
                    ProcessorFactory& factory = ProcessorFactory::getInstance();                        \
                    factory.unRegisterProcessor<className>();                                           \
                }                                                                                       \
                static ProcessorRegistrator<className> g_bProcessorRegistrator;                         \
            };                                                                                          \
            ProcessorRegistrator<className> ProcessorRegistrator<className>::g_bProcessorRegistrator;   \
        }                                                                                               \
    }

#define IPSDK_DEFAULT_DISPATCH_POLICY(className, nbMaxThread, dispatchLocationType)             \
    static bool BOOST_PP_CAT(set, BOOST_PP_CAT(className, StaticDispatchPolicy))() {            \
        BOOST_PP_CAT(get, BOOST_PP_CAT(className, StaticDispatchPolicy))().init(                \
                ipsdk::processor::eDispatchLocationType::dispatchLocationType, nbMaxThread);    \
        return true;                                                                            \
    }                                                                                           \
    static bool BOOST_PP_CAT(g_bSet, BOOST_PP_CAT(className, StaticDispatchPolicy)) =           \
        BOOST_PP_CAT(set, BOOST_PP_CAT(className, StaticDispatchPolicy))();



#endif // __IPSDKBASEPROCESSING_PROCESSORSRCMACROS_H__