IPSDK  4_1_0_2
IPSDK : Image Processing Software Development Kit
Macros
ProcessorHdrDetailsMacros.h File Reference

Internal header part of macros set for processor class declaration. More...

#include <IPSDKCore/Processing/Action/ActionHdrMacros.h>
#include <IPSDKBaseData/Range/ElementsRange.h>
#include <IPSDKBaseProcessing/Attribute/Macros/AttributeCollInfoCheckMacros.h>
#include <IPSDKBaseProcessing/Processor/Instances/BaseSyncProcessor.h>
#include <IPSDKBaseProcessing/Processor/Instances/BaseAsync1Processor.h>
#include <IPSDKBaseProcessing/Processor/Instances/BaseAsync2Processor.h>
#include <IPSDKBaseProcessing/Processor/Instances/BaseAsync3Processor.h>
#include <IPSDKBaseProcessing/Processor/Instances/BaseAsync4Processor.h>
#include <IPSDKBaseProcessing/Processor/Instances/BaseIterativeAsync1Processor.h>
#include <IPSDKBaseProcessing/Processor/Instances/BaseIterativeAsync2Processor.h>
#include <IPSDKBaseProcessing/Processor/Instances/BaseRepeatedAsync1Processor.h>
#include <IPSDKBaseProcessing/Processor/Instances/BaseRepeatedAsync2Processor.h>
#include <IPSDKBaseProcessing/Processor/ProcessorLogMessages.h>
#include <IPSDKBaseProcessing/Logger/IPSDKBaseProcessingLog.h>
#include <IPSDKUtil/TemplateMacro.h>
#include <boost/mpl/if.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/static_assert.hpp>
#include <boost/make_shared.hpp>

Go to the source code of this file.

Macros

#define IPSDK_PROCESSOR_INIT_ATTRIBUTE_START_MACRO(s, _, n, AttributeInfo)
 [INTERNAL] macro allowing to declare attribute initialization method More...
 
#define IPSDK_PROCESSOR_INIT_ATTRIBUTE_END_MACRO(s, _, AttributeInfo)   >::type
 [INTERNAL] macro allowing to declare attribute initialization method
 
#define IPSDK_PROCESSOR_ACCESS_ATTRIBUTE(attributeSeq)
 [INTERNAL] macro allowing to implement attribute initialization method More...
 
#define IPSDK_PROCESSOR_ACCESS_NO_ATTRIBUTE()   typedef AccessError ResultType;
 [INTERNAL] macro allowing to implement attribute initialization method for class without attributes
 
#define IPSDK_DECLARE_PROCESSOR_STRUCT_ACCESS_ATTRIBUTE_MACRO(s, className, n, AttributeInfo)
 [INTERNAL] macro allowing to declare attribute access structures
 
#define IPSDK_DECLARE_PROCESSOR_ATTRIBUTE_MACRO(s, _, n, AttributeInfo)
 [INTERNAL] macro allowing to declare a processor attribute More...
 
#define IPSDK_DECLARE_PROCESSOR_INITIALIZER_MACRO(s, _, AttributeInfo)
 [INTERNAL] macro allowing to declare a processor attribute initializer More...
 
#define IPSDK_PROCESSOR_ENUM_ATTRIBUTES_TYPE_MACRO(s, _, n, AttributeInfo)
 [INTERNAL] macro allowing to enumerate attributes types More...
 
#define IPSDK_PROCESSOR_DECLARE_ATTRIBUTES_TYPE_MACRO(s, _, n, AttributeInfo)
 [INTERNAL] macro allowing to redeclare attributes types in class scope More...
 
#define IPSDK_REGISTER_PROCESSOR_ATTRIBUTE_MACRO(s, _, n, AttributeInfo)
 [INTERNAL] macro allowing to register a processor attribute More...
 
#define IPSDK_REGISTER_PROCESSOR_OUT_INITIALIZER(AttributeInfo)
 [INTERNAL] macro allowing to register a processor attribute output initializer More...
 
