BaseProcessor.h

// BaseProcessor.h:
// ----------------
//

#ifndef __IPSDKBASEPROCESSING_BASEPROCESSOR_H__
#define __IPSDKBASEPROCESSING_BASEPROCESSOR_H__

// suppression warnings
// warning C4251: 'ipsdk::processor::BaseProcessor::_pHeader' : class 'boost::shared_ptr<T>' needs to have dll-interface to be used by clients of class 'ipsdk::processor::BaseProcessor'
#pragma warning (push)
#pragma warning (disable : 4251)

#include <IPSDKBaseProcessing/IPSDKBaseProcessingExports.h>
#include <IPSDKBaseProcessing/Processor/ProcessorTypes.h>
#include <IPSDKCore/Processing/Action/Complex/BaseComplexAction.h>
#include <IPSDKBaseProcessing/Attribute/Base/AttributeTypes.h>
#include <IPSDKBaseProcessing/OutputInitializer/OutputInitializerTypes.h>
#include <IPSDKBaseProcessing/Rule/RuleTypes.h>
#include <IPSDKBaseData/DataItem/DataItemTypes.h>
#include <IPSDKSerialization/Engine/SerializationHdrMacro.h>
#include <IPSDKUtil/BaseCollections.h>
#include <IPSDKUtil/Tools/ProcessingResult.h>
#include <map>

namespace ipsdk {
namespace processor {

class ProcessorFactory;


class IPSDKBASEPROCESSING_API BaseProcessor : public core::BaseComplexAction
{
    // declare dynamic class
    IPSDK_DECLARE_ABSTRACT_SERIAL_WITHOUT_COPY(IPSDKBaseProcessing, BaseProcessor);

    // friend class for private member access

protected:
    BaseProcessor();

public:
    virtual ~BaseProcessor() = 0;
    
// methods
public:
    virtual eProcessorType          getProcessorType() const = 0;

    BoolResult                      init(const eProcessorRulePolicy rulePolicy = eProcessorRulePolicy::ePRP_DisableSubRules);

    const eProcessorRulePolicy&     getProcessorRulePolicy() const;

    std::string                     getFullInfoStr() const;

    //------------------------
    //------------------------

    bool                            existsHeaderKey(const std::string& key) const;

    ItemNames                       getHeaderKeys() const;

    const BaseDataItem&             getHeaderItem(const std::string& key) const;

    BaseDataItem&                   getHeaderItem(const std::string& key);

    void                            addHeaderItem(const std::string& key,
                                                  const DataItemPtr& pItem);

    void                            removeHeaderItem(const std::string& key);

    // remove all items from header
    void                            clearHeader();

    //----------------------------
    //----------------------------

    ipUInt32                        getNbAttributes() const;

    const BaseAttribute&            getAttribute(ipUInt32 index) const;

    BaseAttribute&                  getAttribute(ipUInt32 index);

    bool                            existsAttribute(const std::string& attributeName) const;

    StringVector                    getAttributeNameColl() const;

    const BaseAttribute&            getAttribute(const std::string& attributeName) const;

    BaseAttribute&                  getAttribute(const std::string& attributeName);

    //-----------------------------------------------
    //-----------------------------------------------

    bool                            hasOutputInitializer(const std::string& attributeName) const;

    const BaseOutputInitializer&    getOutputInitializer(const std::string& attributeName) const;

    const BaseRule&                 getGlobalRule() const;

    const ProcessorDispatchPolicy&  getDispatchPolicy() const;

    void                            restrictDispatchPolicy(const ProcessorDispatchPolicy& policy);

    bool                            isProgressAvailable() const;

    ipsdk::processor::eProcessorProgressAvailability
    getProgressAvailability() const;

    ipsdk::ipUInt64                 getTotalNbIterations() const;

protected:
    typedef std::vector<AttributePtr> AttributeColl;

    typedef std::map<std::string, OutputInitializerPtr> OutputInitializerColl;

    virtual BoolResult              initDerived(AttributeColl& attributeColl,
                                                OutputInitializerColl& outputInitializerColl,
                                                ProcessorDispatchPolicy& dispatchPolicy,
                                                RulePtr& pGlobalRule,
                                                const eProcessorRulePolicy& rulePolicy) = 0;

// attributes
protected:
    eProcessorProgressAvailability  _processorProgressAvailability;

    ipUInt32        _nbIter;

private:
    BoolResult                      globalCleanDerived();

    core::ExecResult                initProcess();

    core::ExecResult                endProcess();

    BoolResult                      syncInputDataDerived(const Guid& processingSocketGuid);

    BoolResult                      syncOutputDataDerived(const Guid& processingSocketGuid);

    void                            clearInputData();

    void                            clearOutputData();

    bool                            checkLicenseValidity() const;

// attributes
private:
    eProcessorRulePolicy            _rulePolicy;

    DataItemMapPtr                  _pHeader;

    AttributeColl                   _attributeColl;

    OutputInitializerColl           _outputInitializerColl;

    RulePtr                         _pGlobalRule;

    ProcessorDispatchPolicyPtr      _pProcessorDispatchPolicy;
};


} // end of namespace processor
} // end of namespace ipsdk

#pragma warning (pop)

#endif // __IPSDKBASEPROCESSING_BASEPROCESSOR_H__