MySources/boost_graph/boost/python/init.hpp

400 lines
11 KiB
C++

///////////////////////////////////////////////////////////////////////////////
//
// Copyright David Abrahams 2002, Joel de Guzman, 2002.
// Distributed under 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 INIT_JDG20020820_HPP
#define INIT_JDG20020820_HPP
# include <boost/python/detail/prefix.hpp>
#include <boost/python/detail/type_list.hpp>
#include <boost/python/args_fwd.hpp>
#include <boost/python/detail/make_keyword_range_fn.hpp>
#include <boost/python/def_visitor.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/size.hpp>
#include <boost/mpl/iterator_range.hpp>
#include <boost/mpl/empty.hpp>
#include <boost/mpl/begin_end.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/prior.hpp>
#include <boost/mpl/joint_view.hpp>
#include <boost/mpl/back.hpp>
#include <boost/python/detail/type_traits.hpp>
#include <boost/preprocessor/enum_params_with_a_default.hpp>
#include <boost/preprocessor/enum_params.hpp>
#include <utility>
///////////////////////////////////////////////////////////////////////////////
#define BOOST_PYTHON_OVERLOAD_TYPES_WITH_DEFAULT \
BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT( \
BOOST_PYTHON_MAX_ARITY, \
class T, \
mpl::void_) \
#define BOOST_PYTHON_OVERLOAD_TYPES \
BOOST_PP_ENUM_PARAMS_Z(1, \
BOOST_PYTHON_MAX_ARITY, \
class T) \
#define BOOST_PYTHON_OVERLOAD_ARGS \
BOOST_PP_ENUM_PARAMS_Z(1, \
BOOST_PYTHON_MAX_ARITY, \
T) \
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace python {
template <BOOST_PYTHON_OVERLOAD_TYPES_WITH_DEFAULT>
class init; // forward declaration
template <BOOST_PYTHON_OVERLOAD_TYPES_WITH_DEFAULT>
struct optional; // forward declaration
namespace detail
{
namespace error
{
template <int keywords, int init_args>
struct more_keywords_than_init_arguments
{
typedef char too_many_keywords[init_args - keywords >= 0 ? 1 : -1] BOOST_ATTRIBUTE_UNUSED;
};
}
// is_optional<T>::value
//
// This metaprogram checks if T is an optional
//
template <class T>
struct is_optional
: mpl::false_
{};
template <BOOST_PYTHON_OVERLOAD_TYPES>
struct is_optional<optional<BOOST_PYTHON_OVERLOAD_ARGS> >
: mpl::true_
{};
template <int NDefaults>
struct define_class_init_helper;
} // namespace detail
template <class DerivedT>
struct init_base : def_visitor<DerivedT>
{
init_base(char const* doc_, detail::keyword_range const& keywords_)
: m_doc(doc_), m_keywords(keywords_)
{}
init_base(char const* doc_)
: m_doc(doc_)
{}
DerivedT const& derived() const
{
return *static_cast<DerivedT const*>(this);
}
char const* doc_string() const
{
return m_doc;
}
detail::keyword_range const& keywords() const
{
return m_keywords;
}
static default_call_policies call_policies()
{
return default_call_policies();
}
private:
// visit
//
// Defines a set of n_defaults + 1 constructors for its
// class_<...> argument. Each constructor after the first has
// one less argument to its right. Example:
//
// init<int, optional<char, long, double> >
//
// Defines:
//
// __init__(int, char, long, double)
// __init__(int, char, long)
// __init__(int, char)
// __init__(int)
template <class classT>
void visit(classT& cl) const
{
typedef typename DerivedT::signature signature;
typedef typename DerivedT::n_arguments n_arguments;
typedef typename DerivedT::n_defaults n_defaults;
detail::define_class_init_helper<n_defaults::value>::apply(
cl
, derived().call_policies()
, signature()
, n_arguments()
, derived().doc_string()
, derived().keywords());
}
friend class python::def_visitor_access;
private: // data members
char const* m_doc;
detail::keyword_range m_keywords;
};
template <class CallPoliciesT, class InitT>
class init_with_call_policies
: public init_base<init_with_call_policies<CallPoliciesT, InitT> >
{
typedef init_base<init_with_call_policies<CallPoliciesT, InitT> > base;
public:
typedef typename InitT::n_arguments n_arguments;
typedef typename InitT::n_defaults n_defaults;
typedef typename InitT::signature signature;
init_with_call_policies(
CallPoliciesT const& policies_
, char const* doc_
, detail::keyword_range const& keywords
)
: base(doc_, keywords)
, m_policies(policies_)
{}
CallPoliciesT const& call_policies() const
{
return this->m_policies;
}
private: // data members
CallPoliciesT m_policies;
};
//
// drop1<S> is the initial length(S) elements of S
//
namespace detail
{
template <class S>
struct drop1
: mpl::iterator_range<
typename mpl::begin<S>::type
, typename mpl::prior<
typename mpl::end<S>::type
>::type
>
{};
}
template <BOOST_PYTHON_OVERLOAD_TYPES>
class init : public init_base<init<BOOST_PYTHON_OVERLOAD_ARGS> >
{
typedef init_base<init<BOOST_PYTHON_OVERLOAD_ARGS> > base;
public:
typedef init<BOOST_PYTHON_OVERLOAD_ARGS> self_t;
init(char const* doc_ = 0)
: base(doc_)
{
}
template <std::size_t N>
init(char const* doc_, detail::keywords<N> const& kw)
: base(doc_, kw.range())
{
typedef typename detail::error::more_keywords_than_init_arguments<
N, n_arguments::value + 1
>::too_many_keywords assertion BOOST_ATTRIBUTE_UNUSED;
}
template <std::size_t N>
init(detail::keywords<N> const& kw, char const* doc_ = 0)
: base(doc_, kw.range())
{
typedef typename detail::error::more_keywords_than_init_arguments<
N, n_arguments::value + 1
>::too_many_keywords assertion BOOST_ATTRIBUTE_UNUSED;
}
template <class CallPoliciesT>
init_with_call_policies<CallPoliciesT, self_t>
operator[](CallPoliciesT const& policies) const
{
return init_with_call_policies<CallPoliciesT, self_t>(
policies, this->doc_string(), this->keywords());
}
typedef detail::type_list<BOOST_PYTHON_OVERLOAD_ARGS> signature_;
typedef detail::is_optional<
typename mpl::eval_if<
mpl::empty<signature_>
, mpl::false_
, mpl::back<signature_>
>::type
> back_is_optional;
typedef typename mpl::eval_if<
back_is_optional
, mpl::back<signature_>
, mpl::vector0<>
>::type optional_args;
typedef typename mpl::eval_if<
back_is_optional
, mpl::if_<
mpl::empty<optional_args>
, detail::drop1<signature_>
, mpl::joint_view<
detail::drop1<signature_>
, optional_args
>
>
, signature_
>::type signature;
// TODO: static assert to make sure there are no other optional elements
// Count the number of default args
typedef mpl::size<optional_args> n_defaults;
typedef mpl::size<signature> n_arguments;
};
///////////////////////////////////////////////////////////////////////////////
//
// optional
//
// optional<T0...TN>::type returns a typelist.
//
///////////////////////////////////////////////////////////////////////////////
template <BOOST_PYTHON_OVERLOAD_TYPES>
struct optional
: detail::type_list<BOOST_PYTHON_OVERLOAD_ARGS>
{
};
namespace detail
{
template <class ClassT, class CallPoliciesT, class Signature, class NArgs>
inline void def_init_aux(
ClassT& cl
, Signature const&
, NArgs
, CallPoliciesT const& policies
, char const* doc
, detail::keyword_range const& keywords_
)
{
cl.def(
"__init__"
, detail::make_keyword_range_constructor<Signature,NArgs>(
policies
, keywords_
, (typename ClassT::metadata::holder*)0
)
, doc
);
}
///////////////////////////////////////////////////////////////////////////////
//
// define_class_init_helper<N>::apply
//
// General case
//
// Accepts a class_ and an arguments list. Defines a constructor
// for the class given the arguments and recursively calls
// define_class_init_helper<N-1>::apply with one fewer argument (the
// rightmost argument is shaved off)
//
///////////////////////////////////////////////////////////////////////////////
template <int NDefaults>
struct define_class_init_helper
{
template <class ClassT, class CallPoliciesT, class Signature, class NArgs>
static void apply(
ClassT& cl
, CallPoliciesT const& policies
, Signature const& args
, NArgs
, char const* doc
, detail::keyword_range keywords)
{
detail::def_init_aux(cl, args, NArgs(), policies, doc, keywords);
if (keywords.second > keywords.first)
--keywords.second;
typedef typename mpl::prior<NArgs>::type next_nargs;
define_class_init_helper<NDefaults-1>::apply(
cl, policies, Signature(), next_nargs(), doc, keywords);
}
};
///////////////////////////////////////////////////////////////////////////////
//
// define_class_init_helper<0>::apply
//
// Terminal case
//
// Accepts a class_ and an arguments list. Defines a constructor
// for the class given the arguments.
//
///////////////////////////////////////////////////////////////////////////////
template <>
struct define_class_init_helper<0> {
template <class ClassT, class CallPoliciesT, class Signature, class NArgs>
static void apply(
ClassT& cl
, CallPoliciesT const& policies
, Signature const& args
, NArgs
, char const* doc
, detail::keyword_range const& keywords)
{
detail::def_init_aux(cl, args, NArgs(), policies, doc, keywords);
}
};
}
}} // namespace boost::python
#undef BOOST_PYTHON_OVERLOAD_TYPES_WITH_DEFAULT
#undef BOOST_PYTHON_OVERLOAD_TYPES
#undef BOOST_PYTHON_OVERLOAD_ARGS
#undef BOOST_PYTHON_IS_OPTIONAL_VALUE
#undef BOOST_PYTHON_APPEND_TO_INIT
///////////////////////////////////////////////////////////////////////////////
#endif // INIT_JDG20020820_HPP