#define IPSDK_REGISTER_PROCESSOR_INITIALIZER_MACRO(s, _, n, AttributeInfo)
 [INTERNAL] macro allowing to register a processor attribute initializer More...
 
#define IPSDK_DECLARE_PROCESSOR_ATTRIBUTES(className, attributeSeq)
 [INTERNAL] macro allowing to declare processor attributes
 
#define IPSDK_DECLARE_PROCESSOR(libraryName, className, RuleString, attributeSeq)
 [INTERNAL] macro allowing to declare a processor More...
 
#define IPSDK_DECLARE_SYNC_PROCESSOR(libraryName, className, RuleString, attributeSeq)
 macro allowing to declare a processor with synchronous behavior More...
 
#define IPSDK_DECLARE_ASYNC1_PROCESSOR(libraryName, className, RuleString, attributeSeq)
 macro allowing to declare a processor with asynchronous behavior using a single provider More...
 
#define IPSDK_DECLARE_ASYNC2_PROCESSOR(libraryName, className, RuleString, attributeSeq)
 macro allowing to declare a processor with asynchronous behavior using two providers More...
 
#define IPSDK_DECLARE_ASYNC3_PROCESSOR(libraryName, className, RuleString, attributeSeq)
 macro allowing to declare a processor with asynchronous behavior using three providers More...
 
#define IPSDK_DECLARE_ASYNC4_PROCESSOR(libraryName, className, RuleString, attributeSeq)
 macro allowing to declare a processor with asynchronous behavior using three providers More...
 
#define IPSDK_DECLARE_ITER_ASYNC1_PROCESSOR(libraryName, className, RuleString, attributeSeq)
 macro allowing to declare a processor with asynchronous iterative behavior using a single provider More...
 
#define IPSDK_DECLARE_ITER_ASYNC2_PROCESSOR(libraryName, className, RuleString, attributeSeq)
 macro allowing to declare a processor with asynchronous iterative behavior using two providers More...
 
#define IPSDK_DECLARE_REP_ASYNC1_PROCESSOR(libraryName, className, RuleString, attributeSeq)
 macro allowing to declare a processor with asynchronous repeated behavior using a single provider More...
 
#define IPSDK_DECLARE_REP_ASYNC2_PROCESSOR(libraryName, className, RuleString, attributeSeq)
 macro allowing to declare a processor with asynchronous repeated behavior using two providers More...
 
#define IPSDK_DECLARE_STATIC_RESULT_COLL(AttributeType, CollType)
 macro allowing to declare a collection used for static processing dispatch results merge More...
 
#define IPSDK_DECLARE_DYNAMIC_RESULT_COLL(AttributeType, CollType)
 macro allowing to declare a collection used for dynamic processing dispatch results merge More...
 

Detailed Description

Internal header part of macros set for processor class declaration.

Author
E. Noirfalise
Date
2014/1/28
Copyright
2013 Reactiv'IP, all right reserved.

Macro Definition Documentation

◆ IPSDK_PROCESSOR_INIT_ATTRIBUTE_START_MACRO

#define IPSDK_PROCESSOR_INIT_ATTRIBUTE_START_MACRO (   s,
  _,
  n,
  AttributeInfo 
)
Value:
typename boost::mpl::if_c<boost::is_same< \
IPSDK_NAMESPACE_NAME(BOOST_PP_SEQ_ELEM(0, AttributeInfo)) \
BOOST_PP_SEQ_ELEM(1, AttributeInfo), TAttribute>::value, \
BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(1, AttributeInfo), Access),

[INTERNAL] macro allowing to declare attribute initialization method

◆ IPSDK_PROCESSOR_ACCESS_ATTRIBUTE

