You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
735 lines
19 KiB
735 lines
19 KiB
// Copyright Daniel Wallin 2006. Use, modification and distribution is |
|
// subject to the Boost Software License, Version 1.0. (See accompanying |
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) |
|
|
|
#ifndef BOOST_PARAMETER_PYTHON_060209_HPP |
|
# define BOOST_PARAMETER_PYTHON_060209_HPP |
|
|
|
# include <boost/mpl/vector.hpp> |
|
# include <boost/mpl/fold.hpp> |
|
# include <boost/mpl/prior.hpp> |
|
# include <boost/mpl/shift_right.hpp> |
|
# include <boost/mpl/shift_left.hpp> |
|
# include <boost/mpl/bitand.hpp> |
|
# include <boost/mpl/pair.hpp> |
|
# include <boost/mpl/size.hpp> |
|
# include <boost/mpl/push_back.hpp> |
|
# include <boost/mpl/or.hpp> |
|
# include <boost/mpl/count_if.hpp> |
|
# include <boost/mpl/transform.hpp> |
|
# include <boost/mpl/front.hpp> |
|
# include <boost/mpl/iterator_range.hpp> |
|
# include <boost/mpl/next.hpp> |
|
# include <boost/mpl/begin_end.hpp> |
|
# include <boost/mpl/not.hpp> |
|
# include <boost/mpl/empty.hpp> |
|
# include <boost/python/def.hpp> |
|
# include <boost/python/make_constructor.hpp> |
|
# include <boost/python/init.hpp> |
|
# include <boost/python/to_python_converter.hpp> |
|
# include <boost/parameter/aux_/maybe.hpp> |
|
# include <boost/parameter/aux_/python/invoker.hpp> |
|
|
|
namespace boost { namespace parameter { namespace python |
|
{ |
|
namespace python_ = boost::python; |
|
}}} |
|
|
|
namespace boost { namespace parameter { namespace python { namespace aux |
|
{ |
|
|
|
inline PyObject* unspecified_type() |
|
{ |
|
static PyTypeObject unspecified = { |
|
PyObject_HEAD_INIT(NULL) |
|
0, /* ob_size */ |
|
"Boost.Parameter.Unspecified", /* tp_name */ |
|
PyType_Type.tp_basicsize, /* tp_basicsize */ |
|
0, /* tp_itemsize */ |
|
0, /* tp_dealloc */ |
|
0, /* tp_print */ |
|
0, /* tp_getattr */ |
|
0, /* tp_setattr */ |
|
0, /* tp_compare */ |
|
0, /* tp_repr */ |
|
0, /* tp_as_number */ |
|
0, /* tp_as_sequence */ |
|
0, /* tp_as_mapping */ |
|
0, /* tp_hash */ |
|
0, /* tp_call */ |
|
0, /* tp_str */ |
|
0, /* tp_getattro */ |
|
0, /* tp_setattro */ |
|
0, /* tp_as_buffer */ |
|
Py_TPFLAGS_DEFAULT, /* tp_flags */ |
|
0, /* tp_doc */ |
|
}; |
|
|
|
if (unspecified.ob_type == 0) |
|
{ |
|
unspecified.ob_type = &PyType_Type; |
|
PyType_Ready(&unspecified); |
|
} |
|
|
|
return (PyObject*)&unspecified; |
|
} |
|
|
|
struct empty_tag {}; |
|
|
|
struct empty_tag_to_python |
|
{ |
|
static PyObject* convert(empty_tag) |
|
{ |
|
return python_::xincref(unspecified_type()); |
|
} |
|
}; |
|
|
|
}}}} // namespace boost::parameter::python::aux |
|
|
|
namespace boost { namespace python |
|
{ |
|
|
|
// Converts a Python value to a maybe<T> |
|
template <class T> |
|
struct arg_from_python<parameter::aux::maybe<T> > |
|
: arg_from_python<T> |
|
{ |
|
arg_from_python(PyObject* p) |
|
: arg_from_python<T>(p) |
|
, empty(parameter::python::aux::unspecified_type() == p) |
|
{} |
|
|
|
bool convertible() const |
|
{ |
|
return empty || arg_from_python<T>::convertible(); |
|
} |
|
|
|
parameter::aux::maybe<T> operator()() |
|
{ |
|
if (empty) |
|
{ |
|
return parameter::aux::maybe<T>(); |
|
} |
|
else |
|
{ |
|
return parameter::aux::maybe<T>( |
|
arg_from_python<T>::operator()() |
|
); |
|
} |
|
} |
|
|
|
bool empty; |
|
}; |
|
|
|
}} // namespace boost::python |
|
|
|
namespace boost { namespace parameter { namespace python { |
|
|
|
namespace aux |
|
{ |
|
|
|
template <class K> |
|
struct is_optional |
|
: mpl::not_< |
|
mpl::or_<typename K::required, typename K::optimized_default> |
|
> |
|
{}; |
|
|
|
template <class K, class Required, class Optimized, class T> |
|
struct arg_spec |
|
{ |
|
typedef K keyword; |
|
typedef Required required; |
|
typedef T type; |
|
typedef Optimized optimized_default; |
|
}; |
|
|
|
template <class K, class T, class Optimized = mpl::false_> |
|
struct make_arg_spec_impl |
|
{ |
|
typedef arg_spec< |
|
typename K::first, typename K::second, Optimized, T |
|
> type; |
|
}; |
|
|
|
template <class K, class T> |
|
struct make_arg_spec_impl<K, T, typename K::third> |
|
{ |
|
typedef arg_spec< |
|
typename K::first, typename K::second, typename K::third, T |
|
> type; |
|
}; |
|
|
|
template <class K, class T> |
|
struct make_arg_spec |
|
: make_arg_spec_impl<K, T> |
|
{ |
|
}; |
|
|
|
template <class Spec, class State> |
|
struct combinations_op |
|
{ |
|
typedef typename State::second bits; |
|
typedef typename State::first result0; |
|
|
|
typedef typename mpl::if_< |
|
mpl::or_< |
|
typename Spec::required |
|
, typename Spec::optimized_default |
|
, mpl::bitand_<bits, mpl::long_<1> > |
|
> |
|
, typename mpl::push_back<result0, Spec>::type |
|
, result0 |
|
>::type result; |
|
|
|
typedef typename mpl::if_< |
|
mpl::or_< |
|
typename Spec::required |
|
, typename Spec::optimized_default |
|
> |
|
, bits |
|
, typename mpl::shift_right<bits, mpl::long_<1> >::type |
|
>::type next_bits; |
|
|
|
typedef mpl::pair< |
|
result |
|
, next_bits |
|
> type; |
|
}; |
|
|
|
// Used as start value in the recursive arg() composition below. |
|
struct no_keywords |
|
{ |
|
template <class T> |
|
T const& operator,(T const& x) const |
|
{ |
|
return x; |
|
} |
|
}; |
|
|
|
template <class Def, class F, class Iter, class End, class Keywords> |
|
void def_combination_aux0( |
|
Def def, F f, Iter, End, Keywords const& keywords, mpl::false_) |
|
{ |
|
typedef typename mpl::deref<Iter>::type spec; |
|
typedef typename spec::keyword kw; |
|
|
|
def_combination_aux( |
|
def, f, typename mpl::next<Iter>::type(), End() |
|
, ( |
|
keywords, boost::python::arg(kw::keyword_name()) |
|
) |
|
); |
|
} |
|
|
|
template <class Def, class F, class Iter, class End, class Keywords> |
|
void def_combination_aux0( |
|
Def def, F f, Iter, End, Keywords const& keywords, mpl::true_) |
|
{ |
|
typedef typename mpl::deref<Iter>::type spec; |
|
typedef typename spec::keyword kw; |
|
|
|
def_combination_aux( |
|
def, f, typename mpl::next<Iter>::type(), End() |
|
, ( |
|
keywords, boost::python::arg(kw::keyword_name()) = empty_tag() |
|
) |
|
); |
|
} |
|
|
|
inline void initialize_converter() |
|
{ |
|
static python_::to_python_converter<empty_tag, empty_tag_to_python> x; |
|
} |
|
|
|
template <class Def, class F, class Iter, class End, class Keywords> |
|
void def_combination_aux( |
|
Def def, F f, Iter, End, Keywords const& keywords) |
|
{ |
|
typedef typename mpl::deref<Iter>::type spec; |
|
|
|
typedef typename mpl::and_< |
|
typename spec::optimized_default |
|
, mpl::not_<typename spec::required> |
|
>::type optimized_default; |
|
|
|
def_combination_aux0( |
|
def, f, Iter(), End(), keywords, optimized_default() |
|
); |
|
} |
|
|
|
template <class Def, class F, class End, class Keywords> |
|
void def_combination_aux( |
|
Def def, F f, End, End, Keywords const& keywords) |
|
{ |
|
def(f, keywords); |
|
} |
|
|
|
template <class Def, class F, class End> |
|
void def_combination_aux( |
|
Def def, F f, End, End, no_keywords const&) |
|
{ |
|
def(f); |
|
} |
|
|
|
template < |
|
class Def, class Specs, class Bits, class Invoker |
|
> |
|
void def_combination( |
|
Def def, Specs*, Bits, Invoker*) |
|
{ |
|
typedef typename mpl::fold< |
|
Specs |
|
, mpl::pair<mpl::vector0<>, Bits> |
|
, combinations_op<mpl::_2, mpl::_1> |
|
>::type combination0; |
|
|
|
typedef typename combination0::first combination; |
|
|
|
typedef typename mpl::apply_wrap1< |
|
Invoker, combination |
|
>::type invoker; |
|
|
|
def_combination_aux( |
|
def |
|
, &invoker::execute |
|
, typename mpl::begin<combination>::type() |
|
, typename mpl::end<combination>::type() |
|
, no_keywords() |
|
); |
|
} |
|
|
|
template < |
|
class Def, class Specs, class Bits, class End, class Invoker |
|
> |
|
void def_combinations( |
|
Def def, Specs*, Bits, End, Invoker*) |
|
{ |
|
initialize_converter(); |
|
|
|
def_combination(def, (Specs*)0, Bits(), (Invoker*)0); |
|
|
|
def_combinations( |
|
def |
|
, (Specs*)0 |
|
, mpl::long_<Bits::value + 1>() |
|
, End() |
|
, (Invoker*)0 |
|
); |
|
} |
|
|
|
template < |
|
class Def, class Specs, class End, class Invoker |
|
> |
|
void def_combinations( |
|
Def, Specs*, End, End, Invoker*) |
|
{} |
|
|
|
struct not_specified {}; |
|
|
|
template <class CallPolicies> |
|
struct call_policies_as_options |
|
{ |
|
call_policies_as_options(CallPolicies const& call_policies) |
|
: call_policies(call_policies) |
|
{} |
|
|
|
CallPolicies const& policies() const |
|
{ |
|
return call_policies; |
|
} |
|
|
|
char const* doc() const |
|
{ |
|
return 0; |
|
} |
|
|
|
CallPolicies call_policies; |
|
}; |
|
|
|
template <class Class, class Options = not_specified> |
|
struct def_class |
|
{ |
|
def_class(Class& cl, char const* name, Options options = Options()) |
|
: cl(cl) |
|
, name(name) |
|
, options(options) |
|
{} |
|
|
|
template <class F> |
|
void def(F f, not_specified const*) const |
|
{ |
|
cl.def(name, f); |
|
} |
|
|
|
template <class F> |
|
void def(F f, void const*) const |
|
{ |
|
cl.def(name, f, options.doc(), options.policies()); |
|
} |
|
|
|
template <class F> |
|
void operator()(F f) const |
|
{ |
|
this->def(f, &options); |
|
} |
|
|
|
template <class F, class Keywords> |
|
void def(F f, Keywords const& keywords, not_specified const*) const |
|
{ |
|
cl.def(name, f, keywords); |
|
} |
|
|
|
template <class F, class Keywords> |
|
void def(F f, Keywords const& keywords, void const*) const |
|
{ |
|
cl.def(name, f, keywords, options.doc(), options.policies()); |
|
} |
|
|
|
template <class F, class Keywords> |
|
void operator()(F f, Keywords const& keywords) const |
|
{ |
|
this->def(f, keywords, &options); |
|
} |
|
|
|
Class& cl; |
|
char const* name; |
|
Options options; |
|
}; |
|
|
|
template <class Class, class CallPolicies = boost::python::default_call_policies> |
|
struct def_init |
|
{ |
|
def_init(Class& cl, CallPolicies call_policies = CallPolicies()) |
|
: cl(cl) |
|
, call_policies(call_policies) |
|
{} |
|
|
|
template <class F> |
|
void operator()(F f) const |
|
{ |
|
cl.def( |
|
"__init__" |
|
, boost::python::make_constructor(f, call_policies) |
|
); |
|
} |
|
|
|
template <class F, class Keywords> |
|
void operator()(F f, Keywords const& keywords) const |
|
{ |
|
cl.def( |
|
"__init__" |
|
, boost::python::make_constructor(f, call_policies, keywords) |
|
); |
|
} |
|
|
|
Class& cl; |
|
CallPolicies call_policies; |
|
}; |
|
|
|
struct def_function |
|
{ |
|
def_function(char const* name) |
|
: name(name) |
|
{} |
|
|
|
template <class F> |
|
void operator()(F f) const |
|
{ |
|
boost::python::def(name, f); |
|
} |
|
|
|
template <class F, class Keywords> |
|
void operator()(F f, Keywords const& keywords) const |
|
{ |
|
boost::python::def(name, f, keywords); |
|
} |
|
|
|
char const* name; |
|
}; |
|
|
|
} // namespace aux |
|
|
|
template <class M, class Signature> |
|
void def(char const* name, Signature) |
|
{ |
|
typedef mpl::iterator_range< |
|
typename mpl::next< |
|
typename mpl::begin<Signature>::type |
|
>::type |
|
, typename mpl::end<Signature>::type |
|
> arg_types; |
|
|
|
typedef typename mpl::transform< |
|
typename M::keywords |
|
, arg_types |
|
, aux::make_arg_spec<mpl::_1, mpl::_2> |
|
, mpl::back_inserter<mpl::vector0<> > |
|
>::type arg_specs; |
|
|
|
typedef typename mpl::count_if< |
|
arg_specs |
|
, aux::is_optional<mpl::_1> |
|
>::type optional_arity; |
|
|
|
typedef typename mpl::front<Signature>::type result_type; |
|
typedef typename mpl::shift_left<mpl::long_<1>, optional_arity>::type upper; |
|
|
|
aux::def_combinations( |
|
aux::def_function(name) |
|
, (arg_specs*)0 |
|
, mpl::long_<0>() |
|
, mpl::long_<upper::value>() |
|
, (aux::make_invoker<M, result_type>*)0 |
|
); |
|
} |
|
|
|
template <class M, class Class, class Signature> |
|
void def(Class& cl, char const* name, Signature) |
|
{ |
|
typedef mpl::iterator_range< |
|
typename mpl::next< |
|
typename mpl::begin<Signature>::type |
|
>::type |
|
, typename mpl::end<Signature>::type |
|
> arg_types; |
|
|
|
typedef typename mpl::transform< |
|
typename M::keywords |
|
, arg_types |
|
, aux::make_arg_spec<mpl::_1, mpl::_2> |
|
, mpl::back_inserter<mpl::vector0<> > |
|
>::type arg_specs; |
|
|
|
typedef typename mpl::count_if< |
|
arg_specs |
|
, aux::is_optional<mpl::_1> |
|
>::type optional_arity; |
|
|
|
typedef typename mpl::front<Signature>::type result_type; |
|
typedef typename mpl::shift_left<mpl::long_<1>, optional_arity>::type upper; |
|
|
|
aux::def_combinations( |
|
aux::def_class<Class>(cl, name) |
|
, (arg_specs*)0 |
|
, mpl::long_<0>() |
|
, mpl::long_<upper::value>() |
|
, (aux::make_invoker<M, result_type>*)0 |
|
); |
|
} |
|
|
|
namespace aux |
|
{ |
|
|
|
template <class K> |
|
struct keyword |
|
{ |
|
typedef K type; |
|
}; |
|
|
|
template <class K> |
|
struct keyword<K*> |
|
{ |
|
typedef K type; |
|
}; |
|
|
|
template <class K> |
|
struct keyword<K**> |
|
{ |
|
typedef K type; |
|
}; |
|
|
|
template <class K> |
|
struct required |
|
{ |
|
typedef mpl::true_ type; |
|
}; |
|
|
|
template <class K> |
|
struct required<K*> |
|
{ |
|
typedef mpl::false_ type; |
|
}; |
|
|
|
template <class K> |
|
struct optimized |
|
{ |
|
typedef mpl::true_ type; |
|
}; |
|
|
|
template <class K> |
|
struct optimized<K**> |
|
{ |
|
typedef mpl::false_ type; |
|
}; |
|
|
|
template <class T> |
|
struct make_kw_spec; |
|
|
|
template <class K, class T> |
|
struct make_kw_spec<K(T)> |
|
{ |
|
typedef arg_spec< |
|
typename keyword<K>::type |
|
, typename required<K>::type |
|
, typename optimized<K>::type |
|
, T |
|
> type; |
|
}; |
|
|
|
} // namespace aux |
|
|
|
template <class ParameterSpecs, class CallPolicies = boost::python::default_call_policies> |
|
struct init |
|
: boost::python::def_visitor<init<ParameterSpecs, CallPolicies> > |
|
{ |
|
init(CallPolicies call_policies = CallPolicies()) |
|
: call_policies(call_policies) |
|
{} |
|
|
|
template <class CallPolicies1> |
|
init<ParameterSpecs, CallPolicies1> |
|
operator[](CallPolicies1 const& call_policies) const |
|
{ |
|
return init<ParameterSpecs, CallPolicies1>(call_policies); |
|
} |
|
|
|
template <class Class> |
|
void visit_aux(Class& cl, mpl::true_) const |
|
{ |
|
cl.def(boost::python::init<>()[call_policies]); |
|
} |
|
|
|
template <class Class> |
|
void visit_aux(Class& cl, mpl::false_) const |
|
{ |
|
typedef typename mpl::transform< |
|
ParameterSpecs |
|
, aux::make_kw_spec<mpl::_> |
|
, mpl::back_inserter<mpl::vector0<> > |
|
>::type arg_specs; |
|
|
|
typedef typename mpl::count_if< |
|
arg_specs |
|
, aux::is_optional<mpl::_> |
|
>::type optional_arity; |
|
|
|
typedef typename mpl::shift_left<mpl::long_<1>, optional_arity>::type upper; |
|
|
|
aux::def_combinations( |
|
aux::def_init<Class, CallPolicies>(cl, call_policies) |
|
, (arg_specs*)0 |
|
, mpl::long_<0>() |
|
, mpl::long_<upper::value>() |
|
, (aux::make_init_invoker<typename Class::wrapped_type>*)0 |
|
); |
|
} |
|
|
|
template <class Class> |
|
void visit(Class& cl) const |
|
{ |
|
visit_aux(cl, mpl::empty<ParameterSpecs>()); |
|
} |
|
|
|
CallPolicies call_policies; |
|
}; |
|
|
|
template <class ParameterSpecs, class CallPolicies = boost::python::default_call_policies> |
|
struct call |
|
: boost::python::def_visitor<call<ParameterSpecs, CallPolicies> > |
|
{ |
|
call(CallPolicies const& call_policies = CallPolicies()) |
|
: call_policies(call_policies) |
|
{} |
|
|
|
template <class CallPolicies1> |
|
call<ParameterSpecs, CallPolicies1> |
|
operator[](CallPolicies1 const& call_policies) const |
|
{ |
|
return call<ParameterSpecs, CallPolicies1>(call_policies); |
|
} |
|
|
|
template <class Class> |
|
void visit(Class& cl) const |
|
{ |
|
typedef mpl::iterator_range< |
|
typename mpl::next< |
|
typename mpl::begin<ParameterSpecs>::type |
|
>::type |
|
, typename mpl::end<ParameterSpecs>::type |
|
> arg_types; |
|
|
|
typedef typename mpl::front<ParameterSpecs>::type result_type; |
|
|
|
typedef typename mpl::transform< |
|
arg_types |
|
, aux::make_kw_spec<mpl::_> |
|
, mpl::back_inserter<mpl::vector0<> > |
|
>::type arg_specs; |
|
|
|
typedef typename mpl::count_if< |
|
arg_specs |
|
, aux::is_optional<mpl::_> |
|
>::type optional_arity; |
|
|
|
typedef typename mpl::shift_left<mpl::long_<1>, optional_arity>::type upper; |
|
|
|
typedef aux::call_policies_as_options<CallPolicies> options; |
|
|
|
aux::def_combinations( |
|
aux::def_class<Class, options>(cl, "__call__", options(call_policies)) |
|
, (arg_specs*)0 |
|
, mpl::long_<0>() |
|
, mpl::long_<upper::value>() |
|
, (aux::make_call_invoker<typename Class::wrapped_type, result_type>*)0 |
|
); |
|
} |
|
|
|
CallPolicies call_policies; |
|
}; |
|
|
|
template <class Fwd, class ParameterSpecs> |
|
struct function |
|
: boost::python::def_visitor<function<Fwd, ParameterSpecs> > |
|
{ |
|
template <class Class, class Options> |
|
void visit(Class& cl, char const* name, Options const& options) const |
|
{ |
|
typedef mpl::iterator_range< |
|
typename mpl::next< |
|
typename mpl::begin<ParameterSpecs>::type |
|
>::type |
|
, typename mpl::end<ParameterSpecs>::type |
|
> arg_types; |
|
|
|
typedef typename mpl::front<ParameterSpecs>::type result_type; |
|
|
|
typedef typename mpl::transform< |
|
arg_types |
|
, aux::make_kw_spec<mpl::_> |
|
, mpl::back_inserter<mpl::vector0<> > |
|
>::type arg_specs; |
|
|
|
typedef typename mpl::count_if< |
|
arg_specs |
|
, aux::is_optional<mpl::_> |
|
>::type optional_arity; |
|
|
|
typedef typename mpl::shift_left<mpl::long_<1>, optional_arity>::type upper; |
|
|
|
aux::def_combinations( |
|
aux::def_class<Class, Options>(cl, name, options) |
|
, (arg_specs*)0 |
|
, mpl::long_<0>() |
|
, mpl::long_<upper::value>() |
|
, (aux::make_member_invoker< |
|
Fwd, result_type, typename Class::wrapped_type |
|
>*)0 |
|
); |
|
} |
|
}; |
|
|
|
}}} // namespace boost::parameter::python |
|
|
|
#endif // BOOST_PARAMETER_PYTHON_060209_HPP |
|
|
|
|