DynamicByCopyResultSplit.h

// DynamicByCopyResultSplit.h:
// ---------------------------
//

#ifndef __IPSDKBASEPROCESSING_DYNAMICBYCOPYRESULTSPLIT_H__
#define __IPSDKBASEPROCESSING_DYNAMICBYCOPYRESULTSPLIT_H__

#include <IPSDKBaseProcessing/DataSplit/Dynamic/BaseDynamicSplit.h>
#include <IPSDKBaseData/Range/ElementsRange.h>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/static_assert.hpp>
#include <boost/make_shared.hpp>
#include <boost/function.hpp>
#include <map>

namespace ipsdk {
namespace processor {


template <typename TProcessor, typename TAttribute>
class DynamicByCopyResultSplit : public BaseDynamicSplit
{
// predefined public types
public:
    static const eSplitDynamicType::domain g_splitDynamicType = eSplitDynamicType::eSDT_ByCreationResult;

    typedef TProcessor ProcessorType;

    typedef TAttribute AttributeType;

    typedef typename TAttribute::ValueType ValueType;

    typedef typename boost::enable_if<typename boost::is_same<typename TAttribute::StorageType,
                                                              boost::shared_ptr<typename TAttribute::ValueType> >::type,
                                      typename TAttribute::StorageType>::type ParameterType;

    typedef std::map<ElementsRange, ParameterType> ParameterColl;

    typedef boost::shared_ptr<ParameterColl> ParameterCollPtr;

    typedef boost::function<ParameterType (const ValueType&)> CopyFunType;

public:
    DynamicByCopyResultSplit() {}
    ~DynamicByCopyResultSplit() {}

// methods
public:
    eSplitDynamicType   getSplitDynamicType() const;

    const std::string&  getAttributeName() const;

    const std::string&  getAttributeToolTip() const;

    void                init(const ParameterCollPtr& pParameterColl,
                             const ParameterType& pDefaultValue);
    void                init(const ParameterCollPtr& pParameterColl,
                             const ParameterType& pDefaultValue,
                             const CopyFunType& pCopyFunction);

protected:
    bool                checkProcessorType(const BaseProcessor& processor);

    BoolResult          processAttribute(BaseProcessor& processor,
                                         const ipUInt64 elementIdx,
                                         const ipUInt64 nbElements,
                                         const core::BaseRequestOrigin& requestOrigin);

// attributes
protected:
    ParameterCollPtr        _pParameterColl;

    ParameterType           _pDefaultValue;

    CopyFunType             _pCopyFunction;
};


template <typename TProcessor, typename TAttribute>
inline eSplitDynamicType
DynamicByCopyResultSplit<TProcessor, TAttribute>::getSplitDynamicType() const
{
    return g_splitDynamicType;
}

template <typename TProcessor, typename TAttribute>
inline const std::string&
DynamicByCopyResultSplit<TProcessor, TAttribute>::getAttributeName() const
{
    return TAttribute::getObjectNameStr();
}

template <typename TProcessor, typename TAttribute>
inline const std::string&
DynamicByCopyResultSplit<TProcessor, TAttribute>::getAttributeToolTip() const
{
    return TAttribute::getToolTipStr();
}

template <typename TProcessor, typename TAttribute>
inline void
DynamicByCopyResultSplit<TProcessor, TAttribute>::init(const ParameterCollPtr& pParameterColl,
                                                       const ParameterType& pDefaultValue)
{
    init(pParameterColl, pDefaultValue, static_cast<ParameterType (*)(const ValueType&)>(&boost::make_shared<ValueType>));
}

template <typename TProcessor, typename TAttribute>
inline void
DynamicByCopyResultSplit<TProcessor, TAttribute>::init(const ParameterCollPtr& pParameterColl,
                                                       const ParameterType& pDefaultValue,
                                                       const CopyFunType& pCopyFunction)
{
    // check for input shared pointers validity
    if (pParameterColl.get() == 0)
        throwNullInputSharedPtr();
    if (pDefaultValue.get() == 0)
        throwNullInputSharedPtr();

    // call of base class initialization method
    ElementsLocationInfo elementsLocationInfo;
    elementsLocationInfo.insertNonLocalized(ElementsRange(0, 1), 0);
    this->initUnSplitted(elementsLocationInfo);

    // collection of elements associated to dynamic split
    _pParameterColl = pParameterColl;
    _pParameterColl->clear();

    // default value for newly created elements
    _pDefaultValue = pDefaultValue;

    // store copy function
    _pCopyFunction = pCopyFunction;
}

template <typename TProcessor, typename TAttribute>
inline bool
DynamicByCopyResultSplit<TProcessor, TAttribute>::checkProcessorType(const BaseProcessor& processor)
{
    // check for consistency between processor and attribute
    BOOST_STATIC_ASSERT_MSG((processor::ExistsAttribute<TAttribute, typename TProcessor::AttributesInfo>::g_bValue),
                            "This attribute is not part of processor class");

    return dynamic_cast<const TProcessor*>(&processor) != 0;
}

template <typename TProcessor, typename TAttribute>
inline BoolResult
DynamicByCopyResultSplit<TProcessor, TAttribute>::processAttribute(BaseProcessor& processor,
                                                                   const ipUInt64 elementIdx,
                                                                   const ipUInt64 nbElements,
                                                                   const core::BaseRequestOrigin& requestOrigin)
{
    // cast of input processor object
    TProcessor& tProcessor = static_cast<TProcessor&>(processor);

    // creation of a new result element
    ParameterType pCurResult = _pCopyFunction(*_pDefaultValue);

    // insertion of element into collection
    (*_pParameterColl)[ElementsRange(elementIdx, nbElements)] = pCurResult;

    // update of processor attribute value
    tProcessor.TProcessor::template set<TAttribute>(pCurResult);

    return true;
}


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

#endif // __IPSDKBASEPROCESSING_DYNAMICBYCOPYRESULTSPLIT_H__