#define IPSDK_PROCESSOR_ACCESS_ATTRIBUTE (   attributeSeq)
Value:
typedef \
BOOST_PP_SEQ_FOR_EACH_I(IPSDK_PROCESSOR_INIT_ATTRIBUTE_START_MACRO, \
_, attributeSeq) \
AccessError<TAttribute> \
BOOST_PP_SEQ_FOR_EACH(IPSDK_PROCESSOR_INIT_ATTRIBUTE_END_MACRO, \
_, attributeSeq) \
ResultType;
IPSDK_PROCESSOR_INIT_ATTRIBUTE_START_MACRO
#define IPSDK_PROCESSOR_INIT_ATTRIBUTE_START_MACRO(s, _, n, AttributeInfo)
[INTERNAL] macro allowing to declare attribute initialization method
Definition: ProcessorHdrDetailsMacros.h:43
IPSDK_PROCESSOR_INIT_ATTRIBUTE_END_MACRO
#define IPSDK_PROCESSOR_INIT_ATTRIBUTE_END_MACRO(s, _, AttributeInfo)
[INTERNAL] macro allowing to declare attribute initialization method
Definition: ProcessorHdrDetailsMacros.h:51

[INTERNAL] macro allowing to implement attribute initialization method

◆ IPSDK_DECLARE_PROCESSOR_ATTRIBUTE_MACRO

#define IPSDK_DECLARE_PROCESSOR_ATTRIBUTE_MACRO (   s,
  _,
  n,
  AttributeInfo 
)
Value:
protected: \
boost::shared_ptr<IPSDK_NAMESPACE_NAME(BOOST_PP_SEQ_ELEM(0, AttributeInfo)) \
BOOST_PP_SEQ_ELEM(1, AttributeInfo)> \
BOOST_PP_CAT(_p, BOOST_PP_SEQ_ELEM(1, AttributeInfo));
IPSDK_NAMESPACE_NAME
#define IPSDK_NAMESPACE_NAME(namespaceSeq)
macro allowing to print full namespace name
Definition: BaseMacros.h:92

[INTERNAL] macro allowing to declare a processor attribute

◆ IPSDK_DECLARE_PROCESSOR_INITIALIZER_MACRO

#define IPSDK_DECLARE_PROCESSOR_INITIALIZER_MACRO (   s,
  _,
  AttributeInfo 
)
Value:
protected: \
BOOST_PP_IF(BOOST_PP_SUB(BOOST_PP_SEQ_SIZE(AttributeInfo), 2), \
ipsdk::processor::OutputInitializerPtr \
BOOST_PP_CAT(BOOST_PP_CAT(_p, \
BOOST_PP_SEQ_ELEM(1, AttributeInfo)),Initializer); \
, )
ipsdk::processor::OutputInitializerPtr
boost::shared_ptr< BaseOutputInitializer > OutputInitializerPtr
shared pointer to output intializer
Definition: OutputInitializerTypes.h:51

[INTERNAL] macro allowing to declare a processor attribute initializer

◆ IPSDK_PROCESSOR_ENUM_ATTRIBUTES_TYPE_MACRO

#define IPSDK_PROCESSOR_ENUM_ATTRIBUTES_TYPE_MACRO (   s,
  _,
  n,
  AttributeInfo 
)
Value:
BOOST_PP_COMMA_IF(n) \
IPSDK_NAMESPACE_NAME(BOOST_PP_SEQ_ELEM(0, AttributeInfo)) \
BOOST_PP_SEQ_ELEM(1, AttributeInfo)

[INTERNAL] macro allowing to enumerate attributes types

◆ IPSDK_PROCESSOR_DECLARE_ATTRIBUTES_TYPE_MACRO

#define IPSDK_PROCESSOR_DECLARE_ATTRIBUTES_TYPE_MACRO (   s,
  _,
  n,
  AttributeInfo 
)
Value:
typedef IPSDK_NAMESPACE_NAME(BOOST_PP_SEQ_ELEM(0, AttributeInfo)) \
BOOST_PP_SEQ_ELEM(1, AttributeInfo) \
BOOST_PP_SEQ_ELEM(1, AttributeInfo);
IPSDK_NAMESPACE_NAME
#define IPSDK_NAMESPACE_NAME(namespaceSeq)
macro allowing to print full namespace name
Definition: BaseMacros.h:92

[INTERNAL] macro allowing to redeclare attributes types in class scope

◆ IPSDK_REGISTER_PROCESSOR_ATTRIBUTE_MACRO

