param_pybind.hh

Go to the documentation of this file.

/*
 * param_pybind.hh
 *
 *  Created on: Feb 1, 2018
 *      Author: N. Oblath, L. Gladstone, B.H. LaRoque
 */

#ifndef PARAM_PYBIND_HH_
#define PARAM_PYBIND_HH_

#include <algorithm> //for std::replace on string

#include "param.hh"
#include "error.hh"

#include "pybind11/pybind11.h"
#include "pybind11/pytypes.h"


namespace scarab_pybind
{
    scarab::param_ptr_t to_param( const pybind11::object& an_object, bool hyphenate_keys=false )
    {
        using namespace pybind11;
        if( isinstance< none >( an_object ) )
        {
            return scarab::param_ptr_t( new scarab::param() );
        }
        else if( isinstance< bool_ >( an_object ) )
        {
            return scarab::param_ptr_t( new scarab::param_value( static_cast< const bool_& >(an_object) ) );
        }
        else if( isinstance< int_ >( an_object ) )
        {
            return scarab::param_ptr_t( new scarab::param_value( (int64_t)static_cast< const int_& >(an_object) ) );
        }
        else if( isinstance< float_ >( an_object ) )
        {
            return scarab::param_ptr_t( new scarab::param_value( (double)static_cast< const float_& >(an_object) ) );
        }
        else if( isinstance< str >( an_object ) )
        {
            return scarab::param_ptr_t( new scarab::param_value( static_cast< const str& >(an_object) ) );
        }
        else if( isinstance< list >( an_object ) )
        {
            scarab::param_ptr_t the_return( new scarab::param_array() );
            scarab::param_array& the_return_arr = the_return->as_array();
            for( auto an_item = an_object.begin(); an_item != an_object.end(); ++an_item )
            {
                the_return_arr.push_back( to_param( reinterpret_borrow< object >( *an_item ) ) );
            }
            return the_return;
        }
        else if( isinstance< dict >( an_object ) )
        {
            scarab::param_ptr_t the_return( new scarab::param_node() );
            scarab::param_node& the_return_arr = the_return->as_node();
            const dict& a_dict = static_cast< const dict& >( an_object );
            for( auto an_item = a_dict.begin(); an_item != a_dict.end(); ++an_item )
            {
                if( ! isinstance< str >(an_item->first) || ! isinstance< object >(an_item->second) )
                {
                    throw scarab::error() << "Cannot convert dict to param";
                }
                std::string new_key = pybind11::str(an_item->first);
                if ( hyphenate_keys )
                {
                    std::replace( new_key.begin(), new_key.end(), '_', '-' );
                }
                the_return_arr.add( new_key, to_param( static_cast< const object& >(an_item->second) ) );
            }
            return the_return;
        }
        throw scarab::error() << "Unknown python type cannot be converted to param";
    }

    pybind11::object to_python( const scarab::param& a_param, bool underscore_keys = false )
    {
        if (a_param.is_null())
        {
            return pybind11::none();
        }
        else if (a_param.is_value())
        {
            const scarab::param_value& this_value = a_param.as_value();
            pybind11::object to_return;
            if (this_value.is_bool()) to_return =  pybind11::cast(this_value.as_bool());
            else if (this_value.is_uint()) to_return = pybind11::cast(this_value.as_uint());
            else if (this_value.is_int()) to_return = pybind11::cast(this_value.as_int());
            else if (this_value.is_double()) to_return = pybind11::cast(this_value.as_double());
            else if (this_value.is_string()) to_return = pybind11::cast(this_value.as_string());
            return to_return;
        }
        else if (a_param.is_array())
        {
            const scarab::param_array& this_array = a_param.as_array();
            pybind11::list to_return;
            for (scarab::param_array_const_iterator an_item=this_array.begin(); an_item != this_array.end(); ++an_item)
            {
                to_return.append( to_python( *an_item ) );
            }
            return std::move(to_return);
        }
        else if (a_param.is_node())
        {
            const scarab::param_node& this_node = a_param.as_node();
            pybind11::dict to_return;
            for (scarab::param_node_const_iterator an_item=this_node.begin(); an_item != this_node.end(); ++an_item)
            {
                std::string new_key = an_item.name();
                if ( underscore_keys )
                {
                    std::replace( new_key.begin(), new_key.end(), '-', '_' );
                }
                to_return[ new_key.c_str() ] = to_python( *an_item );
            }
            return std::move(to_return);
        }
        throw scarab::error() << "Unknown param type cannot be converted to Python";
    }

    std::list< std::string > export_param( pybind11::module& mod )
    {
        std::list< std::string > all_members;

        all_members.push_back( "to_param" );
        mod.def( "to_param",
                &to_param,
                pybind11::arg( "object"),
                pybind11::arg( "hyphenate_keys" ) = false,
                "Convert native python types to a param structure." );

        // param
        all_members.push_back( "Param" );
        pybind11::class_< scarab::param >( mod, "Param", "param data structure base class and null object" )
            .def( pybind11::init< >() )
            .def( pybind11::init< scarab::param_value >() )

            .def( "__str__", &scarab::param::to_string )
            .def( "__call__", (scarab::param_value& (scarab::param::*)()) &scarab::param::operator(),
                    pybind11::return_value_policy::reference_internal )

            .def( "is_null", &scarab::param::is_null, "return whether the param object is an empty param type" )
            .def( "is_node", &scarab::param::is_node, "return whether the param object is a ParamNode" )
            .def( "is_array", &scarab::param::is_array, "return whether the param object is a ParamArray" )
            .def( "is_value", &scarab::param::is_value, "return whether the param object is a ParamValue" )

            .def( "as_array",
                    (scarab::param_array& (scarab::param::*)()) &scarab::param::as_array,
                    pybind11::return_value_policy::reference_internal,
                    "returns Param object as a ParamArray" )
            .def( "as_node",
                    (scarab::param_node& (scarab::param::*)()) &scarab::param::as_node,
                    pybind11::return_value_policy::reference_internal,
                    "returns Param object as ParamNode" )
            .def( "as_value",
                    (scarab::param_value& (scarab::param::*)()) &scarab::param::as_value,
                    pybind11::return_value_policy::reference_internal,
                    "returns Param object as ParamValue" )

            .def( "to_python",
                    &to_python,
                    pybind11::arg( "underscore_keys" ) = false,
                    "recursively converts param object to native python data structure" )

            //TODO: has_subset()

            //TODO: get_value() in its various types

            //TODO: merge()

            ;
        return all_members;
    }

} /* namespace scarab_pybind */
#endif /* PARAM_PYBIND_HH_ */