DynamicByRangeDataSplit.h

// DynamicByRangeDataSplit.h:
// --------------------------
//

#ifndef __IPSDKBASEPROCESSING_DYNAMICBYRANGEDATASPLIT_H__
#define __IPSDKBASEPROCESSING_DYNAMICBYRANGEDATASPLIT_H__

#include <IPSDKBaseProcessing/DataSplit/Dynamic/BaseDynamicSplit.h>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/make_shared.hpp>
#include <vector>

namespace ipsdk {
namespace processor {


template <typename TProcessor, typename TAttribute, typename CollField, typename ValueField>
class DynamicByRangeDataSplit : public BaseDynamicSplit
{
// predefined public types
public:
    static const eSplitDynamicType::domain g_splitDynamicType = eSplitDynamicType::eSDT_ByRangeData;

    typedef TProcessor ProcessorType;

    typedef TAttribute AttributeType;

    typedef typename boost::enable_if<typename boost::is_same<boost::mpl::int_<AttributeType::g_attributeType>,
                                                              boost::mpl::int_<processor::eAttributeType::eAT_DataItem> >::type,
                                      typename AttributeType::ValueType>::type DataItemType;

    typedef typename TAttribute::StorageType StorageType;

    typedef typename TAttribute::ValueType ValueType;

public:
    DynamicByRangeDataSplit();
    ~DynamicByRangeDataSplit();

// methods
public:
    eSplitDynamicType   getSplitDynamicType() const;

    const std::string&  getAttributeName() const;

    const std::string&  getAttributeToolTip() const;

    void                init(const StorageType& pDataItem,
                             const IdxCollMapPtr& pIdxCollMap);
    void                init(const StorageType& pDataItem);


protected:
    bool                checkProcessorType(const BaseProcessor& processor);

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

// attributes
protected:
    StorageType             _pDataItem;

    IdxCollMapPtr           _pIdxCollMap;
};


template <typename TProcessor, typename TAttribute, typename CollField, typename ValueField>
DynamicByRangeDataSplit<TProcessor, TAttribute, CollField, ValueField>::DynamicByRangeDataSplit()
{

}

template <typename TProcessor, typename TAttribute, typename CollField, typename ValueField>
DynamicByRangeDataSplit<TProcessor, TAttribute, CollField, ValueField>::~DynamicByRangeDataSplit()
{

}

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

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

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

template <typename TProcessor, typename TAttribute, typename CollField, typename ValueField>
inline void
DynamicByRangeDataSplit<TProcessor, TAttribute, CollField, ValueField>::init(const StorageType& pDataItem,
                                                                             const IdxCollMapPtr& pIdxCollMap)
{
    // check for input shared pointers validity
    if (pDataItem.get() == 0 || pIdxCollMap.get() == 0)
        throwNullInputSharedPtr();

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

    // data item associated to dynamic split
    _pDataItem = pDataItem;

    // default value for newly created elements
    _pIdxCollMap = pIdxCollMap;
    _pIdxCollMap->clear();
}

template <typename TProcessor, typename TAttribute, typename CollField, typename ValueField>
inline void
DynamicByRangeDataSplit<TProcessor, TAttribute, CollField, ValueField>::init(const StorageType& pDataItem)
{
    // check for input shared pointers validity
    if (pDataItem.get() == 0)
        throwNullInputSharedPtr();

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

    // data item associated to dynamic split
    _pDataItem = pDataItem;

    // default value for newly created elements
    _pIdxCollMap.reset();
}

template <typename TProcessor, typename TAttribute, typename CollField, typename ValueField>
inline bool
DynamicByRangeDataSplit<TProcessor, TAttribute, CollField, ValueField>::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, typename CollField, typename ValueField>
inline BoolResult
DynamicByRangeDataSplit<TProcessor, TAttribute, CollField, ValueField>::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 collections of index and of attribute parameters
    IdxCollPtr pIdxColl(boost::make_shared<IdxColl>());
    boost::shared_ptr<ValueType> pParamColl(boost::make_shared<ValueType>());

    // retrieve range end index
    const ipUInt64 endElementIdx = elementIdx + nbElements;

    // retrieve collection of data items
    typedef typename DataItemType::template ChildNodeInfo<CollField>::CollType ParameterPtrCollType;
    const ParameterPtrCollType& vPrms = _pDataItem->template getNode<CollField>().getColl();
    const ipUInt64 nbData = static_cast<ipUInt64>(vPrms.size());

    // parse all data from collection
    for(ipUInt64 i=0; i<nbData; ++i) {

        // retrieve current data item
        typedef typename TAttribute::ValueType::template ChildNodeInfo<CollField>::CollNodePtrType ParameterPtrType;
        const ParameterPtrType& pCurDataItem = vPrms[i];

        // retrieve value field for current data
        const ipUInt64 curValue = static_cast<ipUInt64>(pCurDataItem->template getValue<ValueField>());

        // check whether value field match requested range
        if(curValue >= elementIdx && curValue < endElementIdx) {

            // insertion of index and of parameter into collections
            if (_pIdxCollMap.get() != 0)
                pIdxColl->push_back(i);
            pParamColl->template push_back<CollField>(pCurDataItem);
        }
    }

    // update of index collection associated to range
    if (_pIdxCollMap.get() != 0)
        (*_pIdxCollMap)[ElementsRange(elementIdx, nbElements)] = pIdxColl;

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

    return true;
}


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

#endif // __IPSDKBASEPROCESSING_DYNAMICRESULTSPLIT_H__