PythonPlanIndexedColl.h

Go to the documentation of this file.

// PythonPlanIndexedColl.h:
// ------------------------
//

#ifndef __PYIPSDKBASE_PYTHONPLANINDEXEDCOLL_H__
#define __PYIPSDKBASE_PYTHONPLANINDEXEDCOLL_H__

#include <IPSDKBaseData/PlanIndex/PlanIndex.h>
#include <IPSDKBaseData/PlanIndex/PlanIndexedCollTypes.h>
#include <IPSDKBaseData/PlanIndex/BasePlanIndexedColl.h>
#include <IPSDKBaseData/DataItem/Node/BaseDataItemNode.h>
#include <IPSDKBaseData/DataItem/DataItemUtils.h>
#include <Python/PyIPSDKBase/PythonDataItem.h>
#include <Python/PyIPSDKBase/PythonMacros.h>
#include <boost/python/dict.hpp>
#include <boost/python/tuple.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_base_of.hpp>
#include <IPSDKMath/Constants.h>

namespace ipsdk {
namespace python {


template <typename CollType>
typename boost::enable_if<boost::is_base_of<BaseDataItemNode, typename CollType::ValueType>, boost::python::dict>::type
toPyDict(const boost::shared_ptr<const CollType>& pPlanIndexedColl)
{
    // parse all plan indexed data
    boost::python::dict resDict;
    typedef BasePlanIndexedColl::PlanIndexedConstColl BaseCollType;
    const BaseCollType& baseColl = pPlanIndexedColl->getBaseColl();
    typename BaseCollType::const_iterator iter = baseColl.begin();
    while (iter != baseColl.end()) {
    
        // retrieve current informations
        const PlanIndex& curPlanIndex = iter->first;
        const ipUInt32& curZPlanIdx = curPlanIndex.getZPlanIdx();
        const ipUInt32& curCPlanIdx = curPlanIndex.getCPlanIdx();
        const ipUInt32& curTPlanIdx = curPlanIndex.getTPlanIdx();
        const SerializationObjectConstPtr& pCurBaseObject = iter->second;
        const DataItemNodeConstPtr& pCurObject = boost::static_pointer_cast<const BaseDataItemNode>(pCurBaseObject);

        // insert current data item into collection
        resDict[boost::python::make_tuple(curZPlanIdx, curCPlanIdx, curTPlanIdx)] = toPyDict(pCurObject);

        ++iter;
    }

    return resDict;
}

template <typename CollType>
typename boost::enable_if<boost::is_base_of<BaseDataItemNode, typename CollType::ValueType>, bool>::type
equal(const boost::shared_ptr<const CollType>& pPlanIndexedColl1,
      const boost::shared_ptr<const CollType>& pPlanIndexedColl2,
      const ipReal64& tolerance = NumericLimits<ipReal64>::sqrt_epsilon())
{
    // check collections size
    if (pPlanIndexedColl1->getNbPlans() != pPlanIndexedColl2->getNbPlans())
        return false;

    // parse all plan indexed data
    typedef BasePlanIndexedColl::PlanIndexedConstColl BaseCollType;
    const BaseCollType& baseColl1 = pPlanIndexedColl1->getBaseColl();
    const BaseCollType& baseColl2 = pPlanIndexedColl2->getBaseColl();
    typename BaseCollType::const_iterator iter1 = baseColl1.begin();
    typename BaseCollType::const_iterator iter2 = baseColl2.begin();
    while (iter1 != baseColl1.end()) {
    
        // retrieve current informations
        const PlanIndex& curPlanIndex1 = iter1->first;
        const ipUInt32& curZPlanIdx1 = curPlanIndex1.getZPlanIdx();
        const ipUInt32& curCPlanIdx1 = curPlanIndex1.getCPlanIdx();
        const ipUInt32& curTPlanIdx1 = curPlanIndex1.getTPlanIdx();
        const DataItemConstPtr& pCurObject1 = boost::static_pointer_cast<const BaseDataItemNode>(iter1->second);
        const PlanIndex& curPlanIndex2 = iter2->first;
        const ipUInt32& curZPlanIdx2 = curPlanIndex2.getZPlanIdx();
        const ipUInt32& curCPlanIdx2 = curPlanIndex2.getCPlanIdx();
        const ipUInt32& curTPlanIdx2 = curPlanIndex2.getTPlanIdx();
        const DataItemConstPtr& pCurObject2 = boost::static_pointer_cast<const BaseDataItemNode>(iter2->second);

        // check plan indexes validity
        if (curZPlanIdx1 != curZPlanIdx2)
            return false;
        if (curCPlanIdx1 != curCPlanIdx2)
            return false;
        if (curTPlanIdx1 != curTPlanIdx2)
            return false;

        // check data items equality
        if (equal(*pCurObject1, *pCurObject2, tolerance) == false)
            return false;

        ++iter1;
        ++iter2;
    }

    return true;
}

// function allowing to compare two plan indexed data item collections (with out tolerance)
template <typename CollType>
typename boost::enable_if<boost::is_base_of<BaseDataItemNode, typename CollType::ValueType>, bool>::type
equalWithoutTol(const boost::shared_ptr<const CollType>& pPlanIndexedColl1,
                const boost::shared_ptr<const CollType>& pPlanIndexedColl2)
{
    return equal(pPlanIndexedColl1, pPlanIndexedColl2, NumericLimits<ipReal64>::sqrt_epsilon());
}

//template <typename T>
//bool isPlanIndexed(const T& param)
//{
//    return false;
//}
//
//template<> bool
//isPlanIndexed<ipsdk::BasePlanIndexedColl>(const ipsdk::BasePlanIndexedColl& param)
//{
//    return true;
//}



} // end of namespace python
} // end of namespace ipsdk


//IPSDK_PYTHON_MODULE_WRAPPER_REGISTRATOR(PlanIndexedColl)
//boost::python::def("isPlanIndexed", ipsdk::python::isPlanIndexed<ipsdk::BasePlanIndexedColl>, "function allowing to check whether two data items are equal");
//}

#endif // __PYIPSDKBASE_PYTHONPLANINDEXEDCOLL_H__