FCL/sf/os/ossrv: comparison ossrv_pub/boost

equal deleted inserted replaced

--1:000000000000
+:e4d67989cc36
+// Copyright David Abrahams 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 CLASS_DWA200216_HPP
+# define CLASS_DWA200216_HPP
+# include <boost/python/detail/prefix.hpp>
+# include <boost/noncopyable.hpp>
+# include <boost/python/class_fwd.hpp>
+# include <boost/python/object/class.hpp>
+# include <boost/python/object.hpp>
+# include <boost/python/type_id.hpp>
+# include <boost/python/data_members.hpp>
+# include <boost/python/make_function.hpp>
+# include <boost/python/signature.hpp>
+# include <boost/python/init.hpp>
+# include <boost/python/args_fwd.hpp>
+# include <boost/python/object/class_metadata.hpp>
+# include <boost/python/object/pickle_support.hpp>
+# include <boost/python/object/add_to_namespace.hpp>
+# include <boost/python/detail/overloads_fwd.hpp>
+# include <boost/python/detail/operator_id.hpp>
+# include <boost/python/detail/def_helper.hpp>
+# include <boost/python/detail/force_instantiate.hpp>
+# include <boost/python/detail/unwrap_type_id.hpp>
+# include <boost/python/detail/unwrap_wrapper.hpp>
+# include <boost/type_traits/is_same.hpp>
+# include <boost/type_traits/is_member_function_pointer.hpp>
+# include <boost/type_traits/is_polymorphic.hpp>
+# include <boost/mpl/size.hpp>
+# include <boost/mpl/for_each.hpp>
+# include <boost/mpl/bool.hpp>
+# include <boost/mpl/not.hpp>
+# include <boost/detail/workaround.hpp>
+# if BOOST_WORKAROUND(__MWERKS__, <= 0x3004)                        \
+/* pro9 reintroduced the bug */                                 \
+|| (BOOST_WORKAROUND(__MWERKS__, > 0x3100)                      \
+&& BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201)))   \
+|| BOOST_WORKAROUND(__GNUC__, < 3)
+#  define BOOST_PYTHON_NO_MEMBER_POINTER_ORDERING 1
+# endif
+# ifdef BOOST_PYTHON_NO_MEMBER_POINTER_ORDERING
+#  include <boost/mpl/and.hpp>
+#  include <boost/type_traits/is_member_pointer.hpp>
+# endif
+namespace boost { namespace python {
+template <class DerivedVisitor> class def_visitor;
+enum no_init_t { no_init };
+namespace detail
+{
+// This function object is used with mpl::for_each to write the id
+// of the type a pointer to which is passed as its 2nd compile-time
+// argument. into the iterator pointed to by its runtime argument
+struct write_type_id
+{
+write_type_id(type_info**p) : p(p) {}
+// Here's the runtime behavior
+template <class T>
+void operator()(T*) const
+{
+*(*p)++ = type_id<T>();
+}
+type_info** p;
+};
+template <class T>
+struct is_data_member_pointer
+: mpl::and_<
+is_member_pointer<T>
+, mpl::not_<is_member_function_pointer<T> >
+>
+{};
+# ifdef BOOST_PYTHON_NO_MEMBER_POINTER_ORDERING
+#  define BOOST_PYTHON_DATA_MEMBER_HELPER(D) , detail::is_data_member_pointer<D>()
+#  define BOOST_PYTHON_YES_DATA_MEMBER , mpl::true_
+#  define BOOST_PYTHON_NO_DATA_MEMBER , mpl::false_
+# elif defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+#  define BOOST_PYTHON_DATA_MEMBER_HELPER(D) , 0
+#  define BOOST_PYTHON_YES_DATA_MEMBER , int
+#  define BOOST_PYTHON_NO_DATA_MEMBER , ...
+# else
+#  define BOOST_PYTHON_DATA_MEMBER_HELPER(D)
+#  define BOOST_PYTHON_YES_DATA_MEMBER
+#  define BOOST_PYTHON_NO_DATA_MEMBER
+# endif
+namespace error
+{
+//
+// A meta-assertion mechanism which prints nice error messages and
+// backtraces on lots of compilers. Usage:
+//
+//      assertion<C>::failed
+//
+// where C is an MPL metafunction class
+//
+template <class C> struct assertion_failed { };
+template <class C> struct assertion_ok { typedef C failed; };
+template <class C>
+struct assertion
+: mpl::if_<C, assertion_ok<C>, assertion_failed<C> >::type
+{};
+//
+// Checks for validity of arguments used to define virtual
+// functions with default implementations.
+//
+template <class Default>
+void not_a_derived_class_member(Default) {}
+template <class T, class Fn>
+struct virtual_function_default
+{
+template <class Default>
+static void
+must_be_derived_class_member(Default const&)
+{
+typedef typename assertion<mpl::not_<is_same<Default,Fn> > >::failed test0;
+# if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
+typedef typename assertion<is_polymorphic<T> >::failed test1;
+# endif
+typedef typename assertion<is_member_function_pointer<Fn> >::failed test2;
+not_a_derived_class_member<Default>(Fn());
+}
+};
+}
+}
+// This is the primary mechanism through which users will expose
+// C++ classes to Python.
+template <
+class W // class being wrapped
+, class X1 // = detail::not_specified
+, class X2 // = detail::not_specified
+, class X3 // = detail::not_specified
+>
+class class_ : public objects::class_base
+{
+public: // types
+typedef objects::class_base base;
+typedef class_<W,X1,X2,X3> self;
+typedef typename objects::class_metadata<W,X1,X2,X3> metadata;
+typedef W wrapped_type;
+private: // types
+// A helper class which will contain an array of id objects to be
+// passed to the base class constructor
+struct id_vector
+{
+typedef typename metadata::bases bases;
+id_vector()
+{
+// Stick the derived class id into the first element of the array
+ids[0] = detail::unwrap_type_id((W*)0, (W*)0);
+// Write the rest of the elements into succeeding positions.
+type_info* p = ids + 1;
+mpl::for_each(detail::write_type_id(&p), (bases*)0, (add_pointer<mpl::_>*)0);
+}
+BOOST_STATIC_CONSTANT(
+std::size_t, size = mpl::size<bases>::value + 1);
+type_info ids[size];
+};
+friend struct id_vector;
+public: // constructors
+// Construct with the class name, with or without docstring, and default __init__() function
+class_(char const* name, char const* doc = 0);
+// Construct with class name, no docstring, and an uncallable __init__ function
+class_(char const* name, no_init_t);
+// Construct with class name, docstring, and an uncallable __init__ function
+class_(char const* name, char const* doc, no_init_t);
+// Construct with class name and init<> function
+template <class DerivedT>
+inline class_(char const* name, init_base<DerivedT> const& i)
+: base(name, id_vector::size, id_vector().ids)
+{
+this->initialize(i);
+}
+// Construct with class name, docstring and init<> function
+template <class DerivedT>
+inline class_(char const* name, char const* doc, init_base<DerivedT> const& i)
+: base(name, id_vector::size, id_vector().ids, doc)
+{
+this->initialize(i);
+}
+public: // member functions
+// Generic visitation
+template <class Derived>
+self& def(def_visitor<Derived> const& visitor)
+{
+visitor.visit(*this);
+return *this;
+}
+// Wrap a member function or a non-member function which can take
+// a T, T cv&, or T cv* as its first parameter, a callable
+// python object, or a generic visitor.
+template <class F>
+self& def(char const* name, F f)
+{
+this->def_impl(
+detail::unwrap_wrapper((W*)0)
+, name, f, detail::def_helper<char const*>(0), &f);
+return *this;
+}
+template <class A1, class A2>
+self& def(char const* name, A1 a1, A2 const& a2)
+{
+this->def_maybe_overloads(name, a1, a2, &a2);
+return *this;
+}
+template <class Fn, class A1, class A2>
+self& def(char const* name, Fn fn, A1 const& a1, A2 const& a2)
+{
+//  The arguments are definitely:
+//      def(name, function, policy, doc_string)
+//      def(name, function, doc_string, policy)
+this->def_impl(
+detail::unwrap_wrapper((W*)0)
+, name, fn
+, detail::def_helper<A1,A2>(a1,a2)
+, &fn);
+return *this;
+}
+template <class Fn, class A1, class A2, class A3>
+self& def(char const* name, Fn fn, A1 const& a1, A2 const& a2, A3 const& a3)
+{
+this->def_impl(
+detail::unwrap_wrapper((W*)0)
+, name, fn
+, detail::def_helper<A1,A2,A3>(a1,a2,a3)
+, &fn);
+return *this;
+}
+//
+// Data member access
+//
+template <class D>
+self& def_readonly(char const* name, D const& d, char const* doc=0)
+{
+return this->def_readonly_impl(name, d, doc BOOST_PYTHON_DATA_MEMBER_HELPER(D));
+}
+template <class D>
+self& def_readwrite(char const* name, D const& d, char const* doc=0)
+{
+return this->def_readwrite_impl(name, d, doc BOOST_PYTHON_DATA_MEMBER_HELPER(D));
+}
+template <class D>
+self& def_readonly(char const* name, D& d, char const* doc=0)
+{
+return this->def_readonly_impl(name, d, doc BOOST_PYTHON_DATA_MEMBER_HELPER(D));
+}
+template <class D>
+self& def_readwrite(char const* name, D& d, char const* doc=0)
+{
+return this->def_readwrite_impl(name, d, doc BOOST_PYTHON_DATA_MEMBER_HELPER(D));
+}
+// Property creation
+# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+template <class Get>
+self& add_property(char const* name, Get fget, char const* docstr = 0)
+{
+base::add_property(name, this->make_getter(fget), docstr);
+return *this;
+}
+template <class Get, class Set>
+self& add_property(char const* name, Get fget, Set fset, char const* docstr = 0)
+{
+base::add_property(
+name, this->make_getter(fget), this->make_setter(fset), docstr);
+return *this;
+}
+# else
+private:
+template <class Get>
+self& add_property_impl(char const* name, Get fget, char const* docstr, int)
+{
+base::add_property(name, this->make_getter(fget), docstr);
+return *this;
+}
+template <class Get, class Set>
+self& add_property_impl(char const* name, Get fget, Set fset, ...)
+{
+base::add_property(
+name, this->make_getter(fget), this->make_setter(fset), 0);
+return *this;
+}
+public:
+template <class Get>
+self& add_property(char const* name, Get fget)
+{
+base::add_property(name, this->make_getter(fget), 0);
+return *this;
+}
+template <class Get, class DocStrOrSet>
+self& add_property(char const* name, Get fget, DocStrOrSet docstr_or_set)
+{
+this->add_property_impl(name, this->make_getter(fget), docstr_or_set, 0);
+return *this;
+}
+template <class Get, class Set>
+self&
+add_property(char const* name, Get fget, Set fset, char const* docstr)
+{
+base::add_property(
+name, this->make_getter(fget), this->make_setter(fset), docstr);
+return *this;
+}
+# endif
+template <class Get>
+self& add_static_property(char const* name, Get fget)
+{
+base::add_static_property(name, object(fget));
+return *this;
+}
+template <class Get, class Set>
+self& add_static_property(char const* name, Get fget, Set fset)
+{
+base::add_static_property(name, object(fget), object(fset));
+return *this;
+}
+template <class U>
+self& setattr(char const* name, U const& x)
+{
+this->base::setattr(name, object(x));
+return *this;
+}
+// Pickle support
+template <typename PickleSuiteType>
+self& def_pickle(PickleSuiteType const& x)
+{
+error_messages::must_be_derived_from_pickle_suite(x);
+detail::pickle_suite_finalize<PickleSuiteType>::register_(
+*this,
+&PickleSuiteType::getinitargs,
+&PickleSuiteType::getstate,
+&PickleSuiteType::setstate,
+PickleSuiteType::getstate_manages_dict());
+return *this;
+}
+self& enable_pickling()
+{
+this->base::enable_pickling_(false);
+return *this;
+}
+self& staticmethod(char const* name)
+{
+this->make_method_static(name);
+return *this;
+}
+private: // helper functions
+// Builds a method for this class around the given [member]
+// function pointer or object, appropriately adjusting the type of
+// the first signature argument so that if f is a member of a
+// (possibly not wrapped) base class of T, an lvalue argument of
+// type T will be required.
+//
+// @group PropertyHelpers {
+template <class F>
+object make_getter(F f)
+{
+typedef typename api::is_object_operators<F>::type is_obj_or_proxy;
+return this->make_fn_impl(
+detail::unwrap_wrapper((W*)0)
+, f, is_obj_or_proxy(), (char*)0, detail::is_data_member_pointer<F>()
+);
+}
+template <class F>
+object make_setter(F f)
+{
+typedef typename api::is_object_operators<F>::type is_obj_or_proxy;
+return this->make_fn_impl(
+detail::unwrap_wrapper((W*)0)
+, f, is_obj_or_proxy(), (int*)0, detail::is_data_member_pointer<F>()
+);
+}
+template <class T, class F>
+object make_fn_impl(T*, F const& f, mpl::false_, void*, mpl::false_)
+{
+return python::make_function(f, default_call_policies(), detail::get_signature(f, (T*)0));
+}
+template <class T, class D, class B>
+object make_fn_impl(T*, D B::*pm_, mpl::false_, char*, mpl::true_)
+{
+D T::*pm = pm_;
+return python::make_getter(pm);
+}
+template <class T, class D, class B>
+object make_fn_impl(T*, D B::*pm_, mpl::false_, int*, mpl::true_)
+{
+D T::*pm = pm_;
+return python::make_setter(pm);
+}
+template <class T, class F>
+object make_fn_impl(T*, F const& x, mpl::true_, void*, mpl::false_)
+{
+return x;
+}
+// }
+template <class D, class B>
+self& def_readonly_impl(
+char const* name, D B::*pm_, char const* doc BOOST_PYTHON_YES_DATA_MEMBER)
+{
+return this->add_property(name, pm_, doc);
+}
+template <class D, class B>
+self& def_readwrite_impl(
+char const* name, D B::*pm_, char const* doc BOOST_PYTHON_YES_DATA_MEMBER)
+{
+return this->add_property(name, pm_, pm_, doc);
+}
+template <class D>
+self& def_readonly_impl(
+char const* name, D& d, char const* BOOST_PYTHON_NO_DATA_MEMBER)
+{
+return this->add_static_property(name, python::make_getter(d));
+}
+template <class D>
+self& def_readwrite_impl(
+char const* name, D& d, char const* BOOST_PYTHON_NO_DATA_MEMBER)
+{
+return this->add_static_property(name, python::make_getter(d), python::make_setter(d));
+}
+template <class DefVisitor>
+inline void initialize(DefVisitor const& i)
+{
+metadata::register_(); // set up runtime metadata/conversions
+typedef typename metadata::holder holder;
+this->set_instance_size( objects::additional_instance_size<holder>::value );
+this->def(i);
+}
+inline void initialize(no_init_t)
+{
+metadata::register_(); // set up runtime metadata/conversions
+this->def_no_init();
+}
+//
+// These two overloads discriminate between def() as applied to a
+// generic visitor and everything else.
+//
+// @group def_impl {
+template <class T, class Helper, class LeafVisitor, class Visitor>
+inline void def_impl(
+T*
+, char const* name
+, LeafVisitor
+, Helper const& helper
+, def_visitor<Visitor> const* v
+)
+{
+v->visit(*this, name,  helper);
+}
+template <class T, class Fn, class Helper>
+inline void def_impl(
+T*
+, char const* name
+, Fn fn
+, Helper const& helper
+, ...
+)
+{
+objects::add_to_namespace(
+*this
+, name
+, make_function(
+fn
+, helper.policies()
+, helper.keywords()
+, detail::get_signature(fn, (T*)0)
+)
+, helper.doc()
+);
+this->def_default(name, fn, helper, mpl::bool_<Helper::has_default_implementation>());
+}
+// }
+//
+// These two overloads handle the definition of default
+// implementation overloads for virtual functions. The second one
+// handles the case where no default implementation was specified.
+//
+// @group def_default {
+template <class Fn, class Helper>
+inline void def_default(
+char const* name
+, Fn
+, Helper const& helper
+, mpl::bool_<true>)
+{
+detail::error::virtual_function_default<W,Fn>::must_be_derived_class_member(
+helper.default_implementation());
+objects::add_to_namespace(
+*this, name,
+make_function(
+helper.default_implementation(), helper.policies(), helper.keywords())
+);
+}
+template <class Fn, class Helper>
+inline void def_default(char const*, Fn, Helper const&, mpl::bool_<false>)
+{ }
+// }
+//
+// These two overloads discriminate between def() as applied to
+// regular functions and def() as applied to the result of
+// BOOST_PYTHON_FUNCTION_OVERLOADS(). The final argument is used to
+// discriminate.
+//
+// @group def_maybe_overloads {
+template <class OverloadsT, class SigT>
+void def_maybe_overloads(
+char const* name
+, SigT sig
+, OverloadsT const& overloads
+, detail::overloads_base const*)
+{
+//  convert sig to a type_list (see detail::get_signature in signature.hpp)
+//  before calling detail::define_with_defaults.
+detail::define_with_defaults(
+name, overloads, *this, detail::get_signature(sig));
+}
+template <class Fn, class A1>
+void def_maybe_overloads(
+char const* name
+, Fn fn
+, A1 const& a1
+, ...)
+{
+this->def_impl(
+detail::unwrap_wrapper((W*)0)
+, name
+, fn
+, detail::def_helper<A1>(a1)
+, &fn
+);
+}
+// }
+};
+//
+// implementations
+//
+template <class W, class X1, class X2, class X3>
+inline class_<W,X1,X2,X3>::class_(char const* name, char const* doc)
+: base(name, id_vector::size, id_vector().ids, doc)
+{
+this->initialize(init<>());
+//  select_holder::assert_default_constructible();
+}
+template <class W, class X1, class X2, class X3>
+inline class_<W,X1,X2,X3>::class_(char const* name, no_init_t)
+: base(name, id_vector::size, id_vector().ids)
+{
+this->initialize(no_init);
+}
+template <class W, class X1, class X2, class X3>
+inline class_<W,X1,X2,X3>::class_(char const* name, char const* doc, no_init_t)
+: base(name, id_vector::size, id_vector().ids, doc)
+{
+this->initialize(no_init);
+}
+}} // namespace boost::python
+# undef BOOST_PYTHON_DATA_MEMBER_HELPER
+# undef BOOST_PYTHON_YES_DATA_MEMBER
+# undef BOOST_PYTHON_NO_DATA_MEMBER
+# undef BOOST_PYTHON_NO_MEMBER_POINTER_ORDERING
+#endif // CLASS_DWA200216_HPP