PlanIndexedSplit.h

// PlanIndexedSplit.h:
// -------------------
//

#ifndef __IPSDKIMAGEPROCESSING_PLANINDEXEDSPLIT_H__
#define __IPSDKIMAGEPROCESSING_PLANINDEXEDSPLIT_H__

#include <IPSDKImageProcessing/DataSplit/PlanIndexed/BasePlanIndexedSplit.h>
 #include <boost/type_traits/remove_const.hpp>

namespace ipsdk {
namespace imaproc {


template <typename TProcessor, typename InputStorageType, typename TAttribute>
class PlanIndexedSplit : public BasePlanIndexedSplit
{
// predefined public types
public:
    typedef TProcessor ProcessorType;

    typedef TAttribute AttributeType;

    typedef typename InputStorageType::element_type InputValueType;

    typedef typename boost::remove_const<InputValueType>::type InputMutableValueType;

    typedef typename TAttribute::StorageType OutputStorageType;

public:
    PlanIndexedSplit() {}
    ~PlanIndexedSplit() {}

// methods
public:
    const std::string&  getAttributeName() const;

    const std::string&  getAttributeToolTip() const;

    void                init(const InputStorageType& pPlanIndexedColl,
                             const ipUInt64 sizeZ,
                             const ipUInt64 sizeC,
                             const ipUInt64 sizeT,
                             const bool bCanBeSingle = false);

protected:
    bool                checkProcessorType(const processor::BaseProcessor& processor);

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

// attributes
protected:

};


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

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

template <typename TProcessor, typename InputStorageType, typename TAttribute>
inline void
PlanIndexedSplit<TProcessor, InputStorageType, TAttribute>::init(const InputStorageType& pPlanIndexedColl,
                                                                 const ipUInt64 sizeZ,
                                                                 const ipUInt64 sizeC,
                                                                 const ipUInt64 sizeT,
                                                                 const bool bCanBeSingle)
{
    // call of base class initialization method
    this->initBase(boost::const_pointer_cast<InputMutableValueType>(pPlanIndexedColl), sizeZ, sizeC, sizeT, bCanBeSingle);
}

template <typename TProcessor, typename InputStorageType, typename TAttribute>
inline bool
PlanIndexedSplit<TProcessor, InputStorageType, TAttribute>::checkProcessorType(const processor::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 InputStorageType, typename TAttribute>
inline BoolResult
PlanIndexedSplit<TProcessor, InputStorageType, TAttribute>::processAttribute(processor::BaseProcessor& processor,
                                                                             const ipUInt32 elementIdx,
                                                                             const core::BaseRequestOrigin& requestOrigin)
{
    // cast of input processor object
    TProcessor& tProcessor = static_cast<TProcessor&>(processor);

    // retrieve plan indexed collection
    InputStorageType pPlanIndexedColl = boost::static_pointer_cast<InputValueType>(_pPlanIndexedColl);

    // check for single element
    OutputStorageType pOutputData;
    if (pPlanIndexedColl->getNbPlans() > 1) {

        // retrieve associated element into collection
        const ipUInt64 tPlanIdx = elementIdx / (_sizeZ * _sizeC);
        const ipUInt64 cPlanIdx = (elementIdx - tPlanIdx * _sizeZ * _sizeC) / _sizeZ;
        const ipUInt64 zPlanIdx = (elementIdx - tPlanIdx * _sizeZ * _sizeC - cPlanIdx * _sizeZ);
        pOutputData = pPlanIndexedColl->getStorage(zPlanIdx, cPlanIdx, tPlanIdx);
    }
    else
        pOutputData = pPlanIndexedColl->getStorage(0, 0, 0);

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

    return true;
}


} // end of namespace imaproc
} // end of namespace ipsdk

#endif // __IPSDKIMAGEPROCESSING_PLANINDEXEDSPLIT_H__