PythonDataItemUtils.h

Go to the documentation of this file.

// PythonDataItemUtils.h:
// ----------------------
//

#ifndef __PYIPSDKBASE_PYTHONDATAITEMUTILS_H__
#define __PYIPSDKBASE_PYTHONDATAITEMUTILS_H__

#include <Python/PyIPSDKBase/PyIPSDKBaseExports.h>
#include <Python/PyIPSDKBase/PythonStdVectorUtils.h>
#include <IPSDKBaseData/DataItem/DataItemTypes.h>
#include <IPSDKUtil/BaseTypes.h>
#include <boost/python/copy_const_reference.hpp>
#include <algorithm>
#include <iostream>

namespace ipsdk {
namespace python {


PYIPSDKBASE_API std::string
toString( const BaseDataItem& dataItem);

template <ipsdk::ipUInt32 g_nodeIdx, typename DataItemType, typename Enable = void>
struct DataItemNodeRegistrator;

template <ipsdk::ipUInt32 g_nodeIdx, typename DataItemType>
struct DataItemNodeRegistrator<g_nodeIdx, DataItemType, typename boost::enable_if_c<g_nodeIdx == DataItemType::g_nbChildNodes>::type>
{
    template <typename PyDataItem>
    static void registerNode(PyDataItem& pyDataItem)
    {
        
    }
};

template <ipsdk::ipUInt32 g_nodeIdx, typename DataItemType>
struct DataItemNodeRegistrator<g_nodeIdx, DataItemType, typename boost::enable_if_c<g_nodeIdx < DataItemType::g_nbChildNodes>::type>
{
    template <typename PyDataItem>
    static void registerNode(PyDataItem& pyDataItem)
    {
        typedef typename DataItemType::template IdxToChildNode<g_nodeIdx>::ChildNodeType ChildNode;

        std::string nodeName = DataItemType::template getNodeNameStr<ChildNode>();
        nodeName[0] = std::tolower(nodeName[0]);
        registerNode<PyDataItem, ChildNode>(pyDataItem,
                                            nodeName,
                                            DataItemType::template getNodeToolTipStr<ChildNode>());
        DataItemNodeRegistrator<g_nodeIdx+1, DataItemType>::registerNode(pyDataItem);
    }

    template <typename PyDataItem, typename ChildNode>
    static typename boost::enable_if_c<((ChildNode::NodeType::g_itemType == ipsdk::eDataItemType::eDIT_Leaf) &&
                                        (ChildNode::NodeType::g_dataItemValueType != ipsdk::eDataItemValueType::eDIVT_Enum))>::type
        registerNode(PyDataItem& pyDataItem,
                     const std::string& nodeName,
                     const std::string& nodeToolTip)
    {
        pyDataItem.add_property(nodeName.c_str(),
                                boost::python::make_function(&DataItemType::template getValue<ChildNode>,
                                                             boost::python::return_value_policy<boost::python::copy_const_reference>()),
                                &DataItemType::template setValue<ChildNode>,
                                nodeToolTip.c_str());
    }

    template <typename PyDataItem, typename ChildNode>
    static typename boost::enable_if_c<((ChildNode::NodeType::g_itemType == ipsdk::eDataItemType::eDIT_Leaf) &&
                                        (ChildNode::NodeType::g_dataItemValueType == ipsdk::eDataItemValueType::eDIVT_Enum))>::type
        registerNode(PyDataItem& pyDataItem,
                     const std::string& nodeName,
                     const std::string& nodeToolTip)
    {
        pyDataItem.add_property(nodeName.c_str(),
                                &DataItemType::template getValue<ChildNode>,
                                &DataItemType::template setValue<ChildNode>,
                                nodeToolTip.c_str());
    }

    template <typename PyDataItem, typename ChildNode>
    static typename boost::enable_if_c<ChildNode::NodeType::g_itemType == ipsdk::eDataItemType::eDIT_Node>::type
        registerNode(PyDataItem& pyDataItem,
                     const std::string& nodeName,
                     const std::string& nodeToolTip)
    {
        typedef const typename DataItemType::template ChildNodeInfo<ChildNode>::NodeType& (DataItemType::*ConstGetter) () const;
        typedef typename DataItemType::template ChildNodeInfo<ChildNode>::NodeType& (DataItemType::*MutableGetter) ();
        pyDataItem.add_property(nodeName.c_str(),
                                boost::python::make_function(static_cast<ConstGetter>(&DataItemType::template getNode<ChildNode>),
                                                             boost::python::return_internal_reference<>()),
                                boost::python::make_function(static_cast<MutableGetter>(&DataItemType::template getNode<ChildNode>),
                                                             boost::python::return_internal_reference<>()),
                                nodeToolTip.c_str());
    }

    template <typename PyDataItem, typename ChildNode>
    static typename boost::enable_if_c<ChildNode::NodeType::g_itemType == ipsdk::eDataItemType::eDIT_LeafColl>::type
        registerNode(PyDataItem& pyDataItem,
                     const std::string& nodeName,
                     const std::string& nodeToolTip)
    {
        typedef const typename DataItemType::template ChildNodeInfo<ChildNode>::CollType& (DataItemType::*ConstGetter) () const;
        typedef typename DataItemType::template ChildNodeInfo<ChildNode>::CollType& (DataItemType::*MutableGetter) ();
        pyDataItem.add_property(nodeName.c_str(),
                                boost::python::make_function(static_cast<ConstGetter>(&DataItemType::template getLeafColl<ChildNode>),
                                                             boost::python::return_internal_reference<>()),
                                boost::python::make_function(static_cast<MutableGetter>(&DataItemType::template getLeafColl<ChildNode>),
                                                             boost::python::return_internal_reference<>()),
                                nodeToolTip.c_str());
    }

    template <typename PyDataItem, typename ChildNode>
    static typename boost::enable_if_c<ChildNode::NodeType::g_itemType == ipsdk::eDataItemType::eDIT_NodeColl>::type
        registerNode(PyDataItem& pyDataItem,
                     const std::string& nodeName,
                     const std::string& nodeToolTip)
    {
        typedef typename DataItemType::template ChildNodeInfo<ChildNode>::CollType CollType;
        export_vector_no_str_no_proxy<CollType>(nodeName.c_str());
        typedef const CollType& (DataItemType::*ConstGetter) () const;
        typedef CollType& (DataItemType::*MutableGetter) ();
        pyDataItem.add_property(nodeName.c_str(),
                                boost::python::make_function(static_cast<ConstGetter>(&DataItemType::template getNodeColl<ChildNode>),
                                                             boost::python::return_internal_reference<>()),
                                boost::python::make_function(static_cast<MutableGetter>(&DataItemType::template getNodeColl<ChildNode>),
                                                             boost::python::return_internal_reference<>()),
                                nodeToolTip.c_str());
    }

};


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

#endif // __PYIPSDKBASE_PYTHONDATAITEMUTILS_H__