#define IPSDK_REGISTER_PROCESSOR_ATTRIBUTE_MACRO (   s,
  _,
  n,
  AttributeInfo 
)
Value:
BOOST_PP_CAT(_p, BOOST_PP_SEQ_ELEM(1, AttributeInfo)) = \
boost::make_shared< \
IPSDK_NAMESPACE_NAME(BOOST_PP_SEQ_ELEM(0, AttributeInfo)) \
BOOST_PP_SEQ_ELEM(1, AttributeInfo)>(); \
attributeColl.push_back(BOOST_PP_CAT(_p, BOOST_PP_SEQ_ELEM(1, AttributeInfo)));

[INTERNAL] macro allowing to register a processor attribute

◆ IPSDK_REGISTER_PROCESSOR_OUT_INITIALIZER

#define IPSDK_REGISTER_PROCESSOR_OUT_INITIALIZER (   AttributeInfo)
Value:
{BOOST_STATIC_ASSERT_MSG(IPSDK_NAMESPACE_NAME(BOOST_PP_SEQ_ELEM(0, AttributeInfo)) \
BOOST_PP_SEQ_ELEM(1, AttributeInfo)::g_bOutput == true, \
"Output initializer should only be defined on output attributes");} \
BOOST_PP_CAT(BOOST_PP_CAT(_p, BOOST_PP_SEQ_ELEM(1, AttributeInfo)),Initializer) = \
BOOST_PP_SEQ_ELEM(2, AttributeInfo)( \
BOOST_PP_SEQ_ENUM((BOOST_PP_CAT(_p, BOOST_PP_SEQ_ELEM(1, AttributeInfo))) \
BOOST_PP_IF(BOOST_PP_GREATER(BOOST_PP_SEQ_SIZE(AttributeInfo), 3), \
BOOST_PP_SEQ_REST_N( \
BOOST_PP_MIN(BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(AttributeInfo)), 3), \
AttributeInfo),))); \
outputInitializerColl.insert(std::make_pair( \
BOOST_PP_CAT(_p, BOOST_PP_SEQ_ELEM(1, AttributeInfo))->getObjectName(), \
BOOST_PP_CAT(BOOST_PP_CAT(_p, BOOST_PP_SEQ_ELEM(1, AttributeInfo)),Initializer)));
IPSDK_NAMESPACE_NAME
#define IPSDK_NAMESPACE_NAME(namespaceSeq)
macro allowing to print full namespace name
Definition: BaseMacros.h:92

[INTERNAL] macro allowing to register a processor attribute output initializer

◆ IPSDK_REGISTER_PROCESSOR_INITIALIZER_MACRO

#define IPSDK_REGISTER_PROCESSOR_INITIALIZER_MACRO (   s,
  _,
  n,
  AttributeInfo 
)
Value:
BOOST_PP_IF(BOOST_PP_SUB(BOOST_PP_SEQ_SIZE(AttributeInfo), 2), \
IPSDK_REGISTER_PROCESSOR_OUT_INITIALIZER, \
BOOST_PP_TUPLE_EAT(1))(AttributeInfo)
IPSDK_REGISTER_PROCESSOR_OUT_INITIALIZER
#define IPSDK_REGISTER_PROCESSOR_OUT_INITIALIZER(AttributeInfo)
[INTERNAL] macro allowing to register a processor attribute output initializer
Definition: ProcessorHdrDetailsMacros.h:152

[INTERNAL] macro allowing to register a processor attribute initializer

◆ IPSDK_DECLARE_PROCESSOR

#define IPSDK_DECLARE_PROCESSOR (   libraryName,
  className,
  RuleString,
  attributeSeq 
)
Value:
IPSDK_DECLARE_ACTION(libraryName, className) \
friend class ipsdk::processor::ProcessorFactory; \
public: \
static boost::shared_ptr<className> createProcessor(); \
protected: \
static ipsdk::processor::ProcessorPtr createBaseProcessor(); \
protected: \
className(); \
public: \
~className(); \
public: \
static const ipsdk::processor::ProcessorDispatchPolicy& getDefaultDispatchPolicy(); \
protected: \
ipsdk::BoolResult initDerived(AttributeColl& attributeColl, \
OutputInitializerColl& outputInitializerColl, \
ipsdk::processor::ProcessorDispatchPolicy& dispatchPolicy, \
ipsdk::processor::RulePtr& pGlobalRule, \
const ipsdk::processor::eProcessorRulePolicy& rulePolicy); \
private: \
ipsdk::processor::RulePtr createRule() const { \
ipsdk::processor::RulePtr pRule = RuleString; \
return pRule; \
} \
IPSDK_DECLARE_PROCESSOR_ATTRIBUTES(className, attributeSeq)
ipsdk::processor::RulePtr
boost::shared_ptr< BaseRule > RulePtr
shared pointer to rule
Definition: RuleTypes.h:104
ipsdk::processor::ProcessorFactory
Factory singleton allowing dynamic creation of registred processors.
Definition: ProcessorFactory.h:37
ipsdk::processor::ProcessorPtr
boost::shared_ptr< BaseProcessor > ProcessorPtr
shared pointer to processor class
Definition: ProcessorTypes.h:106
ipsdk::BoolResult
ProcessingResult< bool > BoolResult
typedef for boolean results associated to a string description
Definition: ProcessingResultTypes.h:29
IPSDK_DECLARE_ACTION
#define IPSDK_DECLARE_ACTION(libraryName, className)
macro allowing to declare an action concrete class
Definition: ActionHdrMacros.h:27
ipsdk::processor::ProcessorDispatchPolicy
Class encapsuling dispatch policy for processor dispatcher classes.
Definition: ProcessorDispatchPolicy.h:33
ipsdk::processor::ProcessorFactory::createProcessor
ProcessorPtr createProcessor(const std::string &className) const
create instance of a registered processor class
ipsdk::processor::eProcessorRulePolicy
eProcessorRulePolicy
Enumerate describing processor rule policy.
Definition: ProcessorTypes.h:65

[INTERNAL] macro allowing to declare a processor

◆ IPSDK_DECLARE_SYNC_PROCESSOR

#define IPSDK_DECLARE_SYNC_PROCESSOR (   libraryName,
  className,
  RuleString,
  attributeSeq 
)
Value:
class IPSDK_LIB_API(libraryName) className : \
public ipsdk::processor::BaseSyncProcessor { \
IPSDK_DECLARE_PROCESSOR(libraryName, className, RuleString, attributeSeq) \
protected: \
ipsdk::core::ExecResult mainProcess();
ipsdk::processor::BaseSyncProcessor::mainProcess
virtual core::ExecResult mainProcess()=0
main processing method overloaded in derived class
ipsdk::core::ExecResult
ProcessingResult< eExecutionResult > ExecResult
type used to retrieve an execution result
Definition: ProcessingTypes.h:65
ipsdk::processor::BaseSyncProcessor
Base class for synchronous processors.
Definition: BaseSyncProcessor.h:26

macro allowing to declare a processor with synchronous behavior

◆ IPSDK_DECLARE_ASYNC1_PROCESSOR

#define IPSDK_DECLARE_ASYNC1_PROCESSOR (   libraryName,
  className,
  RuleString,
  attributeSeq 
)
Value:
class IPSDK_LIB_API(libraryName) className : \
public ipsdk::processor::BaseAsync1Processor { \
IPSDK_DECLARE_PROCESSOR(libraryName, className, RuleString, attributeSeq) \
protected: \
ipsdk::processor::RetrievalResult \
retrieveProvider(const ipsdk::core::BasePriority& priority, \
ipsdk::core::ActionProviderPtr& pProvider);
ipsdk::core::BasePriority
Base class for priority encapsulation.
Definition: BasePriority.h:32
ipsdk::processor::BaseAsync1Processor
Base class for asynchronous processors using a single provider.
Definition: BaseAsync1Processor.h:26
ipsdk::core::ActionProviderPtr
boost::shared_ptr< BaseActionProvider > ActionProviderPtr
shared pointer to action provider
Definition: ActionProviderTypes.h:58

macro allowing to declare a processor with asynchronous behavior using a single provider

◆ IPSDK_DECLARE_ASYNC2_PROCESSOR

#define IPSDK_DECLARE_ASYNC2_PROCESSOR (   libraryName,
  className,
  RuleString,
  attributeSeq 
)
Value:
class IPSDK_LIB_API(libraryName) className : \
public ipsdk::processor::BaseAsync2Processor { \
IPSDK_DECLARE_PROCESSOR(libraryName, className, RuleString, attributeSeq) \
protected: \
ipsdk::processor::RetrievalResult \
retrieveFirstProvider(const ipsdk::core::BasePriority& priority, \
ipsdk::core::ActionProviderPtr& pProvider); \
ipsdk::processor::RetrievalResult \
retrieveSecondProvider(const ipsdk::core::BasePriority& priority, \
ipsdk::core::ActionProviderPtr& pProvider);
ipsdk::core::BasePriority
Base class for priority encapsulation.
Definition: BasePriority.h:32
ipsdk::processor::BaseAsync2Processor
Base class for asynchronous processors using two providers.
Definition: BaseAsync2Processor.h:26
ipsdk::core::ActionProviderPtr
boost::shared_ptr< BaseActionProvider > ActionProviderPtr
shared pointer to action provider
Definition: ActionProviderTypes.h:58

macro allowing to declare a processor with asynchronous behavior using two providers

◆ IPSDK_DECLARE_ASYNC3_PROCESSOR

#define IPSDK_DECLARE_ASYNC3_PROCESSOR (   libraryName,
  className,
  RuleString,
  attributeSeq 
)
Value:
class IPSDK_LIB_API(libraryName) className : \
public ipsdk::processor::BaseAsync3Processor { \
IPSDK_DECLARE_PROCESSOR(libraryName, className, RuleString, attributeSeq) \
protected: \
ipsdk::processor::RetrievalResult \
retrieveFirstProvider(const ipsdk::core::BasePriority& priority, \
ipsdk::core::ActionProviderPtr& pProvider); \
ipsdk::processor::RetrievalResult \
retrieveSecondProvider(const ipsdk::core::BasePriority& priority, \
ipsdk::core::ActionProviderPtr& pProvider); \
ipsdk::processor::RetrievalResult \
retrieveThirdProvider(const ipsdk::core::BasePriority& priority, \
ipsdk::core::ActionProviderPtr& pProvider);
ipsdk::processor::BaseAsync3Processor
Base class for asynchronous processors using three providers.
Definition: BaseAsync3Processor.h:26
ipsdk::core::BasePriority
Base class for priority encapsulation.
Definition: BasePriority.h:32
ipsdk::core::ActionProviderPtr
boost::shared_ptr< BaseActionProvider > ActionProviderPtr
shared pointer to action provider
Definition: ActionProviderTypes.h:58

macro allowing to declare a processor with asynchronous behavior using three providers

◆ IPSDK_DECLARE_ASYNC4_PROCESSOR

#define IPSDK_DECLARE_ASYNC4_PROCESSOR (   libraryName,
  className,
  RuleString,
  attributeSeq 
)
Value:
class IPSDK_LIB_API(libraryName) className : \
public ipsdk::processor::BaseAsync4Processor { \
IPSDK_DECLARE_PROCESSOR(libraryName, className, RuleString, attributeSeq) \
protected: \
ipsdk::processor::RetrievalResult \
retrieveFirstProvider(const ipsdk::core::BasePriority& priority, \
ipsdk::core::ActionProviderPtr& pProvider); \
ipsdk::processor::RetrievalResult \
retrieveSecondProvider(const ipsdk::core::BasePriority& priority, \
ipsdk::core::ActionProviderPtr& pProvider); \
ipsdk::processor::RetrievalResult \
retrieveThirdProvider(const ipsdk::core::BasePriority& priority, \
ipsdk::core::ActionProviderPtr& pProvider); \
ipsdk::processor::RetrievalResult \
retrieveFourthProvider(const ipsdk::core::BasePriority& priority, \
ipsdk::core::ActionProviderPtr& pProvider);
ipsdk::core::BasePriority
Base class for priority encapsulation.
Definition: BasePriority.h:32
ipsdk::processor::BaseAsync4Processor
Base class for asynchronous processors using three providers.
Definition: BaseAsync4Processor.h:26
ipsdk::core::ActionProviderPtr
boost::shared_ptr< BaseActionProvider > ActionProviderPtr
shared pointer to action provider
Definition: ActionProviderTypes.h:58

macro allowing to declare a processor with asynchronous behavior using three providers

◆ IPSDK_DECLARE_ITER_ASYNC1_PROCESSOR

#define IPSDK_DECLARE_ITER_ASYNC1_PROCESSOR (   libraryName,
  className,
  RuleString,
  attributeSeq 
)
Value:
class IPSDK_LIB_API(libraryName) className : \
public ipsdk::processor::BaseIterativeAsync1Processor { \
IPSDK_DECLARE_PROCESSOR(libraryName, className, RuleString, attributeSeq) \
protected: \
ipsdk::ipUInt32 retrieveNbIter(); \
ipsdk::processor::RetrievalResult \
retrieveProvider(const ipsdk::core::BasePriority& priority, \
const ipsdk::ipUInt32 curNbIter, \
ipsdk::core::ActionProviderPtr& pProvider);
ipsdk::processor::BaseIterativeAsync1Processor::retrieveNbIter
virtual ipUInt32 retrieveNbIter()=0
method allowing to retrieve number of iterations associated to asynchronous processing in derived cla...
ipsdk::core::BasePriority
Base class for priority encapsulation.
Definition: BasePriority.h:32
ipsdk::processor::BaseIterativeAsync1Processor
Base class for asynchronous processors using iteratively a single provider.
Definition: BaseIterativeAsync1Processor.h:27
ipsdk::core::ActionProviderPtr
boost::shared_ptr< BaseActionProvider > ActionProviderPtr
shared pointer to action provider
Definition: ActionProviderTypes.h:58
ipsdk::ipUInt32
uint32_t ipUInt32
Base types definition.
Definition: BaseTypes.h:53

macro allowing to declare a processor with asynchronous iterative behavior using a single provider

◆ IPSDK_DECLARE_ITER_ASYNC2_PROCESSOR

#define IPSDK_DECLARE_ITER_ASYNC2_PROCESSOR (   libraryName,
  className,
  RuleString,
  attributeSeq 
)
Value:
class IPSDK_LIB_API(libraryName) className : \
public ipsdk::processor::BaseIterativeAsync2Processor { \
IPSDK_DECLARE_PROCESSOR(libraryName, className, RuleString, attributeSeq) \
protected: \
ipsdk::ipUInt32 retrieveNbIter(); \
ipsdk::processor::RetrievalResult \
retrieveFirstProvider(const ipsdk::core::BasePriority& priority, \
const ipsdk::ipUInt32 curNbIter, \
ipsdk::core::ActionProviderPtr& pProvider); \
ipsdk::processor::RetrievalResult \
retrieveSecondProvider(const ipsdk::core::BasePriority& priority, \
const ipsdk::ipUInt32 curNbIter, \
ipsdk::core::ActionProviderPtr& pProvider);
ipsdk::core::BasePriority
Base class for priority encapsulation.
Definition: BasePriority.h:32
ipsdk::processor::BaseIterativeAsync2Processor::retrieveNbIter
virtual ipUInt32 retrieveNbIter()=0
method allowing to retrieve number of iterations associated to asynchronous processing in derived cla...
ipsdk::processor::BaseIterativeAsync2Processor
Base class for asynchronous processors using iteratively two providers.
Definition: BaseIterativeAsync2Processor.h:27
ipsdk::core::ActionProviderPtr
boost::shared_ptr< BaseActionProvider > ActionProviderPtr
shared pointer to action provider
Definition: ActionProviderTypes.h:58
ipsdk::ipUInt32
uint32_t ipUInt32
Base types definition.
Definition: BaseTypes.h:53

macro allowing to declare a processor with asynchronous iterative behavior using two providers

◆ IPSDK_DECLARE_REP_ASYNC1_PROCESSOR

#define IPSDK_DECLARE_REP_ASYNC1_PROCESSOR (   libraryName,
  className,
  RuleString,
  attributeSeq 
)
Value:
class IPSDK_LIB_API(libraryName) className : \
public ipsdk::processor::BaseRepeatedAsync1Processor { \
IPSDK_DECLARE_PROCESSOR(libraryName, className, RuleString, attributeSeq) \
protected: \
ipsdk::processor::RetrievalResult \
retrieveProvider(const ipsdk::core::BasePriority& priority, \
const ipsdk::ipUInt32 curNbIter, \
ipsdk::core::ActionProviderPtr& pProvider);
ipsdk::processor::BaseRepeatedAsync1Processor
Base class for asynchronous processors using a single provider repeatedly (without knowing in advance...
Definition: BaseRepeatedAsync1Processor.h:27
ipsdk::core::BasePriority
Base class for priority encapsulation.
Definition: BasePriority.h:32
ipsdk::core::ActionProviderPtr
boost::shared_ptr< BaseActionProvider > ActionProviderPtr
shared pointer to action provider
Definition: ActionProviderTypes.h:58
ipsdk::ipUInt32
uint32_t ipUInt32
Base types definition.
Definition: BaseTypes.h:53

macro allowing to declare a processor with asynchronous repeated behavior using a single provider

◆ IPSDK_DECLARE_REP_ASYNC2_PROCESSOR

#define IPSDK_DECLARE_REP_ASYNC2_PROCESSOR (   libraryName,
  className,
  RuleString,
  attributeSeq 
)
Value:
class IPSDK_LIB_API(libraryName) className : \
public ipsdk::processor::BaseRepeatedAsync2Processor { \
IPSDK_DECLARE_PROCESSOR(libraryName, className, RuleString, attributeSeq) \
protected: \
ipsdk::processor::RetrievalResult \
retrieveFirstProvider(const ipsdk::core::BasePriority& priority, \
const ipsdk::ipUInt32 curNbIter, \
ipsdk::core::ActionProviderPtr& pProvider); \
ipsdk::processor::RetrievalResult \
retrieveSecondProvider(const ipsdk::core::BasePriority& priority, \
const ipsdk::ipUInt32 curNbIter, \
ipsdk::core::ActionProviderPtr& pProvider);
ipsdk::core::BasePriority
Base class for priority encapsulation.
Definition: BasePriority.h:32
ipsdk::processor::BaseRepeatedAsync2Processor
Base class for asynchronous processors using two providers repeatedly (without knowing in advance num...
Definition: BaseRepeatedAsync2Processor.h:27
ipsdk::core::ActionProviderPtr
boost::shared_ptr< BaseActionProvider > ActionProviderPtr
shared pointer to action provider
Definition: ActionProviderTypes.h:58
ipsdk::ipUInt32
uint32_t ipUInt32
Base types definition.
Definition: BaseTypes.h:53

macro allowing to declare a processor with asynchronous repeated behavior using two providers

◆ IPSDK_DECLARE_STATIC_RESULT_COLL

#define IPSDK_DECLARE_STATIC_RESULT_COLL (   AttributeType,
  CollType 
)
Value:
typedef std::map<ipsdk::ipUInt32, AttributeType::StorageType> CollType; \
boost::shared_ptr<CollType> BOOST_PP_CAT(_p, CollType);

macro allowing to declare a collection used for static processing dispatch results merge

◆ IPSDK_DECLARE_DYNAMIC_RESULT_COLL

#define IPSDK_DECLARE_DYNAMIC_RESULT_COLL (   AttributeType,
  CollType 
)
Value:
typedef std::map<ipsdk::ElementsRange, AttributeType::StorageType> CollType; \
boost::shared_ptr<CollType> BOOST_PP_CAT(_p, CollType);

macro allowing to declare a collection used for dynamic processing dispatch results merge

Generated on Tue Apr 15 2025 16:20:51 for IPSDK by   doxygen 1.8.14