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.
297 lines
8.7 KiB
297 lines
8.7 KiB
// Copyright David Abrahams 2004. 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 CLASS_METADATA_DWA2004719_HPP |
|
# define CLASS_METADATA_DWA2004719_HPP |
|
# include <boost/python/converter/shared_ptr_from_python.hpp> |
|
|
|
# include <boost/python/object/inheritance.hpp> |
|
# include <boost/python/object/class_wrapper.hpp> |
|
# include <boost/python/object/make_instance.hpp> |
|
# include <boost/python/object/value_holder.hpp> |
|
# include <boost/python/object/pointer_holder.hpp> |
|
# include <boost/python/object/make_ptr_instance.hpp> |
|
|
|
# include <boost/python/detail/force_instantiate.hpp> |
|
# include <boost/python/detail/not_specified.hpp> |
|
|
|
# include <boost/python/has_back_reference.hpp> |
|
# include <boost/python/bases.hpp> |
|
|
|
# include <boost/type_traits/add_pointer.hpp> |
|
# include <boost/type_traits/is_convertible.hpp> |
|
# include <boost/type_traits/is_polymorphic.hpp> |
|
|
|
# include <boost/mpl/if.hpp> |
|
# include <boost/mpl/eval_if.hpp> |
|
# include <boost/mpl/bool.hpp> |
|
# include <boost/mpl/or.hpp> |
|
# include <boost/mpl/identity.hpp> |
|
# include <boost/mpl/for_each.hpp> |
|
# include <boost/mpl/placeholders.hpp> |
|
# include <boost/mpl/single_view.hpp> |
|
|
|
# include <boost/mpl/assert.hpp> |
|
# include <boost/type_traits/is_same.hpp> |
|
|
|
# include <boost/type_traits/is_convertible.hpp> |
|
|
|
# include <boost/noncopyable.hpp> |
|
# include <boost/detail/workaround.hpp> |
|
|
|
namespace boost { namespace python { namespace objects { |
|
|
|
BOOST_PYTHON_DECL |
|
void copy_class_object(type_info const& src, type_info const& dst); |
|
|
|
// |
|
// Support for registering base/derived relationships |
|
// |
|
template <class Derived> |
|
struct register_base_of |
|
{ |
|
template <class Base> |
|
inline void operator()(Base*) const |
|
{ |
|
# if !BOOST_WORKAROUND(BOOST_MSVC, == 1200) |
|
BOOST_MPL_ASSERT_NOT((is_same<Base,Derived>)); |
|
# else |
|
BOOST_STATIC_ASSERT(!(is_same<Base,Derived>::value)); |
|
# endif |
|
|
|
// Register the Base class |
|
register_dynamic_id<Base>(); |
|
|
|
// Register the up-cast |
|
register_conversion<Derived,Base>(false); |
|
|
|
// Register the down-cast, if appropriate. |
|
this->register_downcast((Base*)0, is_polymorphic<Base>()); |
|
} |
|
|
|
private: |
|
static inline void register_downcast(void*, mpl::false_) {} |
|
|
|
template <class Base> |
|
static inline void register_downcast(Base*, mpl::true_) |
|
{ |
|
register_conversion<Base, Derived>(true); |
|
} |
|
|
|
}; |
|
|
|
// |
|
// Preamble of register_class. Also used for callback classes, which |
|
// need some registration of their own. |
|
// |
|
template <class T, class Bases> |
|
inline void register_shared_ptr_from_python_and_casts(T*, Bases) |
|
{ |
|
// Constructor performs registration |
|
python::detail::force_instantiate(converter::shared_ptr_from_python<T>()); |
|
|
|
// |
|
// register all up/downcasts here. We're using the alternate |
|
// interface to mpl::for_each to avoid an MSVC 6 bug. |
|
// |
|
register_dynamic_id<T>(); |
|
mpl::for_each(register_base_of<T>(), (Bases*)0, (add_pointer<mpl::_>*)0); |
|
} |
|
|
|
// |
|
// Helper for choosing the unnamed held_type argument |
|
// |
|
template <class T, class Prev> |
|
struct select_held_type |
|
: mpl::if_< |
|
mpl::or_< |
|
python::detail::specifies_bases<T> |
|
, is_same<T,noncopyable> |
|
> |
|
, Prev |
|
, T |
|
> |
|
{ |
|
}; |
|
|
|
template < |
|
class T // class being wrapped |
|
, class X1 // = detail::not_specified |
|
, class X2 // = detail::not_specified |
|
, class X3 // = detail::not_specified |
|
> |
|
struct class_metadata |
|
{ |
|
// |
|
// Calculate the unnamed template arguments |
|
// |
|
|
|
// held_type_arg -- not_specified, [a class derived from] T or a |
|
// smart pointer to [a class derived from] T. Preserving |
|
// not_specified allows us to give class_<T,T> a back-reference. |
|
typedef typename select_held_type< |
|
X1 |
|
, typename select_held_type< |
|
X2 |
|
, typename select_held_type< |
|
X3 |
|
, python::detail::not_specified |
|
>::type |
|
>::type |
|
>::type held_type_arg; |
|
|
|
// bases |
|
typedef typename python::detail::select_bases< |
|
X1 |
|
, typename python::detail::select_bases< |
|
X2 |
|
, typename python::detail::select_bases< |
|
X3 |
|
, python::bases<> |
|
>::type |
|
>::type |
|
>::type bases; |
|
|
|
typedef mpl::or_< |
|
is_same<X1,noncopyable> |
|
, is_same<X2,noncopyable> |
|
, is_same<X3,noncopyable> |
|
> is_noncopyable; |
|
|
|
// |
|
// Holder computation. |
|
// |
|
|
|
// Compute the actual type that will be held in the Holder. |
|
typedef typename mpl::if_< |
|
is_same<held_type_arg,python::detail::not_specified>, T, held_type_arg |
|
>::type held_type; |
|
|
|
// Determine if the object will be held by value |
|
typedef is_convertible<held_type*,T*> use_value_holder; |
|
|
|
// Compute the "wrapped type", that is, if held_type is a smart |
|
// pointer, we're talking about the pointee. |
|
typedef typename mpl::eval_if< |
|
use_value_holder |
|
, mpl::identity<held_type> |
|
, pointee<held_type> |
|
>::type wrapped; |
|
|
|
// Determine whether to use a "back-reference holder" |
|
typedef mpl::or_< |
|
has_back_reference<T> |
|
, is_same<held_type_arg,T> |
|
, is_base_and_derived<T,wrapped> |
|
> use_back_reference; |
|
|
|
// Select the holder. |
|
typedef typename mpl::eval_if< |
|
use_back_reference |
|
, mpl::if_< |
|
use_value_holder |
|
, value_holder_back_reference<T, wrapped> |
|
, pointer_holder_back_reference<held_type,T> |
|
> |
|
, mpl::if_< |
|
use_value_holder |
|
, value_holder<T> |
|
, pointer_holder<held_type,wrapped> |
|
> |
|
>::type holder; |
|
|
|
inline static void register_() // Register the runtime metadata. |
|
{ |
|
class_metadata::register_aux((T*)0); |
|
} |
|
|
|
private: |
|
template <class T2> |
|
inline static void register_aux(python::wrapper<T2>*) |
|
{ |
|
typedef typename mpl::not_<is_same<T2,wrapped> >::type use_callback; |
|
class_metadata::register_aux2((T2*)0, use_callback()); |
|
} |
|
|
|
inline static void register_aux(void*) |
|
{ |
|
typedef typename is_base_and_derived<T,wrapped>::type use_callback; |
|
class_metadata::register_aux2((T*)0, use_callback()); |
|
} |
|
|
|
template <class T2, class Callback> |
|
inline static void register_aux2(T2*, Callback) |
|
{ |
|
objects::register_shared_ptr_from_python_and_casts((T2*)0, bases()); |
|
|
|
class_metadata::maybe_register_callback_class((T2*)0, Callback()); |
|
|
|
class_metadata::maybe_register_class_to_python((T2*)0, is_noncopyable()); |
|
|
|
class_metadata::maybe_register_pointer_to_python( |
|
(T2*)0, (use_value_holder*)0, (use_back_reference*)0); |
|
} |
|
|
|
|
|
// |
|
// Support for converting smart pointers to python |
|
// |
|
inline static void maybe_register_pointer_to_python(...) {} |
|
|
|
#ifndef BOOST_PYTHON_NO_PY_SIGNATURES |
|
inline static void maybe_register_pointer_to_python(void*,void*,mpl::true_*) |
|
{ |
|
objects::copy_class_object(python::type_id<T>(), python::type_id<back_reference<T const &> >()); |
|
objects::copy_class_object(python::type_id<T>(), python::type_id<back_reference<T &> >()); |
|
} |
|
#endif |
|
|
|
template <class T2> |
|
inline static void maybe_register_pointer_to_python(T2*, mpl::false_*, mpl::false_*) |
|
{ |
|
python::detail::force_instantiate( |
|
objects::class_value_wrapper< |
|
held_type |
|
, make_ptr_instance<T2, pointer_holder<held_type, T2> > |
|
>() |
|
); |
|
#ifndef BOOST_PYTHON_NO_PY_SIGNATURES |
|
// explicit qualification of type_id makes msvc6 happy |
|
objects::copy_class_object(python::type_id<T2>(), python::type_id<held_type>()); |
|
#endif |
|
} |
|
// |
|
// Support for registering to-python converters |
|
// |
|
inline static void maybe_register_class_to_python(void*, mpl::true_) {} |
|
|
|
|
|
template <class T2> |
|
inline static void maybe_register_class_to_python(T2*, mpl::false_) |
|
{ |
|
python::detail::force_instantiate(class_cref_wrapper<T2, make_instance<T2, holder> >()); |
|
#ifndef BOOST_PYTHON_NO_PY_SIGNATURES |
|
// explicit qualification of type_id makes msvc6 happy |
|
objects::copy_class_object(python::type_id<T2>(), python::type_id<held_type>()); |
|
#endif |
|
} |
|
|
|
// |
|
// Support for registering callback classes |
|
// |
|
inline static void maybe_register_callback_class(void*, mpl::false_) {} |
|
|
|
template <class T2> |
|
inline static void maybe_register_callback_class(T2*, mpl::true_) |
|
{ |
|
objects::register_shared_ptr_from_python_and_casts( |
|
(wrapped*)0, mpl::single_view<T2>()); |
|
|
|
// explicit qualification of type_id makes msvc6 happy |
|
objects::copy_class_object(python::type_id<T2>(), python::type_id<wrapped>()); |
|
} |
|
}; |
|
|
|
}}} // namespace boost::python::object |
|
|
|
#endif // CLASS_METADATA_DWA2004719_HPP
|
|
|