This commit was manufactured by cvs2svn to create branch

'thread_rewrite'.

[SVN r30953]

include/boost/python.hpp

@@ -0,0 +1,72 @@
+// 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)
+
+//  See http://www.boost.org/libs/python for documentation.
+
+#ifndef PYTHON_DWA2002810_HPP
+# define PYTHON_DWA2002810_HPP
+
+# include <boost/python/args.hpp>
+# include <boost/python/args_fwd.hpp>
+# include <boost/python/back_reference.hpp>
+# include <boost/python/bases.hpp>
+# include <boost/python/borrowed.hpp>
+# include <boost/python/call.hpp>
+# include <boost/python/call_method.hpp>
+# include <boost/python/class.hpp>
+# include <boost/python/copy_const_reference.hpp>
+# include <boost/python/copy_non_const_reference.hpp>
+# include <boost/python/data_members.hpp>
+# include <boost/python/def.hpp>
+# include <boost/python/default_call_policies.hpp>
+# include <boost/python/dict.hpp>
+# include <boost/python/enum.hpp>
+# include <boost/python/errors.hpp>
+# include <boost/python/exception_translator.hpp>
+# include <boost/python/exec.hpp>
+# include <boost/python/extract.hpp>
+# include <boost/python/handle.hpp>
+# include <boost/python/has_back_reference.hpp>
+# include <boost/python/implicit.hpp>
+# include <boost/python/init.hpp>
+# include <boost/python/import.hpp>
+# include <boost/python/instance_holder.hpp>
+# include <boost/python/iterator.hpp>
+# include <boost/python/list.hpp>
+# include <boost/python/long.hpp>
+# include <boost/python/lvalue_from_pytype.hpp>
+# include <boost/python/make_constructor.hpp>
+# include <boost/python/make_function.hpp>
+# include <boost/python/manage_new_object.hpp>
+# include <boost/python/module.hpp>
+# include <boost/python/numeric.hpp>
+# include <boost/python/object.hpp>
+# include <boost/python/object_protocol.hpp>
+# include <boost/python/object_protocol_core.hpp>
+# include <boost/python/opaque_pointer_converter.hpp>
+# include <boost/python/operators.hpp>
+# include <boost/python/other.hpp>
+# include <boost/python/overloads.hpp>
+# include <boost/python/pointee.hpp>
+# include <boost/python/pure_virtual.hpp>
+# include <boost/python/ptr.hpp>
+# include <boost/python/reference_existing_object.hpp>
+# include <boost/python/register_ptr_to_python.hpp>
+# include <boost/python/return_arg.hpp>
+# include <boost/python/return_internal_reference.hpp>
+# include <boost/python/return_opaque_pointer.hpp>
+# include <boost/python/return_value_policy.hpp>
+# include <boost/python/scope.hpp>
+# include <boost/python/self.hpp>
+# include <boost/python/slice_nil.hpp>
+# include <boost/python/str.hpp>
+# include <boost/python/to_python_converter.hpp>
+# include <boost/python/to_python_indirect.hpp>
+# include <boost/python/to_python_value.hpp>
+# include <boost/python/tuple.hpp>
+# include <boost/python/type_id.hpp>
+# include <boost/python/with_custodian_and_ward.hpp>
+
+#endif // PYTHON_DWA2002810_HPP

include/boost/python/arg_from_python.hpp

@@ -1,20 +1,39 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 ARG_FROM_PYTHON_DWA2002128_HPP
 # define ARG_FROM_PYTHON_DWA2002128_HPP
 
+# include <boost/python/detail/prefix.hpp>
 # include <boost/python/converter/arg_from_python.hpp>
+# if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \
+    || BOOST_WORKAROUND(BOOST_INTEL_WIN, BOOST_TESTED_AT(800))
+# include <boost/type_traits/remove_cv.hpp>
+#endif
 
 namespace boost { namespace python { 
 
 template <class T>
 struct arg_from_python
-    : converter::select_arg_from_python<T>::type
+    : converter::select_arg_from_python<
+# if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \
+    || BOOST_WORKAROUND(BOOST_INTEL_WIN, BOOST_TESTED_AT(800))
+          typename boost::remove_cv<T>::type
+# else
+          T
+# endif 
+      >::type
 {
-    typedef typename converter::select_arg_from_python<T>::type base;
+    typedef typename converter::select_arg_from_python<
+# if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \
+    || BOOST_WORKAROUND(BOOST_INTEL_WIN, BOOST_TESTED_AT(800))
+          typename boost::remove_cv<T>::type
+# else
+          T
+# endif 
+        >::type base;
+    
     arg_from_python(PyObject*);
 };
 
@@ -24,18 +43,23 @@ struct arg_from_python<PyObject*>
 {
     typedef PyObject* result_type;
     
-    arg_from_python(PyObject*) {}
+    arg_from_python(PyObject* p) : m_source(p) {}
     bool convertible() const { return true; }
-    PyObject* operator()(PyObject* source) const { return source; }
+    PyObject* operator()() const { return m_source; }
+ private:
+    PyObject* m_source;
 };
 
 template <>
 struct arg_from_python<PyObject* const&>
 {
     typedef PyObject* const& result_type;
-    arg_from_python(PyObject*) {}
+    
+    arg_from_python(PyObject* p) : m_source(p) {}
     bool convertible() const { return true; }
-    PyObject*const& operator()(PyObject*const& source) const { return source; }
+    PyObject*const& operator()() const { return m_source; }
+ private:
+    PyObject* m_source;
 };
 
 //

include/boost/python/args.hpp

@@ -1,34 +1,175 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef ARGS_DWA2002323_HPP
-# define ARGS_DWA2002323_HPP
-#  include <boost/config.hpp>
-#  include <boost/python/detail/preprocessor.hpp>
-#  include <boost/python/detail/type_list.hpp>
+// 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 KEYWORDS_DWA2002323_HPP
+# define KEYWORDS_DWA2002323_HPP
+
+# include <boost/python/detail/prefix.hpp>
+
+# include <boost/python/args_fwd.hpp>
+# include <boost/config.hpp>
+# include <boost/python/detail/preprocessor.hpp>
+# include <boost/python/detail/type_list.hpp>
+
+# include <boost/type_traits/is_reference.hpp>
+# include <boost/type_traits/remove_reference.hpp>
+# include <boost/type_traits/remove_cv.hpp>
+
+# include <boost/preprocessor/enum_params.hpp>
+# include <boost/preprocessor/repeat.hpp>
+# include <boost/preprocessor/facilities/intercept.hpp>
+# include <boost/preprocessor/iteration/local.hpp>
+
+# include <boost/python/detail/mpl_lambda.hpp>
+# include <boost/python/object_core.hpp>
+
+# include <boost/mpl/bool.hpp>
+
+# include <cstddef>
+# include <algorithm>
 
 namespace boost { namespace python {
 
-enum no_init_t { no_init };
+typedef detail::keywords<1> arg;
+typedef arg arg_; // gcc 2.96 workaround
 
 namespace detail
 {
-  template <class Args>
-  struct args_base {};
+  template <std::size_t nkeywords>
+  struct keywords_base
+  {
+      BOOST_STATIC_CONSTANT(std::size_t, size = nkeywords);
+      
+      keyword_range range() const
+      {
+          return keyword_range(elements, elements + nkeywords);
+      }
+
+      keyword elements[nkeywords];
+
+      keywords<nkeywords+1>
+      operator,(python::arg const &k) const;
+
+      keywords<nkeywords + 1>
+      operator,(char const *name) const;
+  };
+  
+  template <std::size_t nkeywords>
+  struct keywords : keywords_base<nkeywords>
+  {
+  };
+
+  template <>
+  struct keywords<1> : keywords_base<1>
+  {
+      explicit keywords(char const *name)
+      {
+          elements[0].name = name;
+      }
+    
+      template <class T>
+      python::arg& operator=(T const& value)
+      {
+          object z(value);
+          elements[0].default_value = handle<>(python::borrowed(object(value).ptr()));
+          return *this;
+      }
+    
+      operator detail::keyword const&() const
+      {
+          return elements[0];
+      }
+  };
+
+  template <std::size_t nkeywords>
+  inline
+  keywords<nkeywords+1>
+  keywords_base<nkeywords>::operator,(python::arg const &k) const
+  {
+      keywords<nkeywords> const& l = *static_cast<keywords<nkeywords> const*>(this);
+      python::detail::keywords<nkeywords+1> res;
+      std::copy(l.elements, l.elements+nkeywords, res.elements);
+      res.elements[nkeywords] = k.elements[0];
+      return res;
+  }
+
+  template <std::size_t nkeywords>
+  inline
+  keywords<nkeywords + 1>
+  keywords_base<nkeywords>::operator,(char const *name) const
+  {
+      return this->operator,(python::arg(name));
+  }
+
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+  template<typename T>
+  struct is_keywords
+  {
+      BOOST_STATIC_CONSTANT(bool, value = false); 
+  };
+
+  template<std::size_t nkeywords>
+  struct is_keywords<keywords<nkeywords> >
+  {
+      BOOST_STATIC_CONSTANT(bool, value = true);
+  };
+  template <class T>
+  struct is_reference_to_keywords
+  {
+      BOOST_STATIC_CONSTANT(bool, is_ref = is_reference<T>::value);
+      typedef typename remove_reference<T>::type deref;
+      typedef typename remove_cv<deref>::type key_t;
+      BOOST_STATIC_CONSTANT(bool, is_key = is_keywords<key_t>::value);
+      BOOST_STATIC_CONSTANT(bool, value = (is_ref & is_key));
+      
+      typedef mpl::bool_<value> type;
+      BOOST_PYTHON_MPL_LAMBDA_SUPPORT(1,is_reference_to_keywords,(T))
+  };
+# else 
+  typedef char (&yes_keywords_t)[1];
+  typedef char (&no_keywords_t)[2];
+      
+  no_keywords_t is_keywords_test(...);
+
+  template<std::size_t nkeywords>
+  yes_keywords_t is_keywords_test(void (*)(keywords<nkeywords>&));
+
+  template<std::size_t nkeywords>
+  yes_keywords_t is_keywords_test(void (*)(keywords<nkeywords> const&));
+
+  template<typename T>
+  class is_reference_to_keywords
+  {
+   public:
+      BOOST_STATIC_CONSTANT(
+          bool, value = (
+              sizeof(detail::is_keywords_test( (void (*)(T))0 ))
+              == sizeof(detail::yes_keywords_t)));
+
+      typedef mpl::bool_<value> type;
+      BOOST_PYTHON_MPL_LAMBDA_SUPPORT(1,is_reference_to_keywords,(T))
+  };
+# endif 
 }
-}}
 
-namespace boost { namespace python {
+inline detail::keywords<1> args(char const* name)
+{ 
+    return detail::keywords<1>(name);
+}
 
-// A type list for specifying arguments
-template < BOOST_PYTHON_ENUM_WITH_DEFAULT(BOOST_PYTHON_MAX_ARITY, typename A, mpl::void_) >
-struct args : detail::args_base<args<BOOST_PYTHON_UNARY_ENUM(BOOST_PYTHON_MAX_ARITY, A)> >
-      , detail::type_list< BOOST_PYTHON_UNARY_ENUM(BOOST_PYTHON_MAX_ARITY, A) >::type
-{};
+#  define BOOST_PYTHON_ASSIGN_NAME(z, n, _) result.elements[n].name = name##n;
+#  define BOOST_PP_LOCAL_MACRO(n)                                               \
+inline detail::keywords<n> args(BOOST_PP_ENUM_PARAMS_Z(1, n, char const* name)) \
+{                                                                               \
+    detail::keywords<n> result;                                                 \
+    BOOST_PP_REPEAT_1(n, BOOST_PYTHON_ASSIGN_NAME, _)                           \
+    return result;                                                              \
+}
+#  define BOOST_PP_LOCAL_LIMITS (2, BOOST_PYTHON_MAX_ARITY)
+#  include BOOST_PP_LOCAL_ITERATE()
 
 }} // namespace boost::python
 
 
-# endif // ARGS_DWA2002323_HPP
+# endif // KEYWORDS_DWA2002323_HPP

include/boost/python/args_fwd.hpp

@@ -0,0 +1,52 @@
+// 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 ARGS_FWD_DWA2002927_HPP
+# define ARGS_FWD_DWA2002927_HPP
+
+# include <boost/python/detail/prefix.hpp>
+
+# include <boost/python/handle.hpp>
+# include <boost/config.hpp>
+# include <cstddef>
+# include <utility>
+
+namespace boost { namespace python { 
+
+namespace detail
+{
+  struct keyword
+  {
+      keyword(char const* name_=0)
+       : name(name_)
+      {}
+      
+      char const* name;
+      handle<> default_value;
+  };
+  
+  template <std::size_t nkeywords = 0> struct keywords;
+  
+  typedef std::pair<keyword const*, keyword const*> keyword_range;
+  
+  template <>
+  struct keywords<0>
+  {
+      BOOST_STATIC_CONSTANT(std::size_t, size = 0);
+      static keyword_range range() { return keyword_range(); }
+  };
+
+  namespace error
+  {
+    template <int keywords, int function_args>
+    struct more_keywords_than_function_arguments
+    {
+        typedef char too_many_keywords[keywords > function_args ? -1 : 1];
+    };
+  }
+}
+
+}} // namespace boost::python
+
+#endif // ARGS_FWD_DWA2002927_HPP

include/boost/python/back_reference.hpp

@@ -1,11 +1,12 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 BACK_REFERENCE_DWA2002510_HPP
 # define BACK_REFERENCE_DWA2002510_HPP
 
+# include <boost/python/detail/prefix.hpp>
+
 # include <boost/python/object_fwd.hpp>
 # include <boost/python/detail/dependent.hpp>
 # include <boost/python/detail/raw_pyobject.hpp>

include/boost/python/base_type_traits.hpp

@@ -1,11 +1,12 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 BASE_TYPE_TRAITS_DWA2002614_HPP
 # define BASE_TYPE_TRAITS_DWA2002614_HPP
 
+# include <boost/python/detail/prefix.hpp>
+
 namespace boost { namespace python { 
 
 namespace detail
@@ -31,6 +32,12 @@ struct base_type_traits<PyTypeObject>
     typedef PyObject type;
 };
 
+template <>
+struct base_type_traits<PyMethodObject>
+{
+    typedef PyObject type;
+};
+
 }} // namespace boost::python
 
 #endif // BASE_TYPE_TRAITS_DWA2002614_HPP

include/boost/python/bases.hpp

@@ -1,60 +1,68 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 BASES_DWA2002321_HPP
 # define BASES_DWA2002321_HPP
+
+# include <boost/python/detail/prefix.hpp>
 # include <boost/type_traits/object_traits.hpp>
 # include <boost/python/detail/type_list.hpp>
 # include <boost/mpl/if.hpp>
+# include <boost/mpl/bool.hpp>
 # include <boost/preprocessor/enum_params_with_a_default.hpp>
 # include <boost/preprocessor/enum_params.hpp>
 
 namespace boost { namespace python { 
 
+# define BOOST_PYTHON_BASE_PARAMS BOOST_PP_ENUM_PARAMS_Z(1, BOOST_PYTHON_MAX_BASES, Base)
+
   // A type list for specifying bases
-  template < BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PYTHON_MAX_BASES, typename B, mpl::void_) >
-  struct bases : detail::type_list< BOOST_PP_ENUM_PARAMS(BOOST_PYTHON_MAX_BASES, B) >::type
+  template < BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PYTHON_MAX_BASES, typename Base, mpl::void_) >
+  struct bases : detail::type_list< BOOST_PYTHON_BASE_PARAMS >::type
   {};
 
   namespace detail
   {
 # ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
     template <class T> struct specifies_bases
+        : mpl::false_
     {
-        BOOST_STATIC_CONSTANT(bool, value = false);
     };
-    template < BOOST_PP_ENUM_PARAMS(BOOST_PYTHON_MAX_BASES, class B) >
-    struct specifies_bases< bases< BOOST_PP_ENUM_PARAMS(BOOST_PYTHON_MAX_BASES, B) > >
+    
+    template < BOOST_PP_ENUM_PARAMS_Z(1, BOOST_PYTHON_MAX_BASES, class Base) >
+    struct specifies_bases< bases< BOOST_PYTHON_BASE_PARAMS > >
+        : mpl::true_
     {
-        BOOST_STATIC_CONSTANT(bool, value = true);
     };
 # else
-    template < BOOST_PP_ENUM_PARAMS(BOOST_PYTHON_MAX_BASES, class B) >
-    static char is_bases_helper(bases< BOOST_PP_ENUM_PARAMS(BOOST_PYTHON_MAX_BASES, B) > const&);
+    template < BOOST_PP_ENUM_PARAMS(BOOST_PYTHON_MAX_BASES, class Base) >
+    static char is_bases_helper(bases< BOOST_PYTHON_BASE_PARAMS > const&);
     
     static char (& is_bases_helper(...) )[256];
 
-    template <class T> struct specifies_bases
+    template <class T>
+    struct specifies_bases
     {
      private:
         static typename add_reference<T>::type make();
         BOOST_STATIC_CONSTANT(bool, non_ref = !is_reference<T>::value);
      public:
         BOOST_STATIC_CONSTANT(bool, value = non_ref & (sizeof(is_bases_helper(make())) == 1));
+        typedef mpl::bool_<value> type;
     };
 # endif
     template <class T, class Prev = bases<> >
     struct select_bases
-        : mpl::if_c<
-                specifies_bases<T>::value
+        : mpl::if_<
+                specifies_bases<T>
                 , T
                 , Prev
           >
     {
     };
   }
+# undef BOOST_PYTHON_BASE_PARAMS
 }} // namespace boost::python
 
 #endif // BASES_DWA2002321_HPP

include/boost/python/borrowed.hpp

@@ -1,10 +1,11 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 BORROWED_DWA2002614_HPP
 # define BORROWED_DWA2002614_HPP
+
+# include <boost/python/detail/prefix.hpp>
 # include <boost/python/detail/borrowed_ptr.hpp>
 
 namespace boost { namespace python { 

include/boost/python/call.hpp

@@ -1,14 +1,15 @@
 #if !defined(BOOST_PP_IS_ITERATING)
 
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 CALL_DWA2002411_HPP
 #  define CALL_DWA2002411_HPP
 
+# include <boost/python/detail/prefix.hpp>
+
 #  include <boost/type.hpp>
 
 #  include <boost/python/converter/arg_to_python.hpp>
@@ -20,6 +21,8 @@
 #  include <boost/preprocessor/iterate.hpp>
 #  include <boost/preprocessor/repeat.hpp>
 #  include <boost/preprocessor/debug/line.hpp>
+#  include <boost/preprocessor/repetition/enum_trailing_params.hpp>
+#  include <boost/preprocessor/repetition/enum_binary_params.hpp>
 
 namespace boost { namespace python {
 
@@ -36,27 +39,39 @@ namespace boost { namespace python {
 # endif // CALL_DWA2002411_HPP
 
 #elif BOOST_PP_ITERATION_DEPTH() == 1
-# line BOOST_PP_LINE(__LINE__, call.hpp)
+# if !(BOOST_WORKAROUND(__MWERKS__, > 0x3100)                      \
+        && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201)))
+#  line BOOST_PP_LINE(__LINE__, call.hpp)
+# endif
 
 # define N BOOST_PP_ITERATION()
 
 template <
     class R
-    BOOST_PP_COMMA_IF(N) BOOST_PYTHON_UNARY_ENUM(N, class A)
+    BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, class A)
     >
 typename detail::returnable<R>::type
 call(PyObject* callable
-    BOOST_PP_COMMA_IF(N) BOOST_PYTHON_BINARY_ENUM(N, A, const& a)
+    BOOST_PP_COMMA_IF(N) BOOST_PP_ENUM_BINARY_PARAMS_Z(1, N, A, const& a)
     , boost::type<R>* = 0
     )
 {
-    converter::return_from_python<R> converter;
-    return converter(
+    PyObject* const result = 
         PyEval_CallFunction(
             callable
             , const_cast<char*>("(" BOOST_PP_REPEAT_1ST(N, BOOST_PYTHON_FIXED, "O") ")")
             BOOST_PP_REPEAT_1ST(N, BOOST_PYTHON_FAST_ARG_TO_PYTHON_GET, nil)
-            ));
+            );
+    
+    // This conversion *must not* be done in the same expression as
+    // the call, because, in the special case where the result is a
+    // reference a Python object which was created by converting a C++
+    // argument for passing to PyEval_CallFunction, its reference
+    // count will be 2 until the end of the full expression containing
+    // the conversion, and that interferes with dangling
+    // pointer/reference detection.
+    converter::return_from_python<R> converter;
+    return converter(result);
 }
 
 # undef N

include/boost/python/call_method.hpp

@@ -1,13 +1,14 @@
 #if !defined(BOOST_PP_IS_ITERATING)
 
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 CALL_METHOD_DWA2002411_HPP
 #  define CALL_METHOD_DWA2002411_HPP
 
+# include <boost/python/detail/prefix.hpp>
+
 #  include <boost/type.hpp>
 
 #  include <boost/python/converter/arg_to_python.hpp>
@@ -19,6 +20,8 @@
 #  include <boost/preprocessor/iterate.hpp>
 #  include <boost/preprocessor/repeat.hpp>
 #  include <boost/preprocessor/debug/line.hpp>
+#  include <boost/preprocessor/repetition/enum_trailing_params.hpp>
+#  include <boost/preprocessor/repetition/enum_binary_params.hpp>
 
 namespace boost { namespace python {
 
@@ -35,28 +38,40 @@ namespace boost { namespace python {
 # endif // CALL_METHOD_DWA2002411_HPP
 
 #elif BOOST_PP_ITERATION_DEPTH() == 1
-# line BOOST_PP_LINE(__LINE__, call_method.hpp)
+# if !(BOOST_WORKAROUND(__MWERKS__, > 0x3100)                      \
+        && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201)))
+#  line BOOST_PP_LINE(__LINE__, call_method.hpp)
+# endif 
 
 # define N BOOST_PP_ITERATION()
 
 template <
     class R
-    BOOST_PP_COMMA_IF(N) BOOST_PYTHON_UNARY_ENUM(N, class A)
+    BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, class A)
     >
 typename detail::returnable<R>::type
 call_method(PyObject* self, char const* name
-    BOOST_PP_COMMA_IF(N) BOOST_PYTHON_BINARY_ENUM(N, A, const& a)
+    BOOST_PP_COMMA_IF(N) BOOST_PP_ENUM_BINARY_PARAMS_Z(1, N, A, const& a)
     , boost::type<R>* = 0
     )
 {
-    converter::return_from_python<R> converter;
-    return converter(
+    PyObject* const result = 
         PyEval_CallMethod(
             self
             , const_cast<char*>(name)
             , const_cast<char*>("(" BOOST_PP_REPEAT_1ST(N, BOOST_PYTHON_FIXED, "O") ")")
             BOOST_PP_REPEAT_1ST(N, BOOST_PYTHON_FAST_ARG_TO_PYTHON_GET, nil)
-            ));
+            );
+    
+    // This conversion *must not* be done in the same expression as
+    // the call, because, in the special case where the result is a
+    // reference a Python object which was created by converting a C++
+    // argument for passing to PyEval_CallFunction, its reference
+    // count will be 2 until the end of the full expression containing
+    // the conversion, and that interferes with dangling
+    // pointer/reference detection.
+    converter::return_from_python<R> converter;
+    return converter(result);
 }
 
 # undef N

include/boost/python/callback.hpp

@@ -1,829 +0,0 @@
-//  (C) Copyright David Abrahams 2000. Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-//
-//  The author gratefully acknowleges the support of Dragon Systems, Inc., in
-//  producing this work.
-//
-//  This file was generated for 10-argument python callbacks by gen_callback.python
-
-#ifndef CALLBACK_DWA_052100_H_
-# define CALLBACK_DWA_052100_H_
-
-# include <boost/python/detail/config.hpp>
-# include <boost/python/conversions.hpp>
-
-namespace boost { namespace python {
-
-namespace detail {
-  template <class T>
-  inline void callback_adjust_refcount(PyObject*, type<T>) {}
-  
-  inline void callback_adjust_refcount(PyObject* p, type<PyObject*>)
-      { Py_INCREF(p); }
-}
-
-// Calling Python from C++
-template <class R>
-struct callback
-{
-    static R call_method(PyObject* self, const char* name)
-    {
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("()")));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    static R call(PyObject* self)
-    {
-        ref result(PyEval_CallFunction(self, const_cast<char*>("()")));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1>
-    static R call_method(PyObject* self, const char* name, const A1& a1)
-    {
-        ref p1(to_python(a1));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(O)"),
-                                     p1.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1>
-    static R call(PyObject* self, const A1& a1)
-    {
-        ref p1(to_python(a1));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(O)"),
-                                       p1.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2>
-    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OO)"),
-                                     p1.get(),
-                                     p2.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2>
-    static R call(PyObject* self, const A1& a1, const A2& a2)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OO)"),
-                                       p1.get(),
-                                       p2.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3>
-    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3>
-    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3, class A4>
-    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get(),
-                                     p4.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3, class A4>
-    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get(),
-                                       p4.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5>
-    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOOOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get(),
-                                     p4.get(),
-                                     p5.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5>
-    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get(),
-                                       p4.get(),
-                                       p5.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6>
-    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOOOOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get(),
-                                     p4.get(),
-                                     p5.get(),
-                                     p6.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6>
-    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get(),
-                                       p4.get(),
-                                       p5.get(),
-                                       p6.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOOOOOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get(),
-                                     p4.get(),
-                                     p5.get(),
-                                     p6.get(),
-                                     p7.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get(),
-                                       p4.get(),
-                                       p5.get(),
-                                       p6.get(),
-                                       p7.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref p8(to_python(a8));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOOOOOOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get(),
-                                     p4.get(),
-                                     p5.get(),
-                                     p6.get(),
-                                     p7.get(),
-                                     p8.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref p8(to_python(a8));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get(),
-                                       p4.get(),
-                                       p5.get(),
-                                       p6.get(),
-                                       p7.get(),
-                                       p8.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref p8(to_python(a8));
-        ref p9(to_python(a9));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOOOOOOOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get(),
-                                     p4.get(),
-                                     p5.get(),
-                                     p6.get(),
-                                     p7.get(),
-                                     p8.get(),
-                                     p9.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref p8(to_python(a8));
-        ref p9(to_python(a9));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get(),
-                                       p4.get(),
-                                       p5.get(),
-                                       p6.get(),
-                                       p7.get(),
-                                       p8.get(),
-                                       p9.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref p8(to_python(a8));
-        ref p9(to_python(a9));
-        ref p10(to_python(a10));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOOOOOOOOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get(),
-                                     p4.get(),
-                                     p5.get(),
-                                     p6.get(),
-                                     p7.get(),
-                                     p8.get(),
-                                     p9.get(),
-                                     p10.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref p8(to_python(a8));
-        ref p9(to_python(a9));
-        ref p10(to_python(a10));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get(),
-                                       p4.get(),
-                                       p5.get(),
-                                       p6.get(),
-                                       p7.get(),
-                                       p8.get(),
-                                       p9.get(),
-                                       p10.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-};
-
-// This specialization wouldn't be needed, but MSVC6 doesn't correctly allow the following:
-// void g();
-// void f() { return g(); }
-template <>
-struct callback<void>
-{
-
-    static void call_method(PyObject* self, const char* name)
-    {
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("()")));
-    }
-
-    static void call(PyObject* self)
-    {
-        ref result(PyEval_CallFunction(self, const_cast<char*>("()")));
-    }
-
-    template <class A1>
-    static void call_method(PyObject* self, const char* name, const A1& a1)
-    {
-        ref p1(to_python(a1));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(O)"),
-                                     p1.get()));
-    }
-
-    template <class A1>
-    static void call(PyObject* self, const A1& a1)
-    {
-        ref p1(to_python(a1));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(O)"),
-                                       p1.get()));
-    }
-
-    template <class A1, class A2>
-    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OO)"),
-                                     p1.get(),
-                                     p2.get()));
-    }
-
-    template <class A1, class A2>
-    static void call(PyObject* self, const A1& a1, const A2& a2)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OO)"),
-                                       p1.get(),
-                                       p2.get()));
-    }
-
-    template <class A1, class A2, class A3>
-    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get()));
-    }
-
-    template <class A1, class A2, class A3>
-    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get()));
-    }
-
-    template <class A1, class A2, class A3, class A4>
-    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get(),
-                                     p4.get()));
-    }
-
-    template <class A1, class A2, class A3, class A4>
-    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get(),
-                                       p4.get()));
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5>
-    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOOOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get(),
-                                     p4.get(),
-                                     p5.get()));
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5>
-    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get(),
-                                       p4.get(),
-                                       p5.get()));
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6>
-    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOOOOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get(),
-                                     p4.get(),
-                                     p5.get(),
-                                     p6.get()));
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6>
-    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get(),
-                                       p4.get(),
-                                       p5.get(),
-                                       p6.get()));
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOOOOOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get(),
-                                     p4.get(),
-                                     p5.get(),
-                                     p6.get(),
-                                     p7.get()));
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get(),
-                                       p4.get(),
-                                       p5.get(),
-                                       p6.get(),
-                                       p7.get()));
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref p8(to_python(a8));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOOOOOOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get(),
-                                     p4.get(),
-                                     p5.get(),
-                                     p6.get(),
-                                     p7.get(),
-                                     p8.get()));
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref p8(to_python(a8));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get(),
-                                       p4.get(),
-                                       p5.get(),
-                                       p6.get(),
-                                       p7.get(),
-                                       p8.get()));
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref p8(to_python(a8));
-        ref p9(to_python(a9));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOOOOOOOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get(),
-                                     p4.get(),
-                                     p5.get(),
-                                     p6.get(),
-                                     p7.get(),
-                                     p8.get(),
-                                     p9.get()));
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref p8(to_python(a8));
-        ref p9(to_python(a9));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get(),
-                                       p4.get(),
-                                       p5.get(),
-                                       p6.get(),
-                                       p7.get(),
-                                       p8.get(),
-                                       p9.get()));
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref p8(to_python(a8));
-        ref p9(to_python(a9));
-        ref p10(to_python(a10));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOOOOOOOOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get(),
-                                     p4.get(),
-                                     p5.get(),
-                                     p6.get(),
-                                     p7.get(),
-                                     p8.get(),
-                                     p9.get(),
-                                     p10.get()));
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref p8(to_python(a8));
-        ref p9(to_python(a9));
-        ref p10(to_python(a10));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get(),
-                                       p4.get(),
-                                       p5.get(),
-                                       p6.get(),
-                                       p7.get(),
-                                       p8.get(),
-                                       p9.get(),
-                                       p10.get()));
-    }
-};
-
-// Make it a compile-time error to try to return a const char* from a virtual
-// function. The standard conversion
-//
-//      from_python(PyObject* string, boost::python::type<const char*>)
-//
-// returns a pointer to the character array which is internal to string. The
-// problem with trying to do this in a standard callback function is that the
-// Python string would likely be destroyed upon return from the calling function
-// (boost::python::callback<const char*>::call[_method]) when its reference count is
-// decremented. If you absolutely need to do this and you're sure it's safe (it
-// usually isn't), you can use
-//
-//      boost::python::string result(boost::python::callback<boost::python::string>::call[_method](...args...));
-//      ...result.c_str()... // access the char* array
-template <>
-struct callback<const char*>
-{
-    // Try hard to generate a readable error message
-    typedef struct unsafe_since_python_string_may_be_destroyed {} call, call_method;
-};
-
-}} // namespace boost::python
-
-#endif // CALLBACK_DWA_052100_H_

include/boost/python/cast.hpp

@@ -1,12 +1,12 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 CAST_DWA200269_HPP
 # define CAST_DWA200269_HPP
 
-# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/detail/prefix.hpp>
+
 # include <boost/type_traits/same_traits.hpp>
 # include <boost/type_traits/cv_traits.hpp>
 # include <boost/type.hpp>
@@ -78,7 +78,7 @@ namespace detail
   {
       typedef typename add_cv<Source>::type src_t;
       typedef typename add_cv<Target>::type target_t;
-      static bool const same = is_same<src_t,target_t>::value;
+      bool const same = is_same<src_t,target_t>::value;
       
       return detail::upcaster<same>::execute(x, (Target*)0);
   }

include/boost/python/class.hpp

@@ -1,43 +1,68 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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/bases.hpp>
-# include <boost/python/args.hpp>
 
 # include <boost/python/object.hpp>
-
 # include <boost/python/type_id.hpp>
-# include <boost/python/detail/member_function_cast.hpp>
-# include <boost/python/object/class_converters.hpp>
-# include <boost/type_traits/ice.hpp>
-# include <boost/type_traits/same_traits.hpp>
-# include <boost/mpl/size.hpp>
-# include <boost/mpl/for_each.hpp>
-# include <boost/mpl/bool_c.hpp>
-# include <boost/python/object/select_holder.hpp>
-# include <boost/python/object/class_wrapper.hpp>
-# include <boost/python/object/make_instance.hpp>
 # include <boost/python/data_members.hpp>
-# include <boost/utility.hpp>
-# include <boost/python/detail/operator_id.hpp>
-# include <boost/python/object/pickle_support.hpp>
 # include <boost/python/make_function.hpp>
-# include <boost/python/object/add_to_namespace.hpp>
-# include <boost/python/detail/def_helper.hpp>
-# include <boost/python/detail/force_instantiate.hpp>
-# include <boost/python/detail/defaults_def.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
@@ -57,79 +82,101 @@ namespace detail
       type_info** p;
   };
 
-  template <class T, class Prev = detail::not_specified>
-  struct select_held_type;
-
-  template <class T1, class T2, class T3>
-  struct has_noncopyable;
-
-  template <detail::operator_id, class L, class R>
-  struct operator_;
-
-  // Register a to_python converter for a class T, depending on the
-  // type of the first (tag) argument. The 2nd argument is a pointer
-  // to the type of holder that must be created. The 3rd argument is a
-  // reference to the Python type object to be created.
-  template <class T, class SelectHolder>
-  static inline void register_copy_constructor(mpl::bool_c<true> const&, SelectHolder const& , T* = 0)
+  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
   {
-      typedef typename SelectHolder::type holder;
-      force_instantiate(objects::class_wrapper<T,holder, objects::make_instance<T,holder> >());
-      SelectHolder::register_();
-  }
+    //
+    // 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; };
 
-  // Tag dispatched to have no effect.
-  template <class T, class SelectHolder>
-  static inline void register_copy_constructor(mpl::bool_c<false> const&, SelectHolder const&, T* = 0)
-  {
-      SelectHolder::register_();
-  }
+    template <class C>
+    struct assertion
+        : mpl::if_<C, assertion_ok<C>, assertion_failed<C> >::type
+    {};
 
-  template <class T> int assert_default_constructible(T const&);
+    //
+    // 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());
+        }
+    };
+  }
 }
 
-//
-// class_<T,Bases,HolderGenerator>
-//
-//      This is the primary mechanism through which users will expose
-//      C++ classes to Python. The three template arguments are:
-//
+// This is the primary mechanism through which users will expose
+// C++ classes to Python.
 template <
-    class T // class being wrapped
+    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
-   typedef objects::class_base base;
-
-    typedef class_<T,X1,X2,X3> self;
-    BOOST_STATIC_CONSTANT(bool, is_copyable = (!detail::has_noncopyable<X1,X2,X3>::value));
-
-    typedef typename detail::select_held_type<
-        X1, typename detail::select_held_type<
-        X2, typename detail::select_held_type<
-        X3
-    >::type>::type>::type held_type;
-
-    typedef objects::select_holder<T,held_type> holder_selector;
-
-    typedef typename detail::select_bases<X1
-            , typename detail::select_bases<X2
-              , typename boost::python::detail::select_bases<X3>::type
-              >::type
-            >::type bases;
 
     // 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] = type_id<T>();
+            ids[0] = detail::unwrap_type_id((W*)0, (W*)0);
 
             // Write the rest of the elements into succeeding positions.
             type_info* p = ids + 1;
@@ -142,120 +189,87 @@ class class_ : public objects::class_base
     };
     friend struct id_vector;
 
- public:
-    // Automatically derive the class name - only works on some
-    // compilers because type_info::name is sometimes mangled (gcc)
-//    class_();           // With default-constructor init function
-//    class_(no_init_t);  // With no init function
-
-    // Construct with the class name, with or without docstring, and default init() function
+ 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 no init() function
+    // Construct with class name, no docstring, and an uncallable __init__ function
     class_(char const* name, no_init_t);
 
-    // Construct with class name, docstring, and no init() function
+    // 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->register_();
-        define_init(*this, i.derived());
-        this->set_instance_size(holder_selector::additional_size());
+        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->register_();
-        define_init(*this, i.derived());
-        this->set_instance_size(holder_selector::additional_size());
+        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, or a callable
-    // python object.
+    // 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(name, f, default_call_policies(), 0, &f);
+        this->def_impl(
+            detail::unwrap_wrapper((W*)0)
+          , name, f, detail::def_helper<char const*>(0), &f);
         return *this;
     }
 
-    template <class DerivedT>
-    self& def(init_base<DerivedT> const& i)
+    template <class A1, class A2>
+    self& def(char const* name, A1 a1, A2 const& a2)
     {
-        define_init(*this, i.derived());
+        this->def_maybe_overloads(name, a1, a2, &a2);
         return *this;
     }
 
-    template <class Arg1T, class Arg2T>
-    self& def(char const* name, Arg1T arg1, Arg2T const& arg2)
-    {
-        //  The arguments may be:
-        //      def(name, function)
-        //      def(name, function, policy)
-        //      def(name, function, doc_string)
-        //      def(name, signature, stubs)
-
-        dispatch_def(&arg2, name, arg1, arg2);
-        return *this;
-    }
-
-    template <class Arg1T, class Arg2T, class Arg3T>
-    self& def(char const* name, Arg1T arg1, Arg2T const& arg2, Arg3T const& arg3)
+    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)
 
-        dispatch_def(&arg2, name, arg1, arg2, arg3);
+        this->def_impl(
+            detail::unwrap_wrapper((W*)0)
+          , name, fn
+          , detail::def_helper<A1,A2>(a1,a2)
+          , &fn);
+
         return *this;
     }
 
-    template <detail::operator_id id, class L, class R>
-    self& def(detail::operator_<id,L,R> const& op)
+    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)
     {
-        typedef detail::operator_<id,L,R> op_t;
-        return this->def(op.name(), &op_t::template apply<T>::execute);
-    }
+        this->def_impl(
+            detail::unwrap_wrapper((W*)0)
+          , name, fn
+          , detail::def_helper<A1,A2,A3>(a1,a2,a3)
+          , &fn);
 
-    // Define the constructor with the given Args, which should be an
-    // MPL sequence of types.
-    template <class Args>
-    self& def_init(Args const&)
-    {
-        return this->def("__init__",
-            python::make_constructor<Args>(
-                // Using runtime type selection works around a CWPro7 bug.
-                holder_selector::execute((held_type*)0).get()
-                )
-            );
-    }
-
-    template <class Args, class CallPolicyOrDoc>
-    self& def_init(Args const&, CallPolicyOrDoc const& policy_or_doc, char const* doc = 0)
-    {
-        typedef detail::def_helper<CallPolicyOrDoc> helper;
-
-        return this->def(
-            "__init__",
-            python::make_constructor<Args>(
-                helper::get_policy(policy_or_doc)
-                // Using runtime type selection works around a CWPro7 bug.
-                , holder_selector::execute((held_type*)0).get()
-                )
-            , helper::get_doc(policy_or_doc, doc)
-            );
-    }
-
-    // Define the default constructor.
-    self& def_init()
-    {
-        this->def_init(mpl::list0<>::type());
         return *this;
     }
 
@@ -263,33 +277,101 @@ class class_ : public objects::class_base
     // Data member access
     //
     template <class D>
-    self& def_readonly(char const* name, D T::*pm)
+    self& def_readonly(char const* name, D const& d, char const* doc=0)
     {
-        this->add_property(name, make_getter(pm));
-        return *this;
+        return this->def_readonly_impl(name, d, doc BOOST_PYTHON_DATA_MEMBER_HELPER(D));
     }
 
     template <class D>
-    self& def_readwrite(char const* name, D T::*pm)
+    self& def_readwrite(char const* name, D const& d, char const* doc=0)
     {
-        return this->add_property(name, make_getter(pm), make_setter(pm));
+        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 const& fget)
+    self& add_property(char const* name, Get fget, char const* docstr = 0)
     {
-        base::add_property(name, object(fget));
+        base::add_property(name, this->make_getter(fget), docstr);
         return *this;
     }
 
     template <class Get, class Set>
-    self& add_property(char const* name, Get const& fget, Set const& fset)
+    self& add_property(char const* name, Get fget, Set fset, char const* docstr = 0)
     {
-        base::add_property(name, object(fget), object(fset));
+        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)
     {
@@ -311,140 +393,262 @@ class class_ : public objects::class_base
       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
 
-    template <class Fn, class Policies>
-    inline void def_impl(char const* name, Fn fn, Policies const& policies
-                         , char const* doc, ...)
+    // 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(
-                    // This bit of nastiness casts F to a member function of T if possible.
-                detail::member_function_cast<T,Fn>::stage1(fn).stage2((T*)0).stage3(fn)
-                , policies)
-            , doc);
+                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*)
 
-    template <class F>
-    inline void def_impl(char const* name, F f, default_call_policies const&
-                         , char const* doc, object const*)
-    {
-        objects::add_to_namespace(*this, name, f, doc);
-    }
-
-    inline void register_() const;
-
-    template <class StubsT, class SigT>
-    void dispatch_def(
-        detail::overloads_base const*,
-        char const* name,
-        SigT sig,
-        StubsT const& stubs)
     {
         //  convert sig to a type_list (see detail::get_signature in signature.hpp)
         //  before calling detail::define_with_defaults.
         detail::define_with_defaults(
-            name, stubs, *this, detail::get_signature(sig));
+            name, overloads, *this, detail::get_signature(sig));
     }
 
-    template <class Fn, class CallPolicyOrDoc>
-    void dispatch_def(
-        void const*,
-        char const* name,
-        Fn fn,
-        CallPolicyOrDoc const& policy_or_doc)
+    template <class Fn, class A1>
+    void def_maybe_overloads(
+        char const* name
+        , Fn fn
+        , A1 const& a1
+        , ...)
     {
-        typedef detail::def_helper<CallPolicyOrDoc> helper;
         this->def_impl(
-            name, fn, helper::get_policy(policy_or_doc),
-            helper::get_doc(policy_or_doc, 0), &fn);
+            detail::unwrap_wrapper((W*)0)
+          , name
+          , fn
+          , detail::def_helper<A1>(a1)
+          , &fn
+        );
 
     }
-
-    template <class Fn, class CallPolicyOrDoc1, class CallPolicyOrDoc2>
-    void dispatch_def(
-        void const*,
-        char const* name,
-        Fn fn,
-        CallPolicyOrDoc1 const& policy_or_doc1,
-        CallPolicyOrDoc2 const& policy_or_doc2)
-    {
-        typedef detail::def_helper<CallPolicyOrDoc1> helper;
-
-        this->def_impl(
-            name, fn, helper::get_policy(policy_or_doc1, policy_or_doc2),
-            helper::get_doc(policy_or_doc1, policy_or_doc2), &fn);
-    }
+    // }
 };
 
 
 //
 // implementations
 //
-        // register converters
-template <class T, class X1, class X2, class X3>
-inline void class_<T,X1,X2,X3>::register_() const
-{
-    objects::register_class_from_python<T,bases>();
 
-    detail::register_copy_constructor<T>(
-        mpl::bool_c<is_copyable>()
-        , holder_selector::execute((held_type*)0)
-        );
-}
-
-template <class T, class X1, class X2, class X3>
-inline class_<T,X1,X2,X3>::class_(char const* name, char const* doc)
+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->register_();
-    detail::force_instantiate(sizeof(detail::assert_default_constructible(T())));
-    this->def_init();
-    this->set_instance_size(holder_selector::additional_size());
+    this->initialize(init<>());
+//  select_holder::assert_default_constructible();
 }
 
-template <class T, class X1, class X2, class X3>
-inline class_<T,X1,X2,X3>::class_(char const* name, no_init_t)
+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->register_();
-    this->def_no_init();
+    this->initialize(no_init);
 }
 
-template <class T, class X1, class X2, class X3>
-inline class_<T,X1,X2,X3>::class_(char const* name, char const* doc, no_init_t)
+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->register_();
-    this->def_no_init();
-}
-
-namespace detail
-{
-  template <class T1, class T2, class T3>
-  struct has_noncopyable
-      : type_traits::ice_or<
-        is_same<T1,noncopyable>::value
-      , is_same<T2,noncopyable>::value
-      , is_same<T3,noncopyable>::value>
-  {};
-
-
-    template <class T, class Prev>
-    struct select_held_type
-        : mpl::if_c<
-            type_traits::ice_or<
-                 specifies_bases<T>::value
-               , is_same<T,noncopyable>::value
-            >::value
-            , Prev
-            , T
-          >
-    {
-    };
+    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

include/boost/python/class_builder.hpp

@@ -1,182 +0,0 @@
-// Revision History:
-// Mar 03 01  added: pickle safety measures (Ralf W. Grosse-Kunstleve)
-
-#ifndef CLASS_WRAPPER_DWA101000_H_
-# define CLASS_WRAPPER_DWA101000_H_
-
-#include <boost/python/detail/extension_class.hpp>
-#include <boost/python/operators.hpp>
-#include <boost/python/module_builder.hpp>
-#include <boost/python/conversions.hpp>
-#include <boost/python/detail/cast.hpp>
-#include <boost/python/reference.hpp>
-
-namespace boost { namespace python {
-
-// Syntactic sugar to make wrapping classes more convenient
-template <class T, class U = detail::held_instance<T> >
-class class_builder
-    : python_extension_class_converters<T, U> // Works around MSVC6.x/GCC2.95.2 bug described below
-{
- public:
-    class_builder(module_builder& module, const char* name)
-        : m_class(new detail::extension_class<T, U>(name))
-    {
-        module.add(ref(as_object(m_class.get()), ref::increment_count), name);
-    }
-    
-  template <class OtherT, class OtherU>
-    class_builder(class_builder<OtherT, OtherU>& cls, const char* name)
-        : m_class(new detail::extension_class<T, U>(name))
-    {
-        cls.add(ref(as_object(m_class.get()), ref::increment_count), name);
-    }
-    
-  template <class OtherT, class OtherU>
-    class_builder(detail::extension_class<OtherT, OtherU>* cls,
-                  const char* name)
-        : m_class(new detail::extension_class<T, U>(name))
-    {
-        cls->set_attribute(name,
-                           ref(as_object(m_class.get()), ref::increment_count));
-    }
-    
-    ~class_builder()
-    {}
-
-    inline void dict_defines_state() {
-      add(ref(BOOST_PYTHON_CONVERSION::to_python(1)), "__dict_defines_state__");
-    }
-    inline void getstate_manages_dict() {
-      add(ref(BOOST_PYTHON_CONVERSION::to_python(1)), "__getstate_manages_dict__");
-    }
-    
-    // define constructors
-    template <class signature>
-    void def(const signature& s)
-        { m_class->def(s); }
-
-    // export heterogeneous reverse-argument operators 
-    // (type of lhs: 'left', of rhs: 'right')
-    // usage:  foo_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub), Foo>(),
-    //                       boost::python::left_operand<int const &>());
-    template <long which, class left, class right>
-    void def(operators<which, right> o1, left_operand<left> o2)
-        { m_class->def(o1, o2); }
-
-    // export heterogeneous operators (type of lhs: 'left', of rhs: 'right')
-    // usage:  foo_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub), Foo>(),
-    //                       boost::python::right_operand<int const &>());
-    template <long which, class left, class right>
-    void def(operators<which, left> o1, right_operand<right> o2)
-        { m_class->def(o1, o2); }
-
-    // define a function that passes Python arguments and keywords
-    // to C++ verbatim (as a 'tuple const &' and 'dictionary const &' 
-    // respectively). This is useful for manual argument passing.
-    // It's also the only possibility to pass keyword arguments to C++.
-    // Fn must have a signatur that is compatible to 
-    //     PyObject * (*)(PyObject * aTuple, PyObject * aDictionary)
-    template <class Fn>
-    void def_raw(Fn fn, const char* name)
-        { m_class->def_raw(fn, name); }
-
-    // define member functions. In fact this works for free functions, too -
-    // they act like static member functions, or if they start with the
-    // appropriate self argument (as a pointer or reference), they can be used
-    // just like ordinary member functions -- just like Python!
-    template <class Fn>
-    void def(Fn fn, const char* name)
-        { m_class->def(fn, name); }
-
-    // Define a virtual member function with a default implementation.
-    // default_fn should be a function which provides the default implementation.
-    // Be careful that default_fn does not in fact call fn virtually!
-    template <class Fn, class DefaultFn>
-    void def(Fn fn, const char* name, DefaultFn default_fn)
-        { m_class->def(fn, name, default_fn); }
-
-    // Provide a function which implements x.<name>, reading from the given
-    // member (pm) of the T obj
-    template <class MemberType>
-    void def_getter(MemberType T::*pm, const char* name)
-        { m_class->def_getter(pm, name); }
-    
-    // Provide a function which implements assignment to x.<name>, writing to
-    // the given member (pm) of the T obj
-    template <class MemberType>
-    void def_setter(MemberType T::*pm, const char* name)
-        { m_class->def_getter(pm, name); }
-    
-    // Expose the given member (pm) of the T obj as a read-only attribute
-    template <class MemberType>
-    void def_readonly(MemberType T::*pm, const char* name)
-        { m_class->def_readonly(pm, name); }
-    
-    // Expose the given member (pm) of the T obj as a read/write attribute
-    template <class MemberType>
-    void def_read_write(MemberType T::*pm, const char* name)
-        { m_class->def_read_write(pm, name); }
-        
-    // define the standard coercion needed for operator overloading
-    void def_standard_coerce()
-        { m_class->def_standard_coerce(); }
-    
-    // declare the given class a base class of this one and register 
-    // conversion functions
-    template <class S, class V>
-    void declare_base(class_builder<S, V> const & base)
-    {
-        m_class->declare_base(base.get_extension_class());
-    }
-
-    // declare the given class a base class of this one and register 
-    // upcast conversion function
-    template <class S, class V>
-    void declare_base(class_builder<S, V> const & base, without_downcast_t)
-    {
-        m_class->declare_base(base.get_extension_class(), without_downcast);
-    }
-
-    // get the embedded ExtensioClass object
-    detail::extension_class<T, U> * get_extension_class() const 
-    {
-        return m_class.get();
-    }
-
-    // set an arbitrary attribute. Useful for non-function class data members,
-    // e.g. enums
-    void add(PyObject* x, const char* name)
-        { m_class->set_attribute(name, x); }
-    void add(ref x, const char* name)
-        { m_class->set_attribute(name, x); }
- private:
-    // declare the given class a base class of this one and register 
-    // conversion functions
-    template <class S, class V>
-    void declare_base(detail::extension_class<S, V> * base)
-    {
-        m_class->declare_base(base);
-    }
-        
-    // declare the given class a base class of this one and register 
-    // upcast conversion function
-    template <class S, class V>
-    void declare_base(detail::extension_class<S, V> * base, without_downcast_t)
-    {
-        m_class->declare_base(base, without_downcast);
-    }
-    
-    reference<detail::extension_class<T, U> > m_class;
-};
-
-// The bug mentioned at the top of this file is that on certain compilers static
-// global functions declared within the body of a class template will only be
-// generated when the class template is constructed, and when (for some reason)
-// the construction does not occur via a new-expression. Otherwise, we could
-// rely on the initialization of the m_class data member to cause all of the
-// to_/from_python functions to come into being.
-
-}} // namespace boost::python
-
-#endif // CLASS_WRAPPER_DWA101000_H_

include/boost/python/class_fwd.hpp

@@ -1,21 +1,15 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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_FWD_DWA200222_HPP
 # define CLASS_FWD_DWA200222_HPP
+
+# include <boost/python/detail/prefix.hpp>
 # include <boost/python/detail/not_specified.hpp>
-# include <boost/python/args.hpp>
-# include <boost/python/bases.hpp>
 
 namespace boost { namespace python { 
 
-namespace detail
-{
-  struct empty_list;
-}
-
 template <
     class T // class being wrapped
     // arbitrarily-ordered optional arguments. Full qualification needed for MSVC6

include/boost/python/classes.hpp

@@ -1,677 +0,0 @@
-//  (C) Copyright David Abrahams 2000. Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-//
-//  The author gratefully acknowleges the support of Dragon Systems, Inc., in
-//  producing this work.
-
-#ifndef SUBCLASS_DWA051500_H_
-# define SUBCLASS_DWA051500_H_
-
-# include <boost/python/detail/config.hpp>
-# include <boost/python/detail/types.hpp>
-# include <boost/python/objects.hpp>
-# include <boost/python/detail/singleton.hpp>
-# include <boost/utility.hpp>
-# include <boost/python/conversions.hpp>
-# include <boost/python/callback.hpp>
-
-namespace boost { namespace python {
-
-// A simple type which acts something like a built-in Python class obj.
-class BOOST_PYTHON_DECL instance
-    : public boost::python::detail::python_object
-{
- public:
-    instance(PyTypeObject* class_);
-    ~instance();
-
-    // Standard Python functions.
-    PyObject* repr();
-    int compare(PyObject*);
-    PyObject* str();
-    long hash();
-    PyObject* call(PyObject* args, PyObject* keywords);
-    PyObject* getattr(const char* name, bool use_special_function = true);
-    int setattr(const char* name, PyObject* value);
-
-    // Mapping methods
-    int length();
-    PyObject* get_subscript(PyObject* key);
-    void set_subscript(PyObject* key, PyObject* value);
-
-    // Sequence methods
-    PyObject* get_slice(int start, int finish);
-    void set_slice(int start, int finish, PyObject* value);
-
-    // Number methods
-    PyObject* add(PyObject* other);
-    PyObject* subtract(PyObject* other);
-    PyObject* multiply(PyObject* other);
-    PyObject* divide(PyObject* other);
-    PyObject* remainder(PyObject* other);
-    PyObject* divmod(PyObject* other);
-    PyObject* power(PyObject*, PyObject*);
-    PyObject* negative();
-    PyObject* positive();
-    PyObject* absolute();
-    int nonzero();
-    PyObject* invert();
-    PyObject* lshift(PyObject* other);
-    PyObject* rshift(PyObject* other);
-    PyObject* do_and(PyObject* other);
-    PyObject* do_xor(PyObject* other);
-    PyObject* do_or(PyObject* other);
-    int coerce(PyObject**, PyObject**);
-    PyObject* as_int();
-    PyObject* as_long();
-    PyObject* as_float();
-    PyObject* oct();
-    PyObject* hex();
-
-    // Rich comparisons
-    PyObject* lt(PyObject* other);
-    PyObject* le(PyObject* other);
-    PyObject* eq(PyObject* other);
-    PyObject* ne(PyObject* other);
-    PyObject* gt(PyObject* other);
-    PyObject* ge(PyObject* other);
-
-    // Inplace operations.
-    PyObject* inplace_add(PyObject* other);
-    PyObject* inplace_subtract(PyObject* other);
-    PyObject* inplace_multiply(PyObject* other);
-    PyObject* inplace_divide(PyObject* other);
-    PyObject* inplace_remainder(PyObject* other);
-    PyObject* inplace_power(PyObject* exponent, PyObject* modulus);
-    PyObject* inplace_lshift(PyObject* other);
-    PyObject* inplace_rshift(PyObject* other);
-    PyObject* inplace_and(PyObject* other);
-    PyObject* inplace_or(PyObject* other);
-    PyObject* inplace_xor(PyObject* other);
-
- private: // noncopyable, without the size bloat
-    instance(const instance&);
-    void operator=(const instance&);
-
- private: // helper functions
-    int setattr_dict(PyObject* value);
-    
- private:
-    dictionary m_name_space;
-};
-
-template <class T> class meta_class;
-
-namespace detail {
-  class BOOST_PYTHON_DECL class_base : public type_object_base
-  {
-   public:
-      class_base(PyTypeObject* meta_class_obj, string name, tuple bases, const dictionary& name_space);
-      tuple bases() const;
-      string name() const;
-      dictionary& dict();
-      
-      // Standard Python functions.
-      PyObject* getattr(const char* name);
-      int setattr(const char* name, PyObject* value);
-      PyObject* repr() const;
-      void add_base(ref base);
-
-   protected:
-      bool initialize_instance(instance* obj, PyObject* args, PyObject* keywords);
-
-   private: // virtual functions
-      // Subclasses should override this to delete the particular obj type
-      virtual void delete_instance(PyObject*) const = 0;
-
-   private: // boost::python::type_object_base required interface implementation
-      void instance_dealloc(PyObject*) const; // subclasses should not override this
-    
-   private: // noncopyable, without the size bloat
-      class_base(const class_base&);
-      void operator=(const class_base&);
-      
-   private:
-      string m_name;
-      tuple m_bases;
-      dictionary m_name_space;
-  };
-
-  void enable_named_method(class_base* type_obj, const char* name);
-}
-
-// A type which acts a lot like a built-in Python class. T is the obj type,
-// so class_t<instance> is a very simple "class-alike".
-template <class T>
-class class_t : public boost::python::detail::class_base
-{
- public:
-    class_t(meta_class<T>* meta_class_obj, string name, tuple bases, const dictionary& name_space);
-    ~class_t();
-    
-    // Standard Python functions.
-    PyObject* call(PyObject* args, PyObject* keywords);
-    
- private: // Implement mapping methods on instances
-    PyObject* instance_repr(PyObject*) const;
-    int instance_compare(PyObject*, PyObject* other) const;
-    PyObject* instance_str(PyObject*) const;
-    long instance_hash(PyObject*) const;
-    int instance_mapping_length(PyObject*) const;
-    PyObject* instance_mapping_subscript(PyObject*, PyObject*) const;
-    int instance_mapping_ass_subscript(PyObject*, PyObject*, PyObject*) const;
-
- private: // Implement sequence methods on instances
-    int instance_sequence_length(PyObject*) const;
-    PyObject* instance_sequence_item(PyObject* obj, int n) const;
-    int instance_sequence_ass_item(PyObject* obj, int n, PyObject* value) const;
-    PyObject* instance_sequence_slice(PyObject*, int start, int finish) const;
-    int instance_sequence_ass_slice(PyObject*, int start, int finish, PyObject* value) const;
-
- private: // Implement number methods on instances
-    PyObject* instance_number_add(PyObject*, PyObject*) const;
-    PyObject* instance_number_subtract(PyObject*, PyObject*) const;
-    PyObject* instance_number_multiply(PyObject*, PyObject*) const;
-    PyObject* instance_number_divide(PyObject*, PyObject*) const;
-    PyObject* instance_number_remainder(PyObject*, PyObject*) const;
-    PyObject* instance_number_divmod(PyObject*, PyObject*) const;
-    PyObject* instance_number_power(PyObject*, PyObject*, PyObject*) const;
-    PyObject* instance_number_negative(PyObject*) const;
-    PyObject* instance_number_positive(PyObject*) const;
-    PyObject* instance_number_absolute(PyObject*) const;
-    int instance_number_nonzero(PyObject*) const;
-    PyObject* instance_number_invert(PyObject*) const;
-    PyObject* instance_number_lshift(PyObject*, PyObject*) const;
-    PyObject* instance_number_rshift(PyObject*, PyObject*) const;
-    PyObject* instance_number_and(PyObject*, PyObject*) const;
-    PyObject* instance_number_xor(PyObject*, PyObject*) const;
-    PyObject* instance_number_or(PyObject*, PyObject*) const;
-    int instance_number_coerce(PyObject*, PyObject**, PyObject**) const;
-    PyObject* instance_number_int(PyObject*) const;
-    PyObject* instance_number_long(PyObject*) const;
-    PyObject* instance_number_float(PyObject*) const;
-    PyObject* instance_number_oct(PyObject*) const;
-    PyObject* instance_number_hex(PyObject*) const;
-
-    PyObject* instance_number_inplace_add(PyObject*, PyObject*) const;
-    PyObject* instance_number_inplace_subtract(PyObject*, PyObject*) const;
-    PyObject* instance_number_inplace_multiply(PyObject*, PyObject*) const;
-    PyObject* instance_number_inplace_divide(PyObject*, PyObject*) const;
-    PyObject* instance_number_inplace_remainder(PyObject*, PyObject*) const;
-    PyObject* instance_number_inplace_power(PyObject*, PyObject*, PyObject*) const;
-    PyObject* instance_number_inplace_lshift(PyObject*, PyObject*) const;
-    PyObject* instance_number_inplace_rshift(PyObject*, PyObject*) const;
-    PyObject* instance_number_inplace_and(PyObject*, PyObject*) const;
-    PyObject* instance_number_inplace_or(PyObject*, PyObject*) const;
-    PyObject* instance_number_inplace_xor(PyObject*, PyObject*) const;
-
- private: // Implement rich comparisons
-    PyObject* instance_lt(PyObject*, PyObject*) const;
-    PyObject* instance_le(PyObject*, PyObject*) const;
-    PyObject* instance_eq(PyObject*, PyObject*) const;
-    PyObject* instance_ne(PyObject*, PyObject*) const;
-    PyObject* instance_gt(PyObject*, PyObject*) const;
-    PyObject* instance_ge(PyObject*, PyObject*) const;
-    
- private: // Miscellaneous "special" methods
-    PyObject* instance_call(PyObject* obj, PyObject* args, PyObject* keywords) const;
-    PyObject* instance_getattr(PyObject* obj, const char* name) const;
-    int instance_setattr(PyObject* obj, const char* name, PyObject* value) const;
-
- private: // Implementation of boost::python::detail::class_base required interface
-    void delete_instance(PyObject*) const;
-};
-
-// The type of a class_t<T> object.
-template <class T>
-class meta_class
-    : public boost::python::detail::reprable<
-                boost::python::detail::callable<
-                   boost::python::detail::getattrable<
-                      boost::python::detail::setattrable<
-                         boost::python::detail::type_object<class_t<T> > > > > >,
-      private boost::noncopyable
-{
- public:
-    meta_class();
-
-    // Standard Python functions.
-    PyObject* call(PyObject* args, PyObject* keywords);
-    
-    struct type_object
-        : boost::python::detail::singleton<type_object,
-             boost::python::detail::callable<
-                boost::python::detail::type_object<meta_class> > >
-    {
-        type_object() : singleton_base(&PyType_Type) {}
-    };
-};
-
-//
-// Member function implementations.
-//
-template <class T>
-meta_class<T>::meta_class()
-    : properties(type_object::instance())
-{
-} 
-
-template <class T>
-class_t<T>::class_t(meta_class<T>* meta_class_obj, string name, tuple bases, const dictionary& name_space)
-    : boost::python::detail::class_base(meta_class_obj, name, bases, name_space)
-{
-}
-
-template <class T>
-class_t<T>::~class_t()
-{
-}
-
-template <class T>
-void class_t<T>::delete_instance(PyObject* obj) const
-{
-    delete downcast<T>(obj);
-}
-
-template <class T>
-PyObject* class_t<T>::call(PyObject* args, PyObject* keywords)
-{
-    reference<T> result(new T(this));
-    if (!this->initialize_instance(result.get(), args, keywords))
-        return 0;
-    else
-        return result.release();
-}
-
-template <class T>
-PyObject* class_t<T>::instance_repr(PyObject* obj) const
-{
-    return downcast<T>(obj)->repr();
-}
-
-template <class T>
-int class_t<T>::instance_compare(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->compare(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_str(PyObject* obj) const
-{
-    return downcast<T>(obj)->str();
-}
-
-template <class T>
-long class_t<T>::instance_hash(PyObject* obj) const
-{
-    return downcast<T>(obj)->hash();
-}
-
-template <class T>
-int class_t<T>::instance_mapping_length(PyObject* obj) const
-{
-    return downcast<T>(obj)->length();
-}
-
-template <class T>
-int class_t<T>::instance_sequence_length(PyObject* obj) const
-{
-    return downcast<T>(obj)->length();
-}
-
-template <class T>
-PyObject* class_t<T>::instance_mapping_subscript(PyObject* obj, PyObject* key) const
-{
-    return downcast<T>(obj)->get_subscript(key);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_sequence_item(PyObject* obj, int n) const
-{
-    ref key(to_python(n));
-    return downcast<T>(obj)->get_subscript(key.get());
-}
-
-template <class T>
-int class_t<T>::instance_sequence_ass_item(PyObject* obj, int n, PyObject* value) const
-{
-    ref key(to_python(n));
-    downcast<T>(obj)->set_subscript(key.get(), value);
-    return 0;
-}
-
-template <class T>
-int class_t<T>::instance_mapping_ass_subscript(PyObject* obj, PyObject* key, PyObject* value) const
-{
-    downcast<T>(obj)->set_subscript(key, value);
-    return 0;
-}
-
-bool BOOST_PYTHON_DECL adjust_slice_indices(PyObject* obj, int& start, int& finish);
-
-template <class T>
-PyObject* class_t<T>::instance_sequence_slice(PyObject* obj, int start, int finish) const
-{
-    if (!adjust_slice_indices(obj, start, finish))
-        return 0;
-    return downcast<T>(obj)->get_slice(start, finish);
-}
-
-template <class T>
-int class_t<T>::instance_sequence_ass_slice(PyObject* obj, int start, int finish, PyObject* value) const
-{
-    if (!adjust_slice_indices(obj, start, finish))
-        return -1;
-    downcast<T>(obj)->set_slice(start, finish, value);
-    return 0;
-}
-
-template <class T>
-PyObject* class_t<T>::instance_call(PyObject* obj, PyObject* args, PyObject* keywords) const
-{
-    return downcast<T>(obj)->call(args, keywords);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_getattr(PyObject* obj, const char* name) const
-{
-    return downcast<T>(obj)->getattr(name);
-}
-
-
-template <class T>
-int class_t<T>::instance_setattr(PyObject* obj, const char* name, PyObject* value) const
-{
-    return downcast<T>(obj)->setattr(name, value);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_add(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->add(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_subtract(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->subtract(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_multiply(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->multiply(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_divide(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->divide(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_remainder(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->remainder(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_divmod(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->divmod(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_power(PyObject* obj, PyObject* exponent, PyObject* modulus) const
-{
-    return downcast<T>(obj)->power(exponent, modulus);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_negative(PyObject* obj) const
-{
-    return downcast<T>(obj)->negative();
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_positive(PyObject* obj) const
-{
-    return downcast<T>(obj)->positive();
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_absolute(PyObject* obj) const
-{
-    return downcast<T>(obj)->absolute();
-}
-
-template <class T>
-int class_t<T>::instance_number_nonzero(PyObject* obj) const
-{
-    return downcast<T>(obj)->nonzero();
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_invert(PyObject* obj) const
-{
-    return downcast<T>(obj)->invert();
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_lshift(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->lshift(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_rshift(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->rshift(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_and(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->do_and(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_xor(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->do_xor(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_or(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->do_or(other);
-}
-
-template <class T>
-int class_t<T>::instance_number_coerce(PyObject* obj, PyObject** x, PyObject** y) const
-{
-    return downcast<T>(obj)->coerce(x, y);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_int(PyObject* obj) const
-{
-    return downcast<T>(obj)->as_int();
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_long(PyObject* obj) const
-{
-    return downcast<T>(obj)->as_long();
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_float(PyObject* obj) const
-{
-    return downcast<T>(obj)->as_float();
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_oct(PyObject* obj) const
-{
-    return downcast<T>(obj)->oct();
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_hex(PyObject* obj) const
-{
-    return downcast<T>(obj)->hex();
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_inplace_add(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->inplace_add(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_inplace_subtract(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->inplace_subtract(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_inplace_multiply(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->inplace_multiply(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_inplace_divide(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->inplace_divide(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_inplace_remainder(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->inplace_remainder(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_inplace_power(PyObject* obj, PyObject* exponent, PyObject* modulus) const
-{
-    return downcast<T>(obj)->inplace_power(exponent, modulus);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_inplace_lshift(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->inplace_lshift(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_inplace_rshift(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->inplace_rshift(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_inplace_and(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->inplace_and(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_inplace_or(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->inplace_or(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_inplace_xor(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->inplace_xor(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_lt(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->lt(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_le(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->le(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_eq(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->eq(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_ne(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->ne(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_gt(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->gt(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_ge(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->ge(other);
-}
-
-namespace detail {
-  inline dictionary& class_base::dict()
-  {
-      return m_name_space;
-  }
-
-  inline tuple class_base::bases() const
-  {
-      return m_bases;
-  }
-}
-
-template <class T>
-PyObject* meta_class<T>::call(PyObject* args, PyObject* /*keywords*/)
-{
-    PyObject* name;
-    PyObject* bases;
-    PyObject* name_space;
-    
-    if (!PyArg_ParseTuple(args, const_cast<char*>("O!O!O!"),
-                          &PyString_Type, &name,
-                          &PyTuple_Type, &bases,
-                          &PyDict_Type, &name_space))
-    {
-        return 0;
-    }
-    
-    return as_object(
-        new class_t<T>(this, string(ref(name, ref::increment_count)),
-                  tuple(ref(bases, ref::increment_count)),
-                  dictionary(ref(name_space, ref::increment_count)))
-        );
-}
-
-namespace detail {
-  const string& setattr_string();
-  const string& getattr_string();
-  const string& delattr_string();
-
-  inline string class_base::name() const
-  {
-      return m_name;
-  }
-}
-
-
-}} // namespace boost::python
-#endif

include/boost/python/conversions.hpp

@@ -1,415 +0,0 @@
-//  (C) Copyright David Abrahams 2000. Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-//
-//  The author gratefully acknowleges the support of Dragon Systems, Inc., in
-//  producing this work.
-//
-// Revision History:
-// 31 Jul 01  convert int/double to complex (Peter Bienstman)
-// 04 Mar 01  Fixed std::complex<> stuff to work with MSVC (David Abrahams)
-// 03 Mar 01  added: converters for [plain] char and std::complex
-//            (Ralf W. Grosse-Kunstleve)
-
-#ifndef METHOD_DWA122899_H_
-# define METHOD_DWA122899_H_
-
-# include <boost/python/detail/config.hpp>
-# include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/detail/none.hpp>
-# include <boost/python/detail/signatures.hpp>
-# include <boost/shared_ptr.hpp>
-# include <boost/python/errors.hpp>
-# include <string>
-
-# ifdef BOOST_MSVC6_OR_EARLIER
-#  pragma warning(push)
-#  pragma warning(disable:4275) // disable a bogus warning caused by <complex>
-# endif
-
-# include <complex>
-
-# ifdef BOOST_MSVC6_OR_EARLIER
-#  pragma warning(pop)
-# endif
-
-BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE // this is a gcc 2.95.2 bug workaround
-
-// This can be instantiated on an enum to provide the to_python/from_python
-// conversions, provided the values can fit in a long.
-template <class EnumType>
-class py_enum_as_int_converters
-{
-    friend EnumType from_python(PyObject* x, boost::python::type<EnumType>)
-    {
-        return static_cast<EnumType>(
-            from_python(x, boost::python::type<long>()));
-    }
-
-    friend EnumType from_python(PyObject* x, boost::python::type<const EnumType&>)
-    {
-        return static_cast<EnumType>(
-            from_python(x, boost::python::type<long>()));
-    }
-
-    friend PyObject* to_python(EnumType x)
-    {
-        return to_python(static_cast<long>(x));
-    }
-};
-BOOST_PYTHON_END_CONVERSION_NAMESPACE
-
-namespace boost { namespace python {
-template <class EnumType> class enum_as_int_converters
-    : public BOOST_PYTHON_CONVERSION::py_enum_as_int_converters<EnumType> {};
-
-template <class P, class T> class wrapped_pointer;
-
-//#pragma warn_possunwant off
-inline void decref_impl(PyObject* p) { Py_DECREF(p); }
-inline void xdecref_impl(PyObject* p) { Py_XDECREF(p); }
-//#pragma warn_possunwant reset
-
-template <class T>
-inline void decref(T* p)
-{
-    char* const raw_p = reinterpret_cast<char*>(p);
-    char* const p_base = raw_p - offsetof(PyObject, ob_refcnt);
-    decref_impl(reinterpret_cast<PyObject*>(p_base));
-}
-
-template <class T>
-inline void xdecref(T* p)
-{
-    char* const raw_p = reinterpret_cast<char*>(p);
-    char* const p_base = raw_p - offsetof(PyObject, ob_refcnt);
-    xdecref_impl(reinterpret_cast<PyObject*>(p_base));
-}
-
-namespace detail {
-
-  void expect_complex(PyObject*);
-
-  template <class T>
-  std::complex<T> complex_from_python(PyObject* p, boost::python::type<T>)
-  {
-      if (PyInt_Check(p)) return std::complex<T>(PyInt_AS_LONG(p));
-      if (PyLong_Check(p)) return std::complex<T>(PyLong_AsDouble(p));
-      if (PyFloat_Check(p)) return std::complex<T>(PyFloat_AS_DOUBLE(p));
-
-      expect_complex(p);
-
-      return std::complex<T>(
-        static_cast<T>(PyComplex_RealAsDouble(p)),
-        static_cast<T>(PyComplex_ImagAsDouble(p)));
-  }
-
-  template <class T>
-  PyObject* complex_to_python(const std::complex<T>& sc) {
-      Py_complex pcc;
-      pcc.real = sc.real();
-      pcc.imag = sc.imag();
-      return PyComplex_FromCComplex(pcc);
-  }
-
-}
-
-}} // namespace boost::python
-
-BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
-//
-// Converters
-//
-PyObject* to_python(long);
-BOOST_PYTHON_DECL long from_python(PyObject* p, boost::python::type<long>);
-long from_python(PyObject* p, boost::python::type<const long&>);
-
-BOOST_PYTHON_DECL PyObject* to_python(unsigned long);
-BOOST_PYTHON_DECL unsigned long from_python(PyObject* p, boost::python::type<unsigned long>);
-unsigned long from_python(PyObject* p, boost::python::type<const unsigned long&>);
-
-PyObject* to_python(int);
-BOOST_PYTHON_DECL int from_python(PyObject*, boost::python::type<int>);
-int from_python(PyObject*, boost::python::type<const int&>);
-    
-BOOST_PYTHON_DECL PyObject* to_python(unsigned int);
-BOOST_PYTHON_DECL unsigned int from_python(PyObject*, boost::python::type<unsigned int>);
-unsigned int from_python(PyObject*, boost::python::type<const unsigned int&>);
-
-PyObject* to_python(short);
-BOOST_PYTHON_DECL short from_python(PyObject*, boost::python::type<short>);
-short from_python(PyObject*, boost::python::type<const short&>);
-    
-BOOST_PYTHON_DECL PyObject* to_python(unsigned short);
-BOOST_PYTHON_DECL unsigned short from_python(PyObject*, boost::python::type<unsigned short>);
-unsigned short from_python(PyObject*, boost::python::type<const unsigned short&>);
-
-BOOST_PYTHON_DECL PyObject* to_python(char);
-BOOST_PYTHON_DECL char from_python(PyObject*, boost::python::type<char>);
-char from_python(PyObject*, boost::python::type<const char&>);
-
-BOOST_PYTHON_DECL PyObject* to_python(signed char);
-BOOST_PYTHON_DECL signed char from_python(PyObject*, boost::python::type<signed char>);
-signed char from_python(PyObject*, boost::python::type<const signed char&>);
-
-BOOST_PYTHON_DECL PyObject* to_python(unsigned char);
-BOOST_PYTHON_DECL unsigned char from_python(PyObject*, boost::python::type<unsigned char>);
-unsigned char from_python(PyObject*, boost::python::type<const unsigned char&>);
-
-BOOST_PYTHON_DECL float from_python(PyObject*, boost::python::type<float>);
-BOOST_PYTHON_DECL double from_python(PyObject*, boost::python::type<double>);
-
-# if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
-PyObject* to_python(float);
-PyObject* to_python(double);
-# else
-BOOST_PYTHON_DECL PyObject* to_python(float);
-BOOST_PYTHON_DECL PyObject* to_python(double);
-# endif 
-float from_python(PyObject*, boost::python::type<const float&>);
-    
-double from_python(PyObject*, boost::python::type<const double&>);
-    
-PyObject* to_python(bool);
-BOOST_PYTHON_DECL bool from_python(PyObject*, boost::python::type<bool>);
-bool from_python(PyObject*, boost::python::type<const bool&>);
-
-BOOST_PYTHON_DECL PyObject* to_python(void);
-BOOST_PYTHON_DECL void from_python(PyObject*, boost::python::type<void>);
-
-PyObject* to_python(const char* s);
-BOOST_PYTHON_DECL const char* from_python(PyObject*, boost::python::type<const char*>);
-
-BOOST_PYTHON_DECL PyObject* to_python(const std::string& s);
-BOOST_PYTHON_DECL std::string from_python(PyObject*, boost::python::type<std::string>);
-std::string from_python(PyObject*, boost::python::type<const std::string&>);
-
-inline PyObject* to_python(const std::complex<float>& x)
-{
-    return boost::python::detail::complex_to_python<float>(x);
-}
-
-inline PyObject* to_python(const std::complex<double>& x)
-{
-    return boost::python::detail::complex_to_python<double>(x);
-}
-
-inline std::complex<double> from_python(PyObject* p,
-                                   boost::python::type<std::complex<double> >) {
-    return boost::python::detail::complex_from_python(p, boost::python::type<double>());
-}
-
-inline std::complex<double> from_python(PyObject* p,
-                                   boost::python::type<const std::complex<double>&>) {
-    return boost::python::detail::complex_from_python(p, boost::python::type<double>());
-}
-
-inline std::complex<float> from_python(PyObject* p,
-                                   boost::python::type<std::complex<float> >) {
-    return boost::python::detail::complex_from_python(p, boost::python::type<float>());
-}
-
-inline std::complex<float> from_python(PyObject* p,
-                                   boost::python::type<const std::complex<float>&>) {
-    return boost::python::detail::complex_from_python(p, boost::python::type<float>());
-}
-
-// For when your C++ function really wants to pass/return a PyObject*
-PyObject* to_python(PyObject*);
-PyObject* from_python(PyObject*, boost::python::type<PyObject*>);
-
-// Some standard conversions to/from smart pointer types. You can add your own
-// from these examples.  These are not generated using the friend technique from
-// wrapped_pointer because:
-//
-//      1. We want to be able to extend conversion to/from WrappedPointers using
-//      arbitrary smart pointer types.
-//
-//      2. It helps with compilation independence. This way, code which creates
-//      wrappers for functions accepting and returning smart_ptr<T> does not
-//      have to have already seen the invocation of wrapped_type<T>.
-//
-
-// Unfortunately, MSVC6 is so incredibly lame that we have to rely on the friend
-// technique to auto_generate standard pointer conversions for wrapped
-// types. This means that you need to write a non-templated function for each
-// specific smart_ptr<T> which you want to convert from_python. For example,
-//
-// namespace boost { namespace python {
-// #ifdef MUST_SUPPORT_MSVC
-//
-// MyPtr<Foo> from_python(PyObject*p, type<MyPtr<Foo> >)
-//     { return smart_ptr_from_python(p, type<MyPtr<Foo> >(), type<Foo>());}
-// }
-// 
-// MyPtr<Bar> from_python(PyObject*p, type<MyPtr<Bar> >)
-//     { return smart_ptr_from_python(p, type<MyPtr<Bar> >(), type<Bar>());}
-// 
-// ... // definitions for MyPtr<Baz>, MyPtr<Mumble>, etc.
-//
-// #else
-//
-// // Just once for all MyPtr<T>
-// template <class T>
-// MyPtr<T> from_python(PyObject*p, type<MyPtr<T> >)
-// {
-//    return smart_ptr_from_python(p, type<MyPtr<T> >(), type<T>());
-// }
-//
-// #endif
-// }} // namespace boost::python
-
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-template <class T>
-boost::shared_ptr<T> from_python(PyObject*p, boost::python::type<boost::shared_ptr<T> >)
-{
-    return smart_ptr_from_python(p, boost::python::type<boost::shared_ptr<T> >(), boost::python::type<T>());
-}
-#endif
-
-#if 0
-template <class T>
-PyObject* to_python(std::auto_ptr<T> p)
-{
-    return new boost::python::wrapped_pointer<std::auto_ptr<T>, T>(p);
-}
-
-template <class T>
-PyObject* to_python(boost::shared_ptr<T> p)
-{
-    return new boost::python::wrapped_pointer<boost::shared_ptr<T>, T>(p);
-}
-#endif
-
-//
-// inline implementations
-//
-
-#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
-inline PyObject* to_python(double d)
-{
-    return PyFloat_FromDouble(d);
-}
-
-inline PyObject* to_python(float f)
-{
-    return PyFloat_FromDouble(f);
-}
-#endif
-
-inline PyObject* to_python(long l)
-{
-    return PyInt_FromLong(l);
-}
-
-inline PyObject* to_python(int x)
-{
-    return PyInt_FromLong(x);
-}
-
-inline PyObject* to_python(short x)
-{
-    return PyInt_FromLong(x);
-}
-
-inline PyObject* to_python(bool b)
-{
-    return PyInt_FromLong(b);
-}
-
-inline PyObject* to_python(void)
-{
-    return boost::python::detail::none();
-}
-
-inline PyObject* to_python(const char* s)
-{
-    return PyString_FromString(s);
-}
-
-inline std::string from_python(PyObject* p, boost::python::type<const std::string&>)
-{
-    return from_python(p, boost::python::type<std::string>());
-}
-
-inline PyObject* to_python(PyObject* p)
-{
-    Py_INCREF(p);
-    return p;
-}
-
-inline PyObject* from_python(PyObject* p, boost::python::type<PyObject*>)
-{
-    return p;
-}
-
-inline const char* from_python(PyObject* p, boost::python::type<const char* const&>)
-{
-    return from_python(p, boost::python::type<const char*>());
-}
-
-inline double from_python(PyObject* p, boost::python::type<const double&>)
-{
-    return from_python(p, boost::python::type<double>());
-}
-
-inline float from_python(PyObject* p, boost::python::type<const float&>)
-{
-    return from_python(p, boost::python::type<float>());
-}
-
-inline int from_python(PyObject* p, boost::python::type<const int&>)
-{
-    return from_python(p, boost::python::type<int>());
-}
-
-inline short from_python(PyObject* p, boost::python::type<const short&>)
-{
-    return from_python(p, boost::python::type<short>());
-}
-
-inline long from_python(PyObject* p, boost::python::type<const long&>)
-{
-    return from_python(p, boost::python::type<long>());
-}
-
-inline bool from_python(PyObject* p, boost::python::type<const bool&>)
-{
-    return from_python(p, boost::python::type<bool>());
-}
-
-inline unsigned int from_python(PyObject* p, boost::python::type<const unsigned int&>)
-{
-    return from_python(p, boost::python::type<unsigned int>());
-}
-
-inline unsigned short from_python(PyObject* p, boost::python::type<const unsigned short&>)
-{
-    return from_python(p, boost::python::type<unsigned short>());
-}
-
-inline char from_python(PyObject* p, boost::python::type<const char&>)
-{
-    return from_python(p, boost::python::type<char>());
-}
-
-inline signed char from_python(PyObject* p, boost::python::type<const signed char&>)
-{
-    return from_python(p, boost::python::type<signed char>());
-}
-
-inline unsigned char from_python(PyObject* p, boost::python::type<const unsigned char&>)
-{
-    return from_python(p, boost::python::type<unsigned char>());
-}
-
-inline unsigned long from_python(PyObject* p, boost::python::type<const unsigned long&>)
-{
-    return from_python(p, boost::python::type<unsigned long>());
-}
-
-
-BOOST_PYTHON_END_CONVERSION_NAMESPACE
-
-#endif // METHOD_DWA122899_H_

include/boost/python/converter/arg_from_python.hpp

@@ -1,18 +1,22 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 ARG_FROM_PYTHON_DWA2002127_HPP
 # define ARG_FROM_PYTHON_DWA2002127_HPP
 
+# include <boost/python/detail/prefix.hpp>
 # include <boost/python/converter/from_python.hpp>
-# include <boost/python/detail/wrap_python.hpp>
 # include <boost/python/detail/indirect_traits.hpp>
 # include <boost/type_traits/transform_traits.hpp>
 # include <boost/type_traits/cv_traits.hpp>
 # include <boost/python/converter/rvalue_from_python_data.hpp>
+# include <boost/mpl/eval_if.hpp>
 # include <boost/mpl/if.hpp>
+# include <boost/mpl/identity.hpp>
+# include <boost/mpl/and.hpp>
+# include <boost/mpl/or.hpp>
+# include <boost/mpl/not.hpp>
 # include <boost/python/converter/registry.hpp>
 # include <boost/python/converter/registered.hpp>
 # include <boost/python/converter/registered_pointee.hpp>
@@ -44,7 +48,7 @@ struct pointer_cref_arg_from_python
     typedef T result_type;
     
     pointer_cref_arg_from_python(PyObject*);
-    T operator()(PyObject*) const;
+    T operator()() const;
     bool convertible() const;
     
  private: // storage for a U*
@@ -74,7 +78,7 @@ struct pointer_arg_from_python : arg_lvalue_from_python_base
     typedef T result_type;
     
     pointer_arg_from_python(PyObject*);
-    T operator()(PyObject*) const;
+    T operator()() const;
 };
 
 // Used when T == U& and (T != V const& or T == W volatile&)
@@ -84,7 +88,7 @@ struct reference_arg_from_python : arg_lvalue_from_python_base
     typedef T result_type;
     
     reference_arg_from_python(PyObject*);
-    T operator()(PyObject*) const;
+    T operator()() const;
 };
 
 // ===================
@@ -103,16 +107,22 @@ template <class T>
 struct arg_rvalue_from_python
 {
     typedef typename boost::add_reference<
-        typename boost::add_const<T>::type
+        T
+        // We can't add_const here, or it would be impossible to pass
+        // auto_ptr<U> args from Python to C++
     >::type result_type;
     
     arg_rvalue_from_python(PyObject*);
     bool convertible() const;
-    
-    result_type operator()(PyObject*);
+
+# if BOOST_MSVC < 1301 || _MSC_FULL_VER > 13102196
+    typename arg_rvalue_from_python<T>::
+# endif 
+    result_type operator()();
     
  private:
     rvalue_from_python_data<result_type> m_data;
+    PyObject* m_source;
 };
 
 
@@ -127,69 +137,58 @@ struct back_reference_arg_from_python
     typedef T result_type;
     
     back_reference_arg_from_python(PyObject*);
-    T operator()(PyObject*);
+    T operator()();
  private:
     typedef boost::python::arg_from_python<typename T::type> base;
+    PyObject* m_source;
 };
 
 
 // ==================
 
+template <class C, class T, class F>
+struct if_2
+{
+    typedef typename mpl::eval_if<C, mpl::identity<T>, F>::type type;
+};
+
 // This metafunction selects the appropriate arg_from_python converter
 // type for an argument of type T.
 template <class T>
 struct select_arg_from_python
 {
-    BOOST_STATIC_CONSTANT(
-        bool, obj_mgr = is_object_manager<T>::value);
-    
-    BOOST_STATIC_CONSTANT(
-        bool, obj_mgr_ref = is_reference_to_object_manager<T>::value);
-    
-    BOOST_STATIC_CONSTANT(
-        bool, ptr = is_pointer<T>::value);
-    
-    BOOST_STATIC_CONSTANT(
-        bool, ptr_cref
-            = boost::python::detail::is_reference_to_pointer<T>::value
-            && boost::python::detail::is_reference_to_const<T>::value
-            && !boost::python::detail::is_reference_to_volatile<T>::value);
-    
-    
-    BOOST_STATIC_CONSTANT(
-        bool, ref =
-        boost::python::detail::is_reference_to_non_const<T>::value
-        || boost::python::detail::is_reference_to_volatile<T>::value);
-
-    BOOST_STATIC_CONSTANT(
-        bool, back_ref =
-        boost::python::is_back_reference<T>::value);
-
-    typedef typename mpl::if_c<
-        obj_mgr
-        , object_manager_value_arg_from_python<T>
-        , typename mpl::if_c<
-            obj_mgr_ref
-            , object_manager_ref_arg_from_python<T>
-            , typename mpl::if_c<
-                ptr
-                , pointer_arg_from_python<T>
-                , typename mpl::if_c<
-                    ptr_cref
-                    , pointer_cref_arg_from_python<T>
-                    , typename mpl::if_c<
-                        ref
-                        , reference_arg_from_python<T>
-                        , typename mpl::if_c<
-                            back_ref
-                            , back_reference_arg_from_python<T>
-                            , arg_rvalue_from_python<T>
-                          >::type
-                      >::type
-                  >::type
-              >::type
-          >::type
-      >::type type;
+    typedef typename if_2<
+        is_object_manager<T>
+      , object_manager_value_arg_from_python<T>
+      , if_2<
+            is_reference_to_object_manager<T>
+          , object_manager_ref_arg_from_python<T>
+          , if_2<
+                is_pointer<T>
+              , pointer_arg_from_python<T>
+              , if_2<
+                    mpl::and_<
+                        indirect_traits::is_reference_to_pointer<T>
+                      , indirect_traits::is_reference_to_const<T>
+                      , mpl::not_<indirect_traits::is_reference_to_volatile<T> >
+                        >
+                  , pointer_cref_arg_from_python<T>
+                  , if_2<
+                        mpl::or_<
+                            indirect_traits::is_reference_to_non_const<T>
+                          , indirect_traits::is_reference_to_volatile<T>
+                        >
+                      , reference_arg_from_python<T>
+                      , mpl::if_<
+                            boost::python::is_back_reference<T>
+                          , back_reference_arg_from_python<T>
+                          , arg_rvalue_from_python<T>
+                        >
+                    >
+                >
+            >
+        >
+    >::type type;
 };
 
 // ==================
@@ -254,9 +253,9 @@ inline bool pointer_cref_arg_from_python<T>::convertible() const
     return python::detail::void_ptr_to_reference(m_result.bytes, (T(*)())0) != 0;
 }
 template <class T>
-inline T pointer_cref_arg_from_python<T>::operator()(PyObject* p) const
+inline T pointer_cref_arg_from_python<T>::operator()() const
 {
-    return (p == Py_None)  // None ==> 0
+    return (*(void**)m_result.bytes == Py_None)  // None ==> 0
         ? detail::null_ptr_reference((T(*)())0)
         // Otherwise, return a U*const& to the m_result storage.
         : python::detail::void_ptr_to_reference(m_result.bytes, (T(*)())0);
@@ -272,9 +271,9 @@ inline pointer_arg_from_python<T>::pointer_arg_from_python(PyObject* p)
 }
 
 template <class T>
-inline T pointer_arg_from_python<T>::operator()(PyObject* p) const
+inline T pointer_arg_from_python<T>::operator()() const
 {
-    return (p == Py_None) ? 0 : T(result());
+    return (result() == Py_None) ? 0 : T(result());
 }
 
 // reference_arg_from_python
@@ -286,7 +285,7 @@ inline reference_arg_from_python<T>::reference_arg_from_python(PyObject* p)
 }
 
 template <class T>
-inline T reference_arg_from_python<T>::operator()(PyObject*) const
+inline T reference_arg_from_python<T>::operator()() const
 {
     return python::detail::void_ptr_to_reference(result(), (T(*)())0);
 }
@@ -297,6 +296,7 @@ inline T reference_arg_from_python<T>::operator()(PyObject*) const
 template <class T>
 inline arg_rvalue_from_python<T>::arg_rvalue_from_python(PyObject* obj)
     : m_data(converter::rvalue_from_python_stage1(obj, registered<T>::converters))
+    , m_source(obj)
 {
 }
 
@@ -308,10 +308,10 @@ inline bool arg_rvalue_from_python<T>::convertible() const
 
 template <class T>
 inline typename arg_rvalue_from_python<T>::result_type
-arg_rvalue_from_python<T>::operator()(PyObject* p)
+arg_rvalue_from_python<T>::operator()()
 {
     if (m_data.stage1.construct != 0)
-        m_data.stage1.construct(p, &m_data.stage1);
+        m_data.stage1.construct(m_source, &m_data.stage1);
     
     return python::detail::void_ptr_to_reference(m_data.stage1.convertible, (result_type(*)())0);
 }
@@ -320,15 +320,15 @@ arg_rvalue_from_python<T>::operator()(PyObject* p)
 //
 template <class T>
 back_reference_arg_from_python<T>::back_reference_arg_from_python(PyObject* x)
-    : base(x)
+  : base(x), m_source(x)
 {
 }
 
 template <class T>
 inline T
-back_reference_arg_from_python<T>::operator()(PyObject* x)
+back_reference_arg_from_python<T>::operator()()
 {
-    return T(x, base::operator()(x));
+    return T(m_source, base::operator()());
 }
 
 }}} // namespace boost::python::converter

include/boost/python/converter/arg_to_python.hpp

@@ -1,27 +1,36 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 ARG_TO_PYTHON_DWA200265_HPP
 # define ARG_TO_PYTHON_DWA200265_HPP
 
 # include <boost/python/ptr.hpp>
+# include <boost/python/tag.hpp>
+# include <boost/python/to_python_indirect.hpp>
+
 # include <boost/python/converter/registered.hpp>
 # include <boost/python/converter/registered_pointee.hpp>
 # include <boost/python/converter/arg_to_python_base.hpp>
-# include <boost/python/to_python_indirect.hpp>
-# include <boost/type_traits/cv_traits.hpp>
-# include <boost/type_traits/composite_traits.hpp>
-# include <boost/type_traits/function_traits.hpp>
+# include <boost/python/converter/shared_ptr_to_python.hpp>
+// Bring in specializations
+# include <boost/python/converter/builtin_converters.hpp>
+
+# include <boost/python/object/function_handle.hpp>
+
+# include <boost/python/base_type_traits.hpp>
+
 # include <boost/python/detail/indirect_traits.hpp>
 # include <boost/python/detail/convertible.hpp>
 # include <boost/python/detail/string_literal.hpp>
-# include <boost/python/base_type_traits.hpp>
-// Bring in specializations
-# include <boost/python/converter/builtin_converters.hpp>
-# include <boost/python/tag.hpp>
-# include <boost/python/object/function_handle.hpp>
+# include <boost/python/detail/value_is_shared_ptr.hpp>
+
+# include <boost/type_traits/cv_traits.hpp>
+# include <boost/type_traits/composite_traits.hpp>
+# include <boost/type_traits/function_traits.hpp>
+
+
+# include <boost/mpl/or.hpp>
 
 namespace boost { namespace python { namespace converter { 
 
@@ -29,8 +38,6 @@ template <class T> struct is_object_manager;
 
 namespace detail
 {
-  BOOST_PYTHON_DECL void throw_no_class_registered();
-
   template <class T>
   struct function_arg_to_python : handle<>
   {
@@ -45,6 +52,14 @@ namespace detail
       static PyObject* get_object(T& x);
   };
 
+  template <class T>
+  struct shared_ptr_arg_to_python : handle<>
+  {
+      shared_ptr_arg_to_python(T const& x);
+   private:
+      static PyObject* get_object(T& x);
+  };
+
   template <class T>
   struct value_arg_to_python : arg_to_python_base
   {
@@ -86,54 +101,51 @@ namespace detail
   template <class T>
   struct select_arg_to_python
   {
-      // Special handling for char const[N]; interpret them as char
-      // const* for the sake of conversion
-      BOOST_STATIC_CONSTANT(
-          bool, is_string = python::detail::is_string_literal<T const>::value);
-      
-      BOOST_STATIC_CONSTANT(
-          bool, function = is_function<T>::value | python::detail::is_pointer_to_function<T>::value | is_member_function_pointer<T>::value);
-      
-      BOOST_STATIC_CONSTANT(
-          bool, manager = is_object_manager<T>::value);
-      
-      BOOST_STATIC_CONSTANT(
-          bool, ptr = is_pointer<T>::value);
-      
-      BOOST_STATIC_CONSTANT(
-          bool, ref_wrapper = is_reference_wrapper<T>::value);
-
-      BOOST_STATIC_CONSTANT(
-          bool, ptr_wrapper = is_pointer_wrapper<T>::value);
-
       typedef typename unwrap_reference<T>::type unwrapped_referent;
       typedef typename unwrap_pointer<T>::type unwrapped_ptr;
 
-      typedef typename mpl::if_c<
-          is_string
-          , arg_to_python<char const*>
-          , typename mpl::if_c<
-              function
-              , function_arg_to_python<T>
-              , typename mpl::if_c<
-                  manager
-                  , object_manager_arg_to_python<T>
-                  , typename mpl::if_c<
-                      ptr
-                      , pointer_deep_arg_to_python<T>
-                      , typename mpl::if_c<
-                          ptr_wrapper
-                          , pointer_shallow_arg_to_python<unwrapped_ptr>
-                          , typename mpl::if_c<
-                              ref_wrapper
-                              , reference_arg_to_python<unwrapped_referent>
-                              , value_arg_to_python<T>
-                            >::type
-                        >::type
-                    >::type
-                >::type
-            >::type
-        >::type
+      typedef typename mpl::if_<
+          // Special handling for char const[N]; interpret them as char
+          // const* for the sake of conversion
+          python::detail::is_string_literal<T const>
+        , arg_to_python<char const*>
+
+        , typename mpl::if_<
+              python::detail::value_is_shared_ptr<T>
+            , shared_ptr_arg_to_python<T>
+      
+            , typename mpl::if_<
+                mpl::or_<
+                    is_function<T>
+                  , indirect_traits::is_pointer_to_function<T>
+                  , is_member_function_pointer<T>
+                >
+                , function_arg_to_python<T>
+
+                , typename mpl::if_<
+                      is_object_manager<T>
+                    , object_manager_arg_to_python<T>
+
+                    , typename mpl::if_<
+                          is_pointer<T>
+                        , pointer_deep_arg_to_python<T>
+
+                        , typename mpl::if_<
+                              is_pointer_wrapper<T>
+                            , pointer_shallow_arg_to_python<unwrapped_ptr>
+
+                            , typename mpl::if_<
+                                  is_reference_wrapper<T>
+                                , reference_arg_to_python<unwrapped_referent>
+                                , value_arg_to_python<T>
+                              >::type
+                          >::type
+                      >::type
+                  >::type
+              >::type
+          >::type
+      >::type
+      
       type;
   };
 }
@@ -209,8 +221,6 @@ namespace detail
   inline PyObject* reference_arg_to_python<T>::get_object(T& x)
   {
       to_python_indirect<T&,python::detail::make_reference_holder> convert;
-      if (!convert.convertible())
-          throw_no_class_registered();
       return convert(x);
   }
 
@@ -220,6 +230,12 @@ namespace detail
   {
   }
 
+  template <class T>
+  inline shared_ptr_arg_to_python<T>::shared_ptr_arg_to_python(T const& x)
+      : handle<>(shared_ptr_to_python(x))
+  {
+  }
+
   template <class Ptr>
   inline pointer_shallow_arg_to_python<Ptr>::pointer_shallow_arg_to_python(Ptr x)
       : handle<>(pointer_shallow_arg_to_python<Ptr>::get_object(x))
@@ -231,9 +247,7 @@ namespace detail
   inline PyObject* pointer_shallow_arg_to_python<Ptr>::get_object(Ptr x)
   {
       to_python_indirect<Ptr,python::detail::make_reference_holder> convert;
-      if (!convert.convertible())
-          throw_no_class_registered();
-      return x ? convert(x) : python::detail::none();
+      return convert(x);
   }
 }
 

include/boost/python/converter/arg_to_python_base.hpp

@@ -1,12 +1,9 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 ARG_TO_PYTHON_BASE_DWA200237_HPP
 # define ARG_TO_PYTHON_BASE_DWA200237_HPP
-# include <boost/python/converter/to_python_function_type.hpp>
-# include <boost/python/detail/wrap_python.hpp>
 # include <boost/python/handle.hpp>
 
 namespace boost { namespace python { namespace converter {

include/boost/python/converter/as_to_python_function.hpp

@@ -0,0 +1,46 @@
+// 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 AS_TO_PYTHON_FUNCTION_DWA2002121_HPP
+# define AS_TO_PYTHON_FUNCTION_DWA2002121_HPP
+# include <boost/python/converter/to_python_function_type.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+// Given a typesafe to_python conversion function, produces a
+// to_python_function_t which can be registered in the usual way.
+template <class T, class ToPython>
+struct as_to_python_function
+{
+    // Assertion functions used to prevent wrapping of converters
+    // which take non-const reference parameters. The T* argument in
+    // the first overload ensures it isn't used in case T is a
+    // reference.
+    template <class U>
+    static void convert_function_must_take_value_or_const_reference(U(*)(T), int, T* = 0) {}
+    template <class U>
+    static void convert_function_must_take_value_or_const_reference(U(*)(T const&), long ...) {}
+        
+    static PyObject* convert(void const* x)
+    {
+        convert_function_must_take_value_or_const_reference(&ToPython::convert, 1L);
+        
+        // Yes, the const_cast below opens a hole in const-correctness,
+        // but it's needed to convert auto_ptr<U> to python.
+        //
+        // How big a hole is it?  It allows ToPython::convert() to be
+        // a function which modifies its argument. The upshot is that
+        // client converters applied to const objects may invoke
+        // undefined behavior. The damage, however, is limited by the
+        // use of the assertion function. Thus, the only way this can
+        // modify its argument is if T is an auto_ptr-like type. There
+        // is still a const-correctness hole w.r.t. auto_ptr<U> const,
+        // but c'est la vie.
+        return ToPython::convert(*const_cast<T*>(static_cast<T const*>(x)));
+    }
+};
+
+}}} // namespace boost::python::converter
+
+#endif // AS_TO_PYTHON_FUNCTION_DWA2002121_HPP

include/boost/python/converter/builtin_converters.hpp

@@ -1,15 +1,16 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 BUILTIN_CONVERTERS_DWA2002124_HPP
 # define BUILTIN_CONVERTERS_DWA2002124_HPP
-# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/detail/prefix.hpp>
 # include <boost/python/detail/none.hpp>
 # include <boost/python/handle.hpp>
+# include <boost/implicit_cast.hpp>
 # include <string>
 # include <complex>
+# include <boost/limits.hpp>
 
 // Since all we can use to decide how to convert an object to_python
 // is its C++ type, there can be only one such converter for each
@@ -37,7 +38,10 @@ namespace detail
   // a converter.
   struct builtin_to_python
   {
-      static bool convertible() { return true; }
+      // This information helps make_getter() decide whether to try to
+      // return an internal reference or not. I don't like it much,
+      // but it will have to serve for now.
+      BOOST_STATIC_CONSTANT(bool, uses_registry = false);
   };
 }
 
@@ -78,12 +82,21 @@ namespace detail
 
 // Specialize converters for signed and unsigned T to Python Int
 # define BOOST_PYTHON_TO_INT(T)                                         \
-    BOOST_PYTHON_TO_PYTHON_BY_VALUE(signed T, PyInt_FromLong(x))        \
-    BOOST_PYTHON_TO_PYTHON_BY_VALUE(unsigned T, PyInt_FromLong(x))
+    BOOST_PYTHON_TO_PYTHON_BY_VALUE(signed T, ::PyInt_FromLong(x))      \
+    BOOST_PYTHON_TO_PYTHON_BY_VALUE(                                    \
+        unsigned T                                                      \
+        , static_cast<unsigned long>(x) > static_cast<unsigned long>(   \
+                (std::numeric_limits<long>::max)())                     \
+        ? ::PyLong_FromUnsignedLong(x)                                  \
+        : ::PyInt_FromLong(x))
 
 // Bool is not signed.
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(bool, PyInt_FromLong(x))
-
+#if PY_VERSION_HEX >= 0x02030000
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(bool, ::PyBool_FromLong(x))
+#else
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(bool, ::PyInt_FromLong(x))
+#endif
+  
 // note: handles signed char and unsigned char, but not char (see below)
 BOOST_PYTHON_TO_INT(char)
 
@@ -94,23 +107,31 @@ BOOST_PYTHON_TO_INT(long)
 // using Python's macro instead of Boost's - we don't seem to get the
 // config right all the time.
 # ifdef HAVE_LONG_LONG 
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(signed LONG_LONG, PyLong_FromLongLong(x))
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(unsigned LONG_LONG, PyLong_FromUnsignedLongLong(x))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(signed BOOST_PYTHON_LONG_LONG, ::PyLong_FromLongLong(x))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(unsigned BOOST_PYTHON_LONG_LONG, ::PyLong_FromUnsignedLongLong(x))
 # endif
     
 # undef BOOST_TO_PYTHON_INT
 
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(char, converter::do_return_to_python(x))
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(char const*, converter::do_return_to_python(x))
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::string, PyString_FromString(x.c_str()))
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(float, PyFloat_FromDouble(x))
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(double, PyFloat_FromDouble(x))
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(long double, PyFloat_FromDouble(x))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::string, ::PyString_FromStringAndSize(x.data(),implicit_cast<int>(x.size())))
+# ifndef BOOST_NO_STD_WSTRING
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::wstring, ::PyUnicode_FromWideChar(x.data(),implicit_cast<int>(x.size())))
+# endif 
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(float, ::PyFloat_FromDouble(x))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(double, ::PyFloat_FromDouble(x))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(long double, ::PyFloat_FromDouble(x))
 BOOST_PYTHON_RETURN_TO_PYTHON_BY_VALUE(PyObject*, converter::do_return_to_python(x))
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::complex<float>, PyComplex_FromDoubles(x.real(), x.imag()))
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::complex<double>, PyComplex_FromDoubles(x.real(), x.imag()))
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::complex<long double>, PyComplex_FromDoubles(x.real(), x.imag()))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::complex<float>, ::PyComplex_FromDoubles(x.real(), x.imag()))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::complex<double>, ::PyComplex_FromDoubles(x.real(), x.imag()))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::complex<long double>, ::PyComplex_FromDoubles(x.real(), x.imag()))
 
+# undef BOOST_PYTHON_RETURN_TO_PYTHON_BY_VALUE
+# undef BOOST_PYTHON_ARG_TO_PYTHON_BY_VALUE
+# undef BOOST_PYTHON_TO_PYTHON_BY_VALUE
+# undef BOOST_PYTHON_TO_INT
+    
 namespace converter
 { 
 

include/boost/python/converter/callback.hpp

@@ -1,278 +0,0 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef CALLBACK_DWA2002228_HPP
-# define CALLBACK_DWA2002228_HPP
-
-# include <boost/python/converter/type_id.hpp>
-# include <boost/python/converter/to_python_function.hpp>
-# include <boost/python/converter/pointee_to_python_function.hpp>
-# include <boost/python/converter/from_python.hpp>
-# include <boost/mpl/select_if.hpp>
-# include <boost/python/converter/callback_to_python_base.hpp>
-# include <boost/python/converter/callback_from_python_base.hpp>
-# include <boost/python/converter/builtin_converters.hpp>
-# include <boost/python/to_python_indirect.hpp>
-# include <boost/python/detail/none.hpp>
-# include <boost/python/ptr.hpp>
-# include <boost/python/errors.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-namespace detail
-{
-  template <class T>
-  struct pointer_callback_from_python
-  {
-      pointer_callback_from_python();
-      T operator()(PyObject*) const;
-  };
-  
-  template <class T>
-  struct reference_callback_from_python
-  {
-      reference_callback_from_python();
-      T operator()(PyObject*) const;
-  };
-  
-  template <class T>
-  struct rvalue_callback_from_python
-  {
-      rvalue_callback_from_python();
-      T const& operator()(PyObject*);
-   private:
-      rvalue_data<T> m_data;
-  };
-  
-  template <class T>
-  struct select_callback_from_python
-  {
-      BOOST_STATIC_CONSTANT(
-          bool, ptr = is_pointer<T>::value);
-    
-      BOOST_STATIC_CONSTANT(
-          bool, ref = is_reference<T>::value);
-
-      typedef typename mpl::select_if_c<
-          ptr
-          , pointer_callback_from_python<T>
-          , typename mpl::select_if_c<
-              ref
-              , reference_callback_from_python<T>
-              , rvalue_callback_from_python<T>
-            >::type
-          >::type type;
-  };
-
-
-  template <class T>
-  struct reference_callback_to_python : callback_to_python_holder
-  {
-      reference_callback_to_python(T& x);
-   private:
-      static PyObject* get_object(T& x);
-  };
-
-  template <class T>
-  struct value_callback_to_python : callback_to_python_base
-  {
-      // Throw an exception if the conversion can't succeed
-      value_callback_to_python(T const&);
-  };
-
-  template <class Ptr>
-  struct pointer_deep_callback_to_python : callback_to_python_base
-  {
-      // Throw an exception if the conversion can't succeed
-      pointer_deep_callback_to_python(Ptr);
-  };
-
-  template <class Ptr>
-  struct pointer_shallow_callback_to_python : callback_to_python_holder
-  {
-      // Throw an exception if the conversion can't succeed
-      pointer_shallow_callback_to_python(Ptr);
-   private:
-      static PyObject* get_object(Ptr p);
-  };
-
-  template <class T>
-  struct select_callback_to_python
-  {
-      BOOST_STATIC_CONSTANT(
-          bool, ptr = is_pointer<T>::value);
-      
-      BOOST_STATIC_CONSTANT(
-          bool, ref_wrapper = is_reference_wrapper<T>::value);
-
-      BOOST_STATIC_CONSTANT(
-          bool, ptr_wrapper = is_pointer_wrapper<T>::value);
-
-      typedef typename unwrap_reference<T>::type unwrapped_referent;
-      typedef typename unwrap_pointer<T>::type unwrapped_ptr;
-
-      typedef typename mpl::select_if_c<
-          ptr
-          , pointer_deep_callback_to_python<T>
-          , typename mpl::select_if_c<
-              ptr_wrapper
-              , pointer_shallow_callback_to_python<unwrapped_ptr>
-              , typename mpl::select_if_c<
-                  ref_wrapper
-                  , reference_callback_to_python<unwrapped_referent>
-                  , value_callback_to_python<T>
-                >::type
-            >::type
-        >::type type;
-  };
-}
-
-template <class T>
-struct callback_from_python
-    : detail::select_callback_from_python<T>::type
-{
-    typedef T result_type;
-};
-
-struct void_result
-{
- private: 
-    void_result() {}
-    void operator=(void_result const&);
-    
-    // I would prefer to make this completely untouchable, but few
-    // compilers support template friends
-# if 0
-    void_result(void_result const&);
-# endif
-    friend struct callback_from_python<void>;
-};
-
-// Specialization as a convenience for call and call_method
-template <>
-struct callback_from_python<void>
-{
-    typedef void_result result_type;
-    result_type operator()(PyObject* x) const
-    {
-        Py_DECREF(expect_non_null(x));
-        return result_type();
-    }
-};
-
-template <class T>
-struct callback_to_python
-    : detail::select_callback_to_python<T>::type
-{
-    typedef typename detail::select_callback_to_python<T>::type base;
- public: // member functions
-    // Throw an exception if the conversion can't succeed
-    callback_to_python(T const& x);
-};
-
-// Convenience macros for call<> and call_method<> code generation
-# define BOOST_PYTHON_CALLBACK_TO_PYTHON_GET(index,ignored)     \
-    converter::callback_to_python<BOOST_PP_CAT(A,index)>(       \
-        BOOST_PP_CAT(a,index)).get()
-
-# define BOOST_PYTHON_ARG_STRING(nargs)                         \
-    "(" BOOST_PP_REPEAT(nargs,BOOST_PYTHON_PROJECT_2ND,"O") ")"
-
-//
-// Implementations
-//
-namespace detail
-{
-  template <class T>
-  inline rvalue_callback_from_python<T>::rvalue_callback_from_python()
-      : m_data(rvalue_from_python_chain<T>::value)
-  {
-      throw_if_not_registered(m_data.stage1);
-  }
-  
-  template <class T>
-  inline T const& rvalue_callback_from_python<T>::operator()(PyObject* obj)
-  {
-      return *(T*)convert_rvalue(obj, m_data.stage1, m_data.storage.bytes);
-  }
-
-  BOOST_PYTHON_DECL void throw_no_class_registered();
-
-  template <class T>
-  inline reference_callback_from_python<T>::reference_callback_from_python()
-  {
-      detail::throw_if_not_registered(lvalue_from_python_chain<T,true>::value);
-  }
-  
-  template <class T>
-  inline T reference_callback_from_python<T>::operator()(PyObject* obj) const
-  {
-      return python::detail::void_ptr_to_reference(
-          callback_convert_reference(obj, lvalue_from_python_chain<T,true>::value)
-          , (T(*)())0);
-  }
-
-  template <class T>
-  inline pointer_callback_from_python<T>::pointer_callback_from_python()
-  {
-      detail::throw_if_not_registered(lvalue_from_python_chain<T,true>::value);
-  }
-  
-  template <class T>
-  inline T pointer_callback_from_python<T>::operator()(PyObject* obj) const
-  {
-      return T(callback_convert_pointer(obj, lvalue_from_python_chain<T,true>::value));
-  }
-
-  template <class T>
-  inline value_callback_to_python<T>::value_callback_to_python(T const& x)
-      : callback_to_python_base(&x, to_python_function<T>::value)
-  {
-  }
-
-  template <class Ptr>
-  inline pointer_deep_callback_to_python<Ptr>::pointer_deep_callback_to_python(Ptr x)
-      : callback_to_python_base(x, pointee_to_python_function<Ptr>::value)
-  {
-  }
-
-  template <class T>
-  inline PyObject* reference_callback_to_python<T>::get_object(T& x)
-  {
-      to_python_indirect<T&,python::detail::make_reference_holder> convert;
-      if (!convert.convertible())
-          throw_no_class_registered();
-      return convert(x);
-  }
-
-  template <class T>
-  inline reference_callback_to_python<T>::reference_callback_to_python(T& x)
-      : callback_to_python_holder(get_object(x))
-  {
-  }
-
-  template <class Ptr>
-  inline pointer_shallow_callback_to_python<Ptr>::pointer_shallow_callback_to_python(Ptr x)
-      : callback_to_python_holder(get_object(x))
-  {}
-
-  template <class Ptr>
-  inline PyObject* pointer_shallow_callback_to_python<Ptr>::get_object(Ptr x)
-  {
-      to_python_indirect<Ptr,python::detail::make_reference_holder> convert;
-      if (!convert.convertible())
-          throw_no_class_registered();
-      return x ? convert(x) : python::detail::none();
-  }
-}
-
-template <class T>
-inline callback_to_python<T>::callback_to_python(T const& x)
-    : base(x)
-{}
-
-}}} // namespace boost::python::converter
-
-#endif // CALLBACK_DWA2002228_HPP

include/boost/python/converter/callback_from_python_base.hpp

@@ -1,25 +0,0 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef CALLBACK_FROM_PYTHON_BASE_DWA200237_HPP
-# define CALLBACK_FROM_PYTHON_BASE_DWA200237_HPP
-
-namespace boost { namespace python { namespace converter { 
-
-namespace detail
-{
-
-  // Throw an exception
-  BOOST_PYTHON_DECL void throw_if_not_registered(rvalue_stage1_data const&);
-  BOOST_PYTHON_DECL void* convert_rvalue(PyObject*, rvalue_stage1_data& data, void* storage);
-  
-  BOOST_PYTHON_DECL void throw_if_not_registered(lvalue_from_python_registration*const&);
-  BOOST_PYTHON_DECL void* callback_convert_reference(PyObject*, lvalue_from_python_registration*const&);
-  BOOST_PYTHON_DECL void* callback_convert_pointer(PyObject*, lvalue_from_python_registration*const&);
-}
-
-}}} // namespace boost::python::converter
-
-#endif // CALLBACK_FROM_PYTHON_BASE_DWA200237_HPP

include/boost/python/converter/callback_to_python_base.hpp

@@ -1,45 +0,0 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef CALLBACK_TO_PYTHON_BASE_DWA200237_HPP
-# define CALLBACK_TO_PYTHON_BASE_DWA200237_HPP
-# include <boost/python/converter/to_python_function_type.hpp>
-# include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/reference.hpp>
-
-namespace boost { namespace python { namespace converter {
-
-namespace detail
-{
-  struct callback_to_python_holder
-  {
-      callback_to_python_holder(PyObject* obj);
-      inline PyObject* get() const;
-   private:
-      ref m_held;
-  };
-  
-  struct BOOST_PYTHON_DECL callback_to_python_base : callback_to_python_holder
-  {
-      callback_to_python_base(void const volatile* source, to_python_function_t);
-  };
-
-  //
-  // implmentation
-  //
-  inline callback_to_python_holder::callback_to_python_holder(PyObject* obj)
-      : m_held(obj)
-  {
-  }
-  
-  inline PyObject* callback_to_python_holder::get() const
-  {
-      return m_held.get();
-  }
-}
-
-}}} // namespace boost::python::converter
-
-#endif // CALLBACK_TO_PYTHON_BASE_DWA200237_HPP

include/boost/python/converter/constructor_function.hpp

@@ -1,8 +1,7 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 CONSTRUCTOR_FUNCTION_DWA200278_HPP
 # define CONSTRUCTOR_FUNCTION_DWA200278_HPP
 

include/boost/python/converter/context_result_converter.hpp

@@ -0,0 +1,17 @@
+// Copyright David Abrahams 2003.
+// 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 CONTEXT_RESULT_CONVERTER_DWA2003917_HPP
+# define CONTEXT_RESULT_CONVERTER_DWA2003917_HPP
+
+namespace boost { namespace python { namespace converter { 
+
+// A ResultConverter base class used to indicate that this result
+// converter should be constructed with the original Python argument
+// list.
+struct context_result_converter {};
+
+}}} // namespace boost::python::converter
+
+#endif // CONTEXT_RESULT_CONVERTER_DWA2003917_HPP

include/boost/python/converter/convertible_function.hpp

@@ -1,8 +1,7 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 CONVERTIBLE_FUNCTION_DWA200278_HPP
 # define CONVERTIBLE_FUNCTION_DWA200278_HPP
 

include/boost/python/converter/find_from_python.hpp

@@ -1,29 +0,0 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef FIND_FROM_PYTHON_DWA2002223_HPP
-# define FIND_FROM_PYTHON_DWA2002223_HPP
-
-# include <boost/python/detail/config.hpp>
-# include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/converter/from_python_stage1_data.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-struct lvalue_from_python_registration;
-struct rvalue_from_python_registration;
-
-BOOST_PYTHON_DECL void* find(
-    PyObject* source, lvalue_from_python_registration const*);
-
-BOOST_PYTHON_DECL rvalue_stage1_data find(
-    PyObject* source, rvalue_from_python_registration const*);
-
-BOOST_PYTHON_DECL rvalue_from_python_registration const* find_chain(
-    PyObject* source, rvalue_from_python_registration const*);
-
-}}} // namespace boost::python::converter
-
-#endif // FIND_FROM_PYTHON_DWA2002223_HPP

include/boost/python/converter/from_python.hpp

@@ -1,24 +1,22 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 FIND_FROM_PYTHON_DWA2002223_HPP
 # define FIND_FROM_PYTHON_DWA2002223_HPP
 
-# include <boost/python/detail/config.hpp>
-# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/detail/prefix.hpp>
 # include <boost/python/converter/rvalue_from_python_data.hpp>
 
 namespace boost { namespace python { namespace converter { 
 
 struct registration;
-struct rvalue_from_python_chain;
+
 
 BOOST_PYTHON_DECL void* get_lvalue_from_python(
     PyObject* source, registration const&);
 
-BOOST_PYTHON_DECL rvalue_from_python_chain const* implicit_conversion_chain(
+BOOST_PYTHON_DECL bool implicit_rvalue_convertible_from_python(
     PyObject* source, registration const&);
 
 BOOST_PYTHON_DECL rvalue_from_python_stage1_data rvalue_from_python_stage1(

include/boost/python/converter/from_python_data.hpp

@@ -1,129 +0,0 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef FROM_PYTHON_AUX_DATA_DWA2002128_HPP
-# define FROM_PYTHON_AUX_DATA_DWA2002128_HPP
-
-# include <boost/python/detail/char_array.hpp>
-# include <boost/mpl/select_if.hpp>
-# include <boost/type_traits/same_traits.hpp>
-# include <boost/type_traits/transform_traits.hpp>
-# include <boost/static_assert.hpp>
-# include <boost/python/converter/from_python_stage1_data.hpp>
-# include <boost/type_traits/composite_traits.hpp>
-# include <boost/type_traits/cv_traits.hpp>
-# include <boost/python/detail/destroy.hpp>
-# include <boost/preprocessor/list/for_each_i.hpp>
-# include <boost/preprocessor/tuple/to_list.hpp>
-# include <boost/preprocessor/cat.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-namespace detail
-{
-  template <class T> struct referent_size;
-  
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-  
-  template <class T>
-  struct referent_size<T&>
-  {
-      BOOST_STATIC_CONSTANT(
-          std::size_t, value = sizeof(T));
-  };
-
-# else
-
-  template <class T> struct referent_size
-  {
-      static T f();
-      BOOST_STATIC_CONSTANT(std::size_t, value = sizeof(f()));
-  };
-  
-# endif
-  struct alignment_dummy;
-  typedef void (*function_ptr)();
-  typedef int (alignment_dummy::*member_ptr);
-  typedef int (alignment_dummy::*member_function_ptr)();
-
-# define BOOST_PYTHON_ALIGNMENT_TYPES BOOST_PP_TUPLE_TO_LIST( \
-        11, ( \
-        char, short, int, long, float, double, long double \
-        , void*, function_ptr, member_ptr, member_function_ptr))
-
-# define BOOST_PYTHON_CHOOSE_LOWER_SIZE(R,P,I,T) \
-        typename mpl::select_if_c< \
-           sizeof(T) <= target, T, char>::type BOOST_PP_CAT(t,I);
-           
-# define BOOST_PYTHON_CHOOSE_T(R,P,I,T) T BOOST_PP_CAT(t,I);
-           
-  template <std::size_t target>
-  union lower_size
-  {
-      BOOST_PP_LIST_FOR_EACH_I(
-          BOOST_PYTHON_CHOOSE_LOWER_SIZE
-          , ignored, BOOST_PYTHON_ALIGNMENT_TYPES)
-  };
-
-  template <class Align, std::size_t size>
-  union aligned_storage
-  {
-      Align align;
-      char bytes[size];
-  };
-
-  template <class Reference>
-  struct referent_storage
-  {
-      typedef lower_size<referent_size<Reference>::value> align_t;
-      typedef aligned_storage<align_t,referent_size<Reference>::value> type;
-  };
-}
-
-template <class T>
-struct rvalue_base_data
-{
-    rvalue_stage1_data stage1;
-    
-    typename detail::referent_storage<
-        typename add_reference<T>::type
-    >::type storage;
-};
-
-template <class T>
-struct rvalue_data : rvalue_base_data<T>
-{
-    rvalue_data(rvalue_stage1_data const&);
-    rvalue_data(void*);
-    ~rvalue_data();
- private:
-    typedef typename add_reference<typename add_cv<T>::type>::type ref_type;
-};
-
-//
-// Implementataions
-//
-template <class T>
-inline rvalue_data<T>::rvalue_data(rvalue_stage1_data const& stage1)
-{
-    this->stage1 = stage1;
-}
-
-template <class T>
-inline rvalue_data<T>::rvalue_data(void* convertible)
-{
-    this->stage1.convertible = convertible;
-}
-
-template <class T>
-inline rvalue_data<T>::~rvalue_data()
-{
-    if (this->stage1.convertible == this->storage.bytes)
-        python::detail::destroy_reference<ref_type>(this->storage.bytes);
-}
-
-}}} // namespace boost::python::converter
-
-#endif // FROM_PYTHON_AUX_DATA_DWA2002128_HPP

include/boost/python/converter/from_python_function.hpp

@@ -1,18 +0,0 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef FROM_PYTHON_FUNCTION_DWA2002128_HPP
-# define FROM_PYTHON_FUNCTION_DWA2002128_HPP
-
-# include <boost/python/detail/wrap_python.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-struct rvalue_stage1_data;
-typedef void (*constructor_function)(PyObject* source, rvalue_stage1_data*);
-
-}}} // namespace boost::python::converter
-
-#endif // FROM_PYTHON_FUNCTION_DWA2002128_HPP

include/boost/python/converter/from_python_stage1_data.hpp

@@ -1,21 +0,0 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef FROM_PYTHON_STAGE1_DATA_DWA2002223_HPP
-# define FROM_PYTHON_STAGE1_DATA_DWA2002223_HPP
-
-# include <boost/python/converter/from_python_function.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-struct rvalue_stage1_data
-{
-    void* convertible;
-    constructor_function construct;
-};
-
-}}} // namespace boost::python::converter
-
-#endif // FROM_PYTHON_STAGE1_DATA_DWA2002223_HPP

include/boost/python/converter/implicit.hpp

@@ -1,14 +1,16 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 IMPLICIT_DWA2002326_HPP
 # define IMPLICIT_DWA2002326_HPP
+
 # include <boost/python/converter/rvalue_from_python_data.hpp>
 # include <boost/python/converter/registrations.hpp>
 # include <boost/python/converter/registered.hpp>
 
+# include <boost/python/extract.hpp>
+
 namespace boost { namespace python { namespace converter { 
 
 template <class Source, class Target>
@@ -16,39 +18,22 @@ struct implicit
 {
     static void* convertible(PyObject* obj)
     {
-        // Find a converter chain which can produce a Source instance
-        // from obj. The user has told us that Source can be converted
-        // to Target, and instantiating construct() below, ensures
-        // that at compile-time.
-        return const_cast<rvalue_from_python_chain*>(
-            converter::implicit_conversion_chain(obj, registered<Source>::converters));
+        // Find a converter which can produce a Source instance from
+        // obj. The user has told us that Source can be converted to
+        // Target, and instantiating construct() below, ensures that
+        // at compile-time.
+        return implicit_rvalue_convertible_from_python(obj, registered<Source>::converters)
+            ? obj : 0;
     }
       
     static void construct(PyObject* obj, rvalue_from_python_stage1_data* data)
     {
-        // This is the chain we got from the convertible step
-        rvalue_from_python_chain const* chain
-            = static_cast<rvalue_from_python_chain*>(data->convertible);
-
-        // Call the convertible function again
-        rvalue_from_python_data<Source> intermediate_data(chain->convertible(obj));
-          
-        // Use the result to construct the source type if the first
-        // converter was an rvalue converter.
-        if (chain->construct != 0)
-            chain->construct(obj, &intermediate_data.stage1);
-          
         void* storage = ((rvalue_from_python_storage<Target>*)data)->storage.bytes;
-#   if !defined(BOOST_MSVC) || _MSC_FULL_VER != 13012108 // vc7.01 alpha workaround
-        new (storage) Target(*static_cast<Source*>(intermediate_data.stage1.convertible));
-#   else
-        Target x(*static_cast<Source*>(intermediate_data.stage1.convertible));
-        new (storage) Target(x);
-#   endif 
-
+        
+        new (storage) Target(extract<Source>(obj)());
+        
         // record successful construction
         data->convertible = storage;
-          
     }
 };
 

include/boost/python/converter/lvalue_from_python_chain.hpp

@@ -1,70 +0,0 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef LVALUE_FROM_PYTHON_CHAIN_DWA200237_HPP
-# define LVALUE_FROM_PYTHON_CHAIN_DWA200237_HPP
-
-# include <boost/python/converter/pointer_type_id.hpp>
-# include <boost/python/converter/registry.hpp>
-# include <boost/type_traits/cv_traits.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-// Given T == U*cv&, T == U*, or T == U&, lvalue_from_python_chain<T>
-// declares a "templated global reference" to the lvalue from_python
-// converter chain for U. The optional bool second argument callback,
-// when true, removes special treatment for T == U*cv& so that the
-// converter for U* is found.
-namespace detail
-{
-  template <class T>
-  struct ptr_or_ptr_ref_lvalue_from_python_chain
-  {
-      static lvalue_from_python_registration*const& value;
-  };
-    
-  template <class T>
-  lvalue_from_python_registration*const&
-  ptr_or_ptr_ref_lvalue_from_python_chain<T>::value
-     = registry::lvalue_converters(pointer_type_id<T>());
-
-  template <class T>
-  struct ref_lvalue_from_python_chain
-  {
-      static lvalue_from_python_registration*const& value;
-  };
-
-  template <class T>
-  lvalue_from_python_registration*const&
-  ref_lvalue_from_python_chain<T>::value
-     = registry::lvalue_converters(undecorated_type_id<T>());
-
-  template <class T, bool callback>
-  struct select_lvalue_from_python_chain
-  {
-      BOOST_STATIC_CONSTANT(
-          bool, ptr
-          = !callback && boost::python::detail::is_reference_to_pointer<T>::value
-            || is_pointer<T>::value);
-
-      typedef typename add_reference<typename add_cv<T>::type>::type normalized;
-
-      typedef typename mpl::select_if_c<
-          ptr
-          , ptr_or_ptr_ref_lvalue_from_python_chain<normalized>
-          , ref_lvalue_from_python_chain<normalized>
-          >::type type;
-  };
-}
-
-template <class T, bool callback = false>
-struct lvalue_from_python_chain
-    : detail::select_lvalue_from_python_chain<T,callback>::type
-{
-};
-
-}}} // namespace boost::python::converter
-
-#endif // LVALUE_FROM_PYTHON_CHAIN_DWA200237_HPP

include/boost/python/converter/obj_mgr_arg_from_python.hpp

@@ -1,12 +1,11 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 OBJ_MGR_ARG_FROM_PYTHON_DWA2002628_HPP
 # define OBJ_MGR_ARG_FROM_PYTHON_DWA2002628_HPP
 
-# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/detail/prefix.hpp>
 # include <boost/python/detail/referent_storage.hpp>
 # include <boost/python/detail/destroy.hpp>
 # include <boost/python/detail/construct.hpp>
@@ -27,7 +26,7 @@ struct object_manager_value_arg_from_python
     
     object_manager_value_arg_from_python(PyObject*);
     bool convertible() const;
-    T operator()(PyObject*) const;
+    T operator()() const;
  private:
     PyObject* m_source;
 };
@@ -48,7 +47,7 @@ struct object_manager_ref_arg_from_python
     
     object_manager_ref_arg_from_python(PyObject*);
     bool convertible() const;
-    Ref operator()(PyObject*) const;
+    Ref operator()() const;
     ~object_manager_ref_arg_from_python();
  private:
     typename python::detail::referent_storage<Ref>::type m_result;
@@ -71,15 +70,21 @@ inline bool object_manager_value_arg_from_python<T>::convertible() const
 }
 
 template <class T>
-inline T object_manager_value_arg_from_python<T>::operator()(PyObject* x) const
+inline T object_manager_value_arg_from_python<T>::operator()() const
 {
-    return T(python::detail::borrowed_reference(x));
+    return T(python::detail::borrowed_reference(m_source));
 }
 
 template <class Ref>
 inline object_manager_ref_arg_from_python<Ref>::object_manager_ref_arg_from_python(PyObject* x)
 {
-    python::detail::construct_referent<Ref>(&m_result.bytes, python::detail::borrowed_reference(x));
+# if defined(__EDG_VERSION__) && __EDG_VERSION__ <= 243
+    // needed for warning suppression
+    python::detail::borrowed_reference x_ = python::detail::borrowed_reference(x);
+    python::detail::construct_referent<Ref>(&m_result.bytes, x_);
+# else 
+    python::detail::construct_referent<Ref>(&m_result.bytes, (python::detail::borrowed_reference)x);
+# endif 
 }
 
 template <class Ref>
@@ -105,7 +110,7 @@ inline bool object_manager_ref_arg_from_python<Ref>::convertible() const
 }
 
 template <class Ref>
-inline Ref object_manager_ref_arg_from_python<Ref>::operator()(PyObject*) const
+inline Ref object_manager_ref_arg_from_python<Ref>::operator()() const
 {
     return python::detail::void_ptr_to_reference(
         this->m_result.bytes, (Ref(*)())0);

include/boost/python/converter/object_manager.hpp

@@ -1,8 +1,7 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 OBJECT_MANAGER_DWA2002614_HPP
 # define OBJECT_MANAGER_DWA2002614_HPP
 
@@ -12,6 +11,7 @@
 # include <boost/type_traits/object_traits.hpp>
 # include <boost/mpl/if.hpp>
 # include <boost/python/detail/indirect_traits.hpp>
+# include <boost/mpl/bool.hpp>
 
 // Facilities for dealing with types which always manage Python
 // objects. Some examples are object, list, str, et. al. Different
@@ -117,16 +117,15 @@ struct object_manager_traits
 
 template <class T>
 struct is_object_manager
+    : mpl::bool_<object_manager_traits<T>::is_specialized>
 {
-    BOOST_STATIC_CONSTANT(
-        bool, value = object_manager_traits<T>::is_specialized);
 };
 
 # ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template <class T>
 struct is_reference_to_object_manager
+    : mpl::false_
 {
-    BOOST_STATIC_CONSTANT(bool, value = false);
 };
 
 template <class T>
@@ -164,8 +163,8 @@ namespace detail
   template <class T>
   struct is_object_manager_help
   {
-      typedef typename mpl::if_c<
-          is_object_manager<T>::value
+      typedef typename mpl::if_<
+          is_object_manager<T>
           , yes_reference_to_object_manager
           , no_reference_to_object_manager
           >::type type;
@@ -197,8 +196,8 @@ namespace detail
   
   template <class T>
   struct is_reference_to_object_manager_nonref
+      : mpl::false_
   {
-      BOOST_STATIC_CONSTANT(bool, value = false);
   };
 
   template <class T>
@@ -211,19 +210,18 @@ namespace detail
             == sizeof(detail::yes_reference_to_object_manager)
           )
         );
+      typedef mpl::bool_<value> type;
   };
 }
 
 template <class T>
 struct is_reference_to_object_manager
-{
-    typedef typename mpl::if_c<
-        is_reference<T>::value
+    : mpl::if_<
+        is_reference<T>
         , detail::is_reference_to_object_manager_ref<T>
         , detail::is_reference_to_object_manager_nonref<T>
-    > chooser;
-
-    BOOST_STATIC_CONSTANT(bool, value = chooser::type::value);
+    >::type
+{
 };
 # endif 
 

include/boost/python/converter/pointee_to_python_function.hpp

@@ -1,51 +0,0 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef POINTEE_TO_PYTHON_FUNCTION_DWA2002128_HPP
-# define POINTEE_TO_PYTHON_FUNCTION_DWA2002128_HPP
-
-# include <boost/python/detail/wrap_python.hpp>
-# include <boost/type_traits/transform_traits.hpp>
-# include <boost/type_traits/cv_traits.hpp>
-# include <boost/python/converter/type_id.hpp>
-# include <boost/python/converter/registry.hpp>
-# include <boost/python/converter/to_python_function_type.hpp>
-# include <boost/python/converter/pointer_type_id.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-// pointee_to_python_function --
-//
-// essentially a "templated global reference" which holds the
-// converter for converting a type to Python by-value. We "normalize"
-// T by adding "const volatile&" so that fewer global variables and
-// associated static initializations are generated.
-namespace detail
-{
-  template <class T>
-  struct pointee_to_python_function_base
-  {
-      static to_python_function_t const& value;
-  };
-  
-  template <class T>
-  to_python_function_t const&
-  pointee_to_python_function_base<T>::value
-        = converter::registry::get_to_python_function(pointer_type_id<T>());
-}
-
-template <class T>
-struct pointee_to_python_function
-    : detail::pointee_to_python_function_base<
-        typename add_reference<
-          typename add_cv<T>::type
-        >::type
-      >
-{
-};
-
-}}} // namespace boost::python::converter
-
-#endif // POINTEE_TO_PYTHON_FUNCTION_DWA2002128_HPP

include/boost/python/converter/pointer_type_id.hpp

@@ -1,8 +1,7 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 POINTER_TYPE_ID_DWA2002222_HPP
 # define POINTER_TYPE_ID_DWA2002222_HPP
 

include/boost/python/converter/pyobject_traits.hpp

@@ -1,12 +1,11 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 PYOBJECT_TRAITS_DWA2002720_HPP
 # define PYOBJECT_TRAITS_DWA2002720_HPP
 
-# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/detail/prefix.hpp>
 # include <boost/python/converter/pyobject_type.hpp>
 
 namespace boost { namespace python { namespace converter { 

include/boost/python/converter/pyobject_type.hpp

@@ -1,12 +1,10 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 PYOBJECT_TYPE_DWA2002720_HPP
 # define PYOBJECT_TYPE_DWA2002720_HPP
 
-# include <boost/python/detail/wrap_python.hpp>
 # include <boost/python/cast.hpp>
 
 namespace boost { namespace python { namespace converter { 

include/boost/python/converter/pytype_arg_from_python.hpp

@@ -1,99 +0,0 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef PYTYPE_ARG_FROM_PYTHON_DWA2002628_HPP
-# define PYTYPE_ARG_FROM_PYTHON_DWA2002628_HPP
-
-# include <boost/python/detail/wrap_python.hpp>
-
-//
-// arg_from_python converters for Python type wrappers, to be used as
-// base classes for specializations.
-//
-namespace boost { namespace python { namespace converter { 
-
-template <PyTypeObject* python_type>
-struct pytype_arg_from_python
-{
-    pytype_arg_from_python(PyObject*);
-    bool convertible() const;
- private:
-    PyObject* m_src;
-};
-
-// rvalue converter base
-template <class Wrapper, PyTypeObject* python_type>
-struct pytype_wrapper_value_arg_from_python
-    : pytype_arg_from_python<python_type>
-{
-    typedef Wrapper result_type;
-    
-    pytype_wrapper_value_arg_from_python(PyObject*);
-    Wrapper operator()(PyObject*) const;
-};
-
-// Special case for Wrapper& - must store an lvalue internally. This
-// OK because the entire state of the object is actually in the Python
-// object.
-template <class Wrapper, PyTypeObject* python_type>
-struct pytype_wrapper_ref_arg_from_python
-    : pytype_arg_from_python<python_type>
-{
-    typedef Wrapper& result_type;
-    
-    pytype_wrapper_ref_arg_from_python(PyObject*);
-    Wrapper& operator()(PyObject*) const;
- private:
-    mutable Wrapper m_result;
-};
-
-//
-// implementations
-//
-
-template <PyTypeObject* python_type>
-inline pytype_arg_from_python<python_type>::pytype_arg_from_python(PyObject* x)
-    : m_src(x)
-{
-}
-
-template <PyTypeObject* python_type>
-inline bool pytype_arg_from_python<python_type>::convertible() const
-{
-    return PyObject_IsInstance(m_src, (PyObject*)python_type);
-}
-
-template <class Wrapper, PyTypeObject* python_type>
-pytype_wrapper_value_arg_from_python<Wrapper,python_type>::pytype_wrapper_value_arg_from_python(
-    PyObject* p)
-    : pytype_arg_from_python<python_type>(p)
-{
-}
-
-template <class Wrapper, PyTypeObject* python_type>
-Wrapper pytype_wrapper_value_arg_from_python<Wrapper,python_type>::operator()(
-    PyObject* x) const
-{
-    return Wrapper(python::detail::borrowed_reference(x));
-}
-
-template <class Wrapper, PyTypeObject* python_type>
-pytype_wrapper_ref_arg_from_python<Wrapper,python_type>::pytype_wrapper_ref_arg_from_python(
-    PyObject* p)
-    : pytype_arg_from_python<python_type>(p)
-      , m_result(python::detail::borrowed_reference(p))
-{
-}
-
-template <class Wrapper, PyTypeObject* python_type>
-Wrapper& pytype_wrapper_ref_arg_from_python<Wrapper,python_type>::operator()(
-    PyObject* x) const
-{
-    return m_result;
-}
-
-}}} // namespace boost::python::converter
-
-#endif // PYTYPE_ARG_FROM_PYTHON_DWA2002628_HPP

include/boost/python/converter/pytype_object_mgr_traits.hpp

@@ -1,14 +1,13 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 PYTYPE_OBJECT_MANAGER_TRAITS_DWA2002716_HPP
 # define PYTYPE_OBJECT_MANAGER_TRAITS_DWA2002716_HPP
 
+# include <boost/python/detail/prefix.hpp>
 # include <boost/python/detail/raw_pyobject.hpp>
 # include <boost/python/cast.hpp>
-# include <boost/python/detail/wrap_python.hpp>
 # include <boost/python/converter/pyobject_type.hpp>
 # include <boost/python/errors.hpp>
 

include/boost/python/converter/registered.hpp

@@ -1,8 +1,7 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 REGISTERED_DWA2002710_HPP
 # define REGISTERED_DWA2002710_HPP
 # include <boost/python/type_id.hpp>
@@ -10,8 +9,16 @@
 # include <boost/python/converter/registrations.hpp>
 # include <boost/type_traits/transform_traits.hpp>
 # include <boost/type_traits/cv_traits.hpp>
+# include <boost/detail/workaround.hpp>
 
-namespace boost { namespace python { namespace converter { 
+namespace boost {
+
+// You'll see shared_ptr mentioned in this header because we need to
+// note which types are shared_ptrs in their registrations, to
+// implement special shared_ptr handling for rvalue conversions.
+template <class T> class shared_ptr;
+
+namespace python { namespace converter { 
 
 struct registration;
 
@@ -26,18 +33,23 @@ namespace detail
 
 template <class T>
 struct registered
-    : detail::registered_base<
+  : detail::registered_base<
         typename add_reference<
-           typename add_cv<T>::type
+            typename add_cv<T>::type
         >::type
     >
 {
 };
 
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-// collapses a few more types to the same static instance
+# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
+    && !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
+// collapses a few more types to the same static instance.  MSVC7.1
+// fails to strip cv-qualification from array types in typeid.  For
+// some reason we can't use this collapse there or array converters
+// will not be found.
 template <class T>
-struct registered<T&> : registered<T> {};
+struct registered<T&>
+  : registered<T> {};
 # endif
 
 //
@@ -45,10 +57,37 @@ struct registered<T&> : registered<T> {};
 //
 namespace detail
 {
+  inline void
+  register_shared_ptr0(...)
+  {
+  }
+  
   template <class T>
-  registration const& registered_base<T>::converters
-     = registry::lookup(type_id<T>());
+  inline void
+  register_shared_ptr0(shared_ptr<T>*)
+  {
+      registry::lookup_shared_ptr(type_id<shared_ptr<T> >());
+  }
+  
+  template <class T>
+  inline void
+  register_shared_ptr1(T const volatile*)
+  {
+      detail::register_shared_ptr0((T*)0);
+  }
+  
+  template <class T>
+  registration const& 
+  registry_lookup(T&(*)())
+  {
+      detail::register_shared_ptr1((T*)0);
+      return registry::lookup(type_id<T&>());
+  }
+
+  template <class T>
+  registration const& registered_base<T>::converters = detail::registry_lookup((T(*)())0);
 }
+
 }}} // namespace boost::python::converter
 
 #endif // REGISTERED_DWA2002710_HPP

include/boost/python/converter/registered_pointee.hpp

@@ -1,8 +1,7 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 REGISTERED_POINTEE_DWA2002710_HPP
 # define REGISTERED_POINTEE_DWA2002710_HPP
 # include <boost/python/converter/registered.hpp>

include/boost/python/converter/registrations.hpp

@@ -1,16 +1,19 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 REGISTRATIONS_DWA2002223_HPP
 # define REGISTRATIONS_DWA2002223_HPP
 
-# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/detail/prefix.hpp>
+
+# include <boost/python/type_id.hpp>
+
 # include <boost/python/converter/convertible_function.hpp>
 # include <boost/python/converter/constructor_function.hpp>
 # include <boost/python/converter/to_python_function_type.hpp>
-# include <boost/python/type_id.hpp>
+
+# include <boost/detail/workaround.hpp>
 
 namespace boost { namespace python { namespace converter { 
 
@@ -27,10 +30,19 @@ struct rvalue_from_python_chain
     rvalue_from_python_chain* next;
 };
 
-struct registration
+struct BOOST_PYTHON_DECL registration
 {
-    explicit registration(type_info);
+ public: // member functions
+    explicit registration(type_info target, bool is_shared_ptr = false);
     
+    // Convert the appropriately-typed data to Python
+    PyObject* to_python(void const volatile*) const;
+
+    // Return the class object, or raise an appropriate Python
+    // exception if no class has been registered.
+    PyTypeObject* get_class_object() const;
+
+ public: // data members. So sue me.
     const python::type_info target_type;
 
     // The chain of eligible from_python converters when an lvalue is required
@@ -39,22 +51,32 @@ struct registration
     // The chain of eligible from_python converters when an rvalue is acceptable
     rvalue_from_python_chain* rvalue_chain;
     
-    // The unique to_python converter for the associated C++ type.
-    to_python_function_t to_python;
-
     // The class object associated with this type
-    PyTypeObject* class_object;
+    PyTypeObject* m_class_object;
+
+    // The unique to_python converter for the associated C++ type.
+    to_python_function_t m_to_python;
+
+    // True iff this type is a shared_ptr.  Needed for special rvalue
+    // from_python handling.
+    const bool is_shared_ptr;
+
+# if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
+ private:
+    void operator=(registration); // This is not defined, and just keeps MWCW happy.
+# endif 
 };
 
 //
 // implementations
 //
-inline registration::registration(type_info target_type)
+inline registration::registration(type_info target_type, bool is_shared_ptr)
     : target_type(target_type)
       , lvalue_chain(0)
       , rvalue_chain(0)
-      , to_python(0)
-      , class_object(0)
+      , m_class_object(0)
+      , m_to_python(0)
+      , is_shared_ptr(is_shared_ptr)
 {}
 
 inline bool operator<(registration const& lhs, registration const& rhs)

include/boost/python/converter/registry.hpp

@@ -1,13 +1,10 @@
-//  Copyright David Abrahams 2001. Permission to copy, use,
-//  modify, sell and distribute this software is granted provided this
-//  copyright notice appears in all copies. This software is provided
-//  "as is" without express or implied warranty, and with no claim as
-//  to its suitability for any purpose.
+//  Copyright David Abrahams 2001.
+// 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 REGISTRY_DWA20011127_HPP
 # define REGISTRY_DWA20011127_HPP
 # include <boost/python/type_id.hpp>
-# include <boost/python/detail/config.hpp>
-# include <boost/python/detail/wrap_python.hpp>
 # include <boost/python/converter/to_python_function_type.hpp>
 # include <boost/python/converter/rvalue_from_python_data.hpp>
 # include <boost/python/converter/constructor_function.hpp>
@@ -20,9 +17,13 @@ struct registration;
 // This namespace acts as a sort of singleton
 namespace registry
 {
-  // Get the registration corresponding to the type, creating it if neccessary
+  // Get the registration corresponding to the type, creating it if necessary
   BOOST_PYTHON_DECL registration const& lookup(type_info);
 
+  // Get the registration corresponding to the type, creating it if
+  // necessary.  Use this first when the type is a shared_ptr.
+  BOOST_PYTHON_DECL registration const& lookup_shared_ptr(type_info);
+
   // Return a pointer to the corresponding registration, if one exists
   BOOST_PYTHON_DECL registration const* query(type_info);
   

include/boost/python/converter/return_from_python.hpp

@@ -1,8 +1,7 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 RETURN_FROM_PYTHON_DWA200265_HPP
 # define RETURN_FROM_PYTHON_DWA200265_HPP
 
@@ -10,9 +9,14 @@
 # include <boost/python/converter/rvalue_from_python_data.hpp>
 # include <boost/python/converter/registered.hpp>
 # include <boost/python/converter/registered_pointee.hpp>
+# include <boost/python/converter/object_manager.hpp>
 # include <boost/python/detail/void_ptr.hpp>
-# include <boost/call_traits.hpp>
 # include <boost/python/detail/void_return.hpp>
+# include <boost/python/errors.hpp>
+# include <boost/python/handle.hpp>
+# include <boost/type_traits/has_trivial_copy.hpp>
+# include <boost/mpl/and.hpp>
+# include <boost/mpl/bool.hpp>
 
 namespace boost { namespace python { namespace converter { 
 
@@ -37,7 +41,8 @@ namespace detail
   template <class T>
   struct return_rvalue_from_python
   {
-      typedef typename call_traits<T>::param_type result_type;
+      typedef T result_type;
+
       return_rvalue_from_python();
       result_type operator()(PyObject*);
    private:
@@ -117,6 +122,12 @@ namespace detail
   inline typename return_rvalue_from_python<T>::result_type
   return_rvalue_from_python<T>::operator()(PyObject* obj)
   {
+    // Take possession of the source object here.  If the result is in
+    // fact going to be a copy of an lvalue embedded in the object,
+    // and we take possession inside rvalue_result_from_python, it
+    // will be destroyed too early.
+    handle<> holder(obj);
+
       return *(T*)
           (rvalue_result_from_python)(obj, m_data.stage1);
   }
@@ -141,7 +152,7 @@ namespace detail
   inline T return_object_manager_from_python<T>::operator()(PyObject* obj) const
   {
       return T(
-          object_manager_traits<T>::adopt(obj)
+          object_manager_traits<T>::adopt(expect_non_null(obj))
           );
   }
 }

include/boost/python/converter/rvalue_from_python_chain.hpp

@@ -1,39 +0,0 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef RVALUE_FROM_PYTHON_CHAIN_DWA200237_HPP
-# define RVALUE_FROM_PYTHON_CHAIN_DWA200237_HPP
-# include <boost/python/converter/registry.hpp>
-# include <boost/type_traits/transform_traits.hpp>
-# include <boost/type_traits/cv_traits.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-namespace detail
-{
-  template <class T>
-  struct rvalue_from_python_chain_impl
-  {
-      static rvalue_from_python_registration*const& value;
-  };
-
-  template <class T>
-  rvalue_from_python_registration*const& rvalue_from_python_chain_impl<T>::value
-      = registry::rvalue_converters(undecorated_type_id<T>());
-}
-
-template <class T>
-struct rvalue_from_python_chain
-    : detail::rvalue_from_python_chain_impl<
-        typename add_reference<
-          typename add_cv<T>::type
-        >::type
-      >
-{
-};
-
-}}} // namespace boost::python::converter
-
-#endif // RVALUE_FROM_PYTHON_CHAIN_DWA200237_HPP

include/boost/python/converter/rvalue_from_python_data.hpp

@@ -1,8 +1,7 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 FROM_PYTHON_AUX_DATA_DWA2002128_HPP
 # define FROM_PYTHON_AUX_DATA_DWA2002128_HPP
 
@@ -94,9 +93,10 @@ struct rvalue_from_python_data : rvalue_from_python_storage<T>
 {
 # if (!defined(__MWERKS__) || __MWERKS__ >= 0x3000) \
         && (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= 245) \
-        && (!defined(__DECCXX_VER) || __DECCXX_VER > 60590014)
+        && (!defined(__DECCXX_VER) || __DECCXX_VER > 60590014) \
+        && !defined(BOOST_PYTHON_SYNOPSIS) /* Synopsis' OpenCXX has trouble parsing this */
     // This must always be a POD struct with m_data its first member.
-    BOOST_STATIC_ASSERT(offsetof(rvalue_from_python_storage<T>,stage1) == 0);
+    BOOST_STATIC_ASSERT(BOOST_PYTHON_OFFSETOF(rvalue_from_python_storage<T>,stage1) == 0);
 # endif
     
     // The usual constructor 

include/boost/python/converter/shared_ptr_deleter.hpp

@@ -0,0 +1,22 @@
+// 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 SHARED_PTR_DELETER_DWA2002121_HPP
+# define SHARED_PTR_DELETER_DWA2002121_HPP
+
+namespace boost { namespace python { namespace converter { 
+
+struct BOOST_PYTHON_DECL shared_ptr_deleter
+{
+    shared_ptr_deleter(handle<> owner);
+    ~shared_ptr_deleter();
+
+    void operator()(void const*);
+        
+    handle<> owner;
+};
+
+}}} // namespace boost::python::converter
+
+#endif // SHARED_PTR_DELETER_DWA2002121_HPP

include/boost/python/converter/shared_ptr_from_python.hpp

@@ -0,0 +1,52 @@
+// 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 SHARED_PTR_FROM_PYTHON_DWA20021130_HPP
+# define SHARED_PTR_FROM_PYTHON_DWA20021130_HPP
+
+# include <boost/python/handle.hpp>
+# include <boost/python/converter/shared_ptr_deleter.hpp>
+# include <boost/python/converter/from_python.hpp>
+# include <boost/python/converter/rvalue_from_python_data.hpp>
+# include <boost/python/converter/registered.hpp>
+# include <boost/shared_ptr.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+template <class T>
+struct shared_ptr_from_python
+{
+    shared_ptr_from_python()
+    {
+        converter::registry::insert(&convertible, &construct, type_id<shared_ptr<T> >());
+    }
+
+ private:
+    static void* convertible(PyObject* p)
+    {
+        if (p == Py_None)
+            return p;
+        
+        return converter::get_lvalue_from_python(p, registered<T>::converters);
+    }
+    
+    static void construct(PyObject* source, rvalue_from_python_stage1_data* data)
+    {
+        void* const storage = ((converter::rvalue_from_python_storage<shared_ptr<T> >*)data)->storage.bytes;
+        // Deal with the "None" case.
+        if (data->convertible == source)
+            new (storage) shared_ptr<T>();
+        else
+            new (storage) shared_ptr<T>(
+                static_cast<T*>(data->convertible),
+                shared_ptr_deleter(handle<>(borrowed(source)))
+                );
+        
+        data->convertible = storage;
+    }
+};
+
+}}} // namespace boost::python::converter
+
+#endif // SHARED_PTR_FROM_PYTHON_DWA20021130_HPP

include/boost/python/converter/shared_ptr_to_python.hpp

@@ -0,0 +1,28 @@
+// Copyright David Abrahams 2003.
+// 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 SHARED_PTR_TO_PYTHON_DWA2003224_HPP
+# define SHARED_PTR_TO_PYTHON_DWA2003224_HPP
+
+# include <boost/python/refcount.hpp>
+# include <boost/python/converter/shared_ptr_deleter.hpp>
+# include <boost/shared_ptr.hpp>
+# include <boost/get_pointer.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+template <class T>
+PyObject* shared_ptr_to_python(shared_ptr<T> const& x)
+{
+    if (!x)
+        return python::detail::none();
+    else if (shared_ptr_deleter* d = boost::get_deleter<shared_ptr_deleter>(x))
+        return incref( get_pointer( d->owner ) );
+    else
+        return converter::registered<shared_ptr<T> const&>::converters.to_python(&x);
+}
+
+}}} // namespace boost::python::converter
+
+#endif // SHARED_PTR_TO_PYTHON_DWA2003224_HPP

include/boost/python/converter/smart_ptr.hpp

@@ -1,70 +0,0 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef SMART_PTR_DWA2002123_HPP
-# define SMART_PTR_DWA2002123_HPP
-
-# include <boost/python/converter/class.hpp>
-# include <boost/python/object/pointer_holder.hpp>
-namespace boost { namespace python { namespace converter { 
-
-template <class Pointer, class Value>
-class smart_ptr_wrapper
-    : wrapper<Pointer const&>
-{
-    smart_ptr_wrapper(ref const& type_)
-        : m_class_object(type_)
-    {
-        assert(type_->ob_type == (PyTypeObject*)class_metatype().get());
-    }
-    
-    PyObject* convert(Pointer x) const;
-    
- private:
-    ref m_class_object;
-    
-    smart_ptr_converters();
-}
-
-
-//
-// implementations
-//
-
-template <class Pointer, class Value>
-PyObject* smart_ptr_wrapper<Pointer,Value>::convert(Pointer x) const
-{
-    if (x.operator->() == 0)
-        return detail::none();
-        
-    // Don't call the type to do the construction, since that
-    // would require the registration of an __init__ copy
-    // constructor. Instead, just construct the object in place.
-    PyObject* raw_result = (PyObject*)PyObject_New(
-        instance, (PyTypeObject*)m_class_object.get());
-        
-    if (raw_result == 0)
-        return 0;
-
-    // Everything's OK; Bypass NULL checks but guard against
-    // exceptions.
-    ref result(raw_result, ref::allow_null());
-
-    // Build a value_holder to contain the object using the copy
-    // constructor
-    objects::pointer_holder<Pointer,Value>*
-        p = new objects::pointer_holder<Pointer,Value>(x);
-
-    // Install it in the instance
-    p->install(raw_result);
-
-    // Return the new result
-    return result.release();
-}
-    
-
-}}} // namespace boost::python::converter
-
-#endif // SMART_PTR_DWA2002123_HPP

include/boost/python/converter/to_python_function.hpp

@@ -1,50 +0,0 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef TO_PYTHON_FUNCTION_DWA2002128_HPP
-# define TO_PYTHON_FUNCTION_DWA2002128_HPP
-
-# include <boost/python/detail/wrap_python.hpp>
-# include <boost/type_traits/transform_traits.hpp>
-# include <boost/type_traits/cv_traits.hpp>
-# include <boost/python/converter/type_id.hpp>
-# include <boost/python/converter/registry.hpp>
-# include <boost/python/converter/to_python_function_type.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-// to_python_function --
-//
-// essentially a "templated global reference" which holds the
-// converter for converting a type to Python by-value. We "normalize"
-// T by adding "const volatile&" so that fewer global variables and
-// associated static initializations are generated.
-namespace detail
-{
-  template <class T>
-  struct to_python_function_base
-  {
-      static to_python_function_t const& value;
-  };
-  
-  template <class T>
-  to_python_function_t const&
-  to_python_function_base<T>::value
-        = converter::registry::get_to_python_function(undecorated_type_id<T>());
-}
-
-template <class T>
-struct to_python_function
-    : detail::to_python_function_base<
-        typename add_reference<
-          typename add_cv<T>::type
-        >::type
-      >
-{
-};
-
-}}} // namespace boost::python::converter
-
-#endif // TO_PYTHON_FUNCTION_DWA2002128_HPP

include/boost/python/converter/to_python_function_type.hpp

@@ -1,11 +1,11 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 TO_PYTHON_FUNCTION_TYPE_DWA200236_HPP
 # define TO_PYTHON_FUNCTION_TYPE_DWA200236_HPP
-# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/detail/prefix.hpp>
+# include <boost/static_assert.hpp>
 
 namespace boost { namespace python { namespace converter { 
 
@@ -14,17 +14,6 @@ namespace boost { namespace python { namespace converter {
 // type-safety is preserved through runtime registration.
 typedef PyObject* (*to_python_function_t)(void const*);
 
-// Given a typesafe to_python conversion function, produces a
-// to_python_function_t which can be registered in the usual way.
-template <class T, class ToPython>
-struct as_to_python_function
-{
-    static PyObject* convert(void const* x)
-    {
-        return ToPython::convert(*(T const*)x);
-    }
-};
-
 }}} // namespace boost::python::converter
 
 #endif // TO_PYTHON_FUNCTION_TYPE_DWA200236_HPP

include/boost/python/converter/type_id.hpp

@@ -1,176 +0,0 @@
-//  Copyright David Abrahams 2001. Permission to copy, use,
-//  modify, sell and distribute this software is granted provided this
-//  copyright notice appears in all copies. This software is provided
-//  "as is" without express or implied warranty, and with no claim as
-//  to its suitability for any purpose.
-#ifndef TYPE_ID_DWA20011127_HPP
-# define TYPE_ID_DWA20011127_HPP
-# include <boost/python/detail/config.hpp>
-# include <boost/python/detail/indirect_traits.hpp>
-# include <boost/python/detail/msvc_typeinfo.hpp>
-# include <boost/type_traits/cv_traits.hpp>
-# include <boost/type_traits/composite_traits.hpp>
-# include <boost/mpl/select_if.hpp>
-# include <boost/operators.hpp>
-# include <boost/type.hpp>
-# include <typeinfo>
-# include <iosfwd>
-# include <cstring>
-
-
-namespace boost { namespace python { namespace converter { 
-
-// for this compiler at least, cross-shared-library type_info
-// comparisons don't work, so use typeid(x).name() instead. It's not
-// yet clear what the best default strategy is.
-# if defined(__GNUC__) && __GNUC__ >= 3
-#  define BOOST_PYTHON_TYPE_ID_NAME
-# endif 
-
-// type ids which represent the same information as std::type_info
-// (i.e. the top-level reference and cv-qualifiers are stripped), but
-// which works across shared libraries.
-struct undecorated_type_id_t : totally_ordered<undecorated_type_id_t>
-{
-    undecorated_type_id_t(std::type_info const&);
-    
-    // default constructor needed to build arrays, etc.
-    undecorated_type_id_t();
-
-    bool operator<(undecorated_type_id_t const& rhs) const;
-    bool operator==(undecorated_type_id_t const& rhs) const;
-
-    char const* name() const;
-    friend BOOST_PYTHON_DECL std::ostream& operator<<(
-        std::ostream&, undecorated_type_id_t const&);
-    
- private: // data members
-#  ifdef BOOST_PYTHON_TYPE_ID_NAME
-    typedef char const* base_id_t;
-#  else
-    typedef std::type_info const* base_id_t;
-#  endif
-    
-    base_id_t m_base_type;
-};
-
-struct type_id_t : totally_ordered<type_id_t>
-{
-    enum decoration { const_ = 0x1, volatile_ = 0x2, reference = 0x4 };
-    
-    type_id_t(undecorated_type_id_t, decoration = decoration());
-
-    bool operator<(type_id_t const& rhs) const;
-    bool operator==(type_id_t const& rhs) const;
-
-    friend BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream&, type_id_t const&);
-
-    operator undecorated_type_id_t const&() const;
- private: // type
-    typedef undecorated_type_id_t base_id_t;
-    
- private: // data members
-    decoration m_decoration;
-    base_id_t m_base_type;
-};
-
-template <class T>
-inline undecorated_type_id_t undecorated_type_id(boost::type<T>* = 0)
-{
-    return undecorated_type_id_t(
-#  if (!defined(BOOST_MSVC) || BOOST_MSVC > 1300) && (!defined(BOOST_INTEL_CXX_VERSION) || BOOST_INTEL_CXX_VERSION > 600)
-        typeid(T)
-#  else // strip the decoration which msvc and Intel mistakenly leave in
-        python::detail::msvc_typeid<T>()
-#  endif 
-        );
-}
-
-template <class T>
-inline type_id_t type_id(boost::type<T>* = 0)
-{
-    return type_id_t(
-        undecorated_type_id<T>()
-        , type_id_t::decoration(
-            (is_const<T>::value || python::detail::is_reference_to_const<T>::value
-             ? type_id_t::const_ : 0)
-            | (is_volatile<T>::value || python::detail::is_reference_to_volatile<T>::value
-               ? type_id_t::volatile_ : 0)
-            | (is_reference<T>::value ? type_id_t::reference : 0)
-            )
-        );
-}
-
-inline undecorated_type_id_t::undecorated_type_id_t(std::type_info const& id)
-    : m_base_type(
-#  ifdef BOOST_PYTHON_TYPE_ID_NAME
-        id.name()
-#  else
-        &id
-#  endif
-        )
-{
-}
-
-inline undecorated_type_id_t::undecorated_type_id_t()
-    : m_base_type()
-{
-}
-
-inline type_id_t::type_id_t(undecorated_type_id_t base_t, decoration decoration)
-    : m_decoration(decoration)
-    , m_base_type(base_t)
-{
-}
-
-inline bool undecorated_type_id_t::operator<(undecorated_type_id_t const& rhs) const
-{
-#  ifdef BOOST_PYTHON_TYPE_ID_NAME
-    return std::strcmp(m_base_type, rhs.m_base_type) < 0;
-#  else
-    return m_base_type->before(*rhs.m_base_type);
-#  endif 
-}
-
-inline bool type_id_t::operator<(type_id_t const& rhs) const
-{
-    return m_decoration < rhs.m_decoration
-        || m_decoration == rhs.m_decoration
-           && m_base_type < rhs.m_base_type;
-}
-
-inline bool undecorated_type_id_t::operator==(undecorated_type_id_t const& rhs) const
-{
-#  ifdef BOOST_PYTHON_TYPE_ID_NAME
-    return !std::strcmp(m_base_type, rhs.m_base_type);
-#  else
-    return *m_base_type == *rhs.m_base_type;
-#  endif 
-}
-
-inline bool type_id_t::operator==(type_id_t const& rhs) const
-{
-    return m_decoration == rhs.m_decoration && m_base_type == rhs.m_base_type;
-}
-
-inline type_id_t::operator undecorated_type_id_t const&() const
-{
-    return m_base_type;
-}
-
-inline char const* undecorated_type_id_t::name() const
-{
-#  ifdef BOOST_PYTHON_TYPE_ID_NAME
-    return m_base_type;
-#  else
-    return m_base_type->name();
-#  endif 
-}
-
-
-BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream&, undecorated_type_id_t const&);
-BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream&, type_id_t const&);
-
-}}} // namespace boost::python::converter
-
-#endif // TYPE_ID_DWA20011127_HPP

include/boost/python/copy_const_reference.hpp

@@ -1,10 +1,11 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 COPY_CONST_REFERENCE_DWA2002131_HPP
 # define COPY_CONST_REFERENCE_DWA2002131_HPP
+
+# include <boost/python/detail/prefix.hpp>
 # include <boost/python/detail/indirect_traits.hpp>
 # include <boost/mpl/if.hpp>
 # include <boost/python/to_python_value.hpp>
@@ -29,9 +30,9 @@ struct copy_const_reference
     struct apply
     {
         typedef typename mpl::if_c<
-            detail::is_reference_to_const<T>::value
-            , to_python_value<T>
-            , detail::copy_const_reference_expects_a_const_reference_return_type<T>
+            indirect_traits::is_reference_to_const<T>::value
+          , to_python_value<T>
+          , detail::copy_const_reference_expects_a_const_reference_return_type<T>
         >::type type;
     };
 };

include/boost/python/copy_mutable_reference.hpp

@@ -1,41 +0,0 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef COPY_MUTABLE_REFERENCE_DWA2002131_HPP
-# define COPY_MUTABLE_REFERENCE_DWA2002131_HPP
-# include <boost/python/detail/indirect_traits.hpp>
-# include <boost/mpl/select_if.hpp>
-# include <boost/python/to_python_value.hpp>
-
-namespace boost { namespace python { 
-
-namespace detail
-{
-  template <class R>
-  struct copy_mutable_reference_expects_a_reference_to_non_const_return_type
-# if defined(__GNUC__) && __GNUC__ >= 3 || defined(__EDG__)
-  {}
-# endif
-  ;
-}
-
-template <class T> struct to_python_value;
-
-struct copy_mutable_reference
-{
-    template <class T>
-    struct apply
-    {
-        typedef typename mpl::select_if_c<
-            detail::is_reference_to_non_const<T>::value
-            , to_python_value<T>
-            , detail::copy_mutable_reference_expects_a_reference_to_non_const_return_type<T>
-        >::type type;
-    };
-};
-
-}} // namespace boost::python
-
-#endif // COPY_MUTABLE_REFERENCE_DWA2002131_HPP

include/boost/python/copy_non_const_reference.hpp

@@ -1,10 +1,11 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 COPY_NON_CONST_REFERENCE_DWA2002131_HPP
 # define COPY_NON_CONST_REFERENCE_DWA2002131_HPP
+
+# include <boost/python/detail/prefix.hpp>
 # include <boost/python/detail/indirect_traits.hpp>
 # include <boost/mpl/if.hpp>
 # include <boost/python/to_python_value.hpp>
@@ -29,7 +30,7 @@ struct copy_non_const_reference
     struct apply
     {
         typedef typename mpl::if_c<
-            boost::python::detail::is_reference_to_non_const<T>::value
+            indirect_traits::is_reference_to_non_const<T>::value
             , to_python_value<T>
             , detail::copy_non_const_reference_expects_a_non_const_reference_return_type<T>
         >::type type;

include/boost/python/cross_module.hpp

@@ -1,329 +0,0 @@
-/* (C) Copyright Ralf W. Grosse-Kunstleve 2001. Permission to copy, use,
-   modify, sell and distribute this software is granted provided this
-   copyright notice appears in all copies. This software is provided
-   "as is" without express or implied warranty, and with no claim as to
-   its suitability for any purpose.
-
-   Revision History:
-     17 Apr 01 merged into boost CVS trunk (Ralf W. Grosse-Kunstleve)
-*/
-
-/* Implementation of Boost.Python cross-module support.
-   See root/libs/python/doc/cross_module.html for details.
-*/
-
-#ifndef CROSS_MODULE_HPP
-# define CROSS_MODULE_HPP
-
-# include <boost/python/class_builder.hpp>
-
-namespace boost { namespace python {
-
-struct BOOST_PYTHON_DECL import_error: error_already_set {};
-struct BOOST_PYTHON_DECL export_error : error_already_set {};
-
-void BOOST_PYTHON_DECL throw_import_error();
-void BOOST_PYTHON_DECL throw_export_error();
-
-namespace detail
-{
-
-// Concept: throw exception if api_major is changed
-//          show warning on stderr if api_minor is changed
-  const int export_converters_api_major = 4;
-  const int export_converters_api_minor = 1;
-  extern BOOST_PYTHON_DECL const char* converters_attribute_name;
-  BOOST_PYTHON_DECL void* import_converter_object(const std::string& module_name,
-                                const std::string& py_class_name,
-                                const std::string& attribute_name);
-  BOOST_PYTHON_DECL void check_export_converters_api(const int importing_major,
-                                   const int importing_minor,
-                                   const int imported_major,
-                                   const int imported_minor);
-
-}
-
-}} // namespace boost::python
-
-// forward declaration
-namespace boost { namespace python { namespace detail {
-template <class T> class import_extension_class;
-}}}
-
-BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
-
-/* This class template is instantiated by import_converters<T>.
-   This class is a look-alike of class python_extension_class_converters.
-   The converters in this class are wrappers that call converters
-   imported from another module.
-   To ensure that the dynamic loader resolves all symbols in the
-   intended way, the signature of all friend functions is changed with
-   respect to the original functions in class
-   python_extension_class_converters by adding an arbitrary additional
-   parameter with a default value, in this case "bool sig = false".
-   See also: comments for class export_converter_object_base below.
- */
-template <class T>
-class python_import_extension_class_converters
-{
- public:
-
-    friend python_import_extension_class_converters py_extension_class_converters(boost::python::type<T>, bool sig = false) {
-        return python_import_extension_class_converters();
-    }
-
-    PyObject* to_python(const T& x) const {
-        return boost::python::detail::import_extension_class<T>::get_converters()->to_python(x);
-    }
-
-    friend T* from_python(PyObject* p, boost::python::type<T*> t, bool sig = false) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_Ts(p, t);
-    }
-    friend const T* from_python(PyObject* p, boost::python::type<const T*> t, bool sig = false) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_cTs(p, t);
-    }
-    friend const T* from_python(PyObject* p, boost::python::type<const T*const&> t, bool sig = false) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_cTscr(p, t);
-    }
-    friend T* from_python(PyObject* p, boost::python::type<T* const&> t, bool sig = false) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_Tscr(p, t);
-    }
-    friend T& from_python(PyObject* p, boost::python::type<T&> t, bool sig = false) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_Tr(p, t);
-    }
-    friend const T& from_python(PyObject* p, boost::python::type<const T&> t, bool sig = false) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_cTr(p, t);
-    }
-    friend const T& from_python(PyObject* p, boost::python::type<T> t, bool sig = false) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_T(p, t);
-    }
-
-    friend std::auto_ptr<T>& from_python(PyObject* p, boost::python::type<std::auto_ptr<T>&> t, bool sig = false) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_aTr(p, t);
-    }
-    friend std::auto_ptr<T> from_python(PyObject* p, boost::python::type<std::auto_ptr<T> > t, bool sig = false) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_aT(p, t);
-    }
-    friend const std::auto_ptr<T>& from_python(PyObject* p, boost::python::type<const std::auto_ptr<T>&> t, bool sig = false) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_caTr(p, t);
-    }
-    friend PyObject* to_python(std::auto_ptr<T> x, bool sig = false) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->to_python(x);
-    }
-
-    friend boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<boost::shared_ptr<T>&> t, bool sig = false) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_sTr(p, t);
-    }
-    friend const boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<boost::shared_ptr<T> > t, bool sig = false) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_sT(p, t);
-    }
-    friend const boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<const boost::shared_ptr<T>&> t, bool sig = false) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_csTr(p, t);
-    }
-    friend PyObject* to_python(boost::shared_ptr<T> x, bool sig = false) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->to_python(x);
-    }
-};
-
-BOOST_PYTHON_END_CONVERSION_NAMESPACE
-
-namespace boost { namespace python {
-
-BOOST_PYTHON_IMPORT_CONVERSION(python_import_extension_class_converters);
-
-/* This class template is instantiated by export_converters().
-   A pointer to this class is exported/imported via the Python API.
-   Using the Python API ensures maximum portability.
-   All member functions are virtual. This is, what we export/import
-   is essentially just a pointer to a vtbl.
-   To work around a deficiency of Visual C++ 6.0, the name of each
-   from_python() member functions is made unique by appending a few
-   characters (derived in a ad-hoc manner from the corresponding type).
- */
-template <class T>
-struct export_converter_object_base
-{
-    virtual int get_api_major() const { return detail::export_converters_api_major; }
-    virtual int get_api_minor() const { return detail::export_converters_api_minor; }
-
-    virtual PyObject* to_python(const T& x) = 0;
-
-    virtual T* from_python_Ts(PyObject* p, boost::python::type<T*> t) = 0;
-    virtual const T* from_python_cTs(PyObject* p, boost::python::type<const T*> t) = 0;
-    virtual const T* from_python_cTscr(PyObject* p, boost::python::type<const T*const&> t) = 0;
-    virtual T* from_python_Tscr(PyObject* p, boost::python::type<T* const&> t) = 0;
-    virtual T& from_python_Tr(PyObject* p, boost::python::type<T&> t) = 0;
-    virtual const T& from_python_cTr(PyObject* p, boost::python::type<const T&> t) = 0;
-    virtual const T& from_python_T(PyObject* p, boost::python::type<T> t) = 0;
-
-    virtual std::auto_ptr<T>& from_python_aTr(PyObject* p, boost::python::type<std::auto_ptr<T>&> t) = 0;
-    virtual std::auto_ptr<T> from_python_aT(PyObject* p, boost::python::type<std::auto_ptr<T> > t) = 0;
-    virtual const std::auto_ptr<T>& from_python_caTr(PyObject* p, boost::python::type<const std::auto_ptr<T>&> t) = 0;
-    virtual PyObject* to_python(std::auto_ptr<T> x) = 0;
-
-    virtual boost::shared_ptr<T>& from_python_sTr(PyObject* p, boost::python::type<boost::shared_ptr<T>&> t) = 0;
-    virtual const boost::shared_ptr<T>& from_python_sT(PyObject* p, boost::python::type<boost::shared_ptr<T> > t) = 0;
-    virtual const boost::shared_ptr<T>& from_python_csTr(PyObject* p, boost::python::type<const boost::shared_ptr<T>&> t) = 0;
-    virtual PyObject* to_python(boost::shared_ptr<T> x) = 0;
-};
-
-// Converters to be used if T is not copyable.
-template <class T>
-struct export_converter_object_noncopyable : export_converter_object_base<T>
-{
-    virtual PyObject* to_python(const T& x) {
-        PyErr_SetString(PyExc_RuntimeError,
-          "to_python(const T&) converter not exported");
-        throw_import_error();
-        return 0;
-    }
-
-    virtual T* from_python_Ts(PyObject* p, boost::python::type<T*> t) {
-        return BOOST_PYTHON_CONVERSION::from_python(p, t);
-    }
-    virtual const T* from_python_cTs(PyObject* p, boost::python::type<const T*> t) {
-        return BOOST_PYTHON_CONVERSION::from_python(p, t);
-    }
-    virtual const T* from_python_cTscr(PyObject* p, boost::python::type<const T*const&> t) {
-        return BOOST_PYTHON_CONVERSION::from_python(p, t);
-    }
-    virtual T* from_python_Tscr(PyObject* p, boost::python::type<T* const&> t) {
-        return BOOST_PYTHON_CONVERSION::from_python(p, t);
-    }
-    virtual T& from_python_Tr(PyObject* p, boost::python::type<T&> t) {
-        return BOOST_PYTHON_CONVERSION::from_python(p, t);
-    }
-    virtual const T& from_python_cTr(PyObject* p, boost::python::type<const T&> t) {
-        return BOOST_PYTHON_CONVERSION::from_python(p, t);
-    }
-    virtual const T& from_python_T(PyObject* p, boost::python::type<T> t) {
-        return BOOST_PYTHON_CONVERSION::from_python(p, t);
-    }
-
-    virtual std::auto_ptr<T>& from_python_aTr(PyObject* p, boost::python::type<std::auto_ptr<T>&> t) {
-        return BOOST_PYTHON_CONVERSION::from_python(p, t);
-    }
-    virtual std::auto_ptr<T> from_python_aT(PyObject* p, boost::python::type<std::auto_ptr<T> > t) {
-        return BOOST_PYTHON_CONVERSION::from_python(p, t);
-    }
-    virtual const std::auto_ptr<T>& from_python_caTr(PyObject* p, boost::python::type<const std::auto_ptr<T>&> t) {
-        return BOOST_PYTHON_CONVERSION::from_python(p, t);
-    }
-    virtual PyObject* to_python(std::auto_ptr<T> x) {
-        return BOOST_PYTHON_CONVERSION::to_python(x);
-    }
-
-    virtual boost::shared_ptr<T>& from_python_sTr(PyObject* p, boost::python::type<boost::shared_ptr<T>&> t) {
-        return BOOST_PYTHON_CONVERSION::from_python(p, t);
-    }
-    virtual const boost::shared_ptr<T>& from_python_sT(PyObject* p, boost::python::type<boost::shared_ptr<T> > t) {
-        return BOOST_PYTHON_CONVERSION::from_python(p, t);
-    }
-    virtual const boost::shared_ptr<T>& from_python_csTr(PyObject* p, boost::python::type<const boost::shared_ptr<T>&> t) {
-        return BOOST_PYTHON_CONVERSION::from_python(p, t);
-    }
-    virtual PyObject* to_python(boost::shared_ptr<T> x) {
-        return BOOST_PYTHON_CONVERSION::to_python(x);
-    }
-};
-
-// The addditional to_python() converter that can be used if T is copyable.
-template <class T>
-struct export_converter_object : export_converter_object_noncopyable<T>
-{
-    virtual PyObject* to_python(const T& x) {
-        return BOOST_PYTHON_CONVERSION::py_extension_class_converters(boost::python::type<T>()).to_python(x);
-    }
-};
-
-namespace detail
-{
-
-/* This class template is instantiated by import_converters<T>.
-   Its purpose is to import the converter_object via the Python API.
-   The actual import is only done once. The pointer to the
-   imported converter object is kept in the static data member
-   imported_converters.
-*/
-  template <class T>
-  class import_extension_class
-      : public python_import_extension_class_converters<T>
-  {
-   public:
-      inline import_extension_class(const char* module, const char* py_class) {
-          m_module = module;
-          m_py_class = py_class;
-      }
-
-      static boost::python::export_converter_object_base<T>* get_converters();
-
-   private:
-      static std::string m_module;
-      static std::string m_py_class;
-      static boost::python::export_converter_object_base<T>* imported_converters;
-  };
-
-  template <class T> std::string import_extension_class<T>::m_module;
-  template <class T> std::string import_extension_class<T>::m_py_class;
-  template <class T>
-  boost::python::export_converter_object_base<T>*
-  import_extension_class<T>::imported_converters = 0;
-
-  template <class T>
-  boost::python::export_converter_object_base<T>*
-  import_extension_class<T>::get_converters() {
-      if (imported_converters == 0) {
-          void* cobject
-              = import_converter_object(m_module, m_py_class,
-                                        converters_attribute_name);
-          imported_converters
-              = static_cast<boost::python::export_converter_object_base<T>*>(cobject);
-          check_export_converters_api(
-              export_converters_api_major,
-              export_converters_api_minor,
-              imported_converters->get_api_major(),
-              imported_converters->get_api_minor());
-      }
-      return imported_converters;
-  }
-}}} // namespace boost::python::detail
-
-namespace boost { namespace python {
-
-// Implementation of export_converters().
-template <class T, class U>
-void export_converters(class_builder<T, U>& cb)
-{
-    static export_converter_object<T> export_cvts;
-    cb.add(
-      ref(PyCObject_FromVoidPtr(reinterpret_cast<void*>(&export_cvts), NULL)),
-      detail::converters_attribute_name);
-}
-
-// Implementation of export_converters_noncopyable().
-template <class T, class U>
-void export_converters_noncopyable(class_builder<T, U>& cb)
-{
-    static export_converter_object_noncopyable<T> export_cvts;
-    cb.add(
-      ref(PyCObject_FromVoidPtr(reinterpret_cast<void*>(&export_cvts), NULL)),
-      detail::converters_attribute_name);
-}
-
-// Implementation of import_converters<T>.
-template <class T>
-class import_converters
-    : python_import_extension_class_converters<T> // Works around MSVC6.x/GCC2.95.2 bug described
-                                                  // at the bottom of class_builder.hpp.
-{
- public:
-    import_converters(const char* module, const char* py_class)
-        : m_class(new detail::import_extension_class<T>(module, py_class))
-    { }
- private:
-    boost::shared_ptr<detail::import_extension_class<T> > m_class;
-};
-
-}} // namespace boost::python
-
-#endif // CROSS_MODULE_HPP

include/boost/python/data_members.hpp

@@ -1,111 +1,316 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 DATA_MEMBERS_DWA2002328_HPP
 # define DATA_MEMBERS_DWA2002328_HPP
 
-# include <boost/python/detail/config.hpp>
-# include <boost/python/detail/wrap_python.hpp>
-# include <boost/type_traits/transform_traits.hpp>
-# include <boost/type_traits/cv_traits.hpp>
+# include <boost/python/detail/prefix.hpp>
+
+# include <boost/python/handle.hpp>
+
 # include <boost/python/return_value_policy.hpp>
-# include <boost/python/copy_non_const_reference.hpp>
-# include <boost/python/object/function_object.hpp>
-# include <boost/python/arg_from_python.hpp>
-# include <boost/bind.hpp>
+# include <boost/python/return_by_value.hpp>
+# include <boost/python/return_internal_reference.hpp>
+# include <boost/python/make_function.hpp>
+
+# include <boost/python/converter/builtin_converters.hpp>
+
+# include <boost/python/detail/indirect_traits.hpp>
+# include <boost/python/detail/not_specified.hpp>
+# include <boost/python/detail/value_arg.hpp>
+
+# include <boost/type_traits/add_const.hpp>
+# include <boost/type_traits/add_reference.hpp>
+# include <boost/type_traits/is_member_pointer.hpp>
+
+# if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
+#  include <boost/type_traits/remove_cv.hpp>
+# endif 
+
+# include <boost/mpl/eval_if.hpp>
+# include <boost/mpl/if.hpp>
+# include <boost/mpl/vector/vector10.hpp>
+
+# include <boost/detail/workaround.hpp>
 
 namespace boost { namespace python { 
 
+//
+// This file defines the make_getter and make_setter function
+// families, which are responsible for turning pointers, references,
+// and pointers-to-data-members into callable Python objects which
+// can be used for attribute access on wrapped classes.
+//
+
 namespace detail
 {
-  template <class Data, class Class, class Policies>
+
+  // A small function object which handles the getting and setting of
+  // data members.
+  template <class Data, class Class>
   struct member
   {
-      static PyObject* get(Data Class::*pm, PyObject* args_, PyObject*, Policies const& policies)
-      {
-          arg_from_python<Class*> c0(PyTuple_GET_ITEM(args_, 0));
-          if (!c0.convertible()) return 0;
-
-          // find the result converter
-          typedef typename Policies::result_converter result_converter;
-          typedef typename boost::add_reference<Data>::type source;
-          typename mpl::apply1<result_converter,source>::type cr;
-          if (!cr.convertible()) return 0;
-        
-          if (!policies.precall(args_)) return 0;
-
-          PyObject* result = cr( (c0(PyTuple_GET_ITEM(args_, 0)))->*pm );
-        
-          return policies.postcall(args_, result);
-      }
-  
-      static PyObject* set(Data Class::*pm, PyObject* args_, PyObject*, Policies const& policies)
-      {
-          // check that each of the arguments is convertible
-          arg_from_python<Class*> c0(PyTuple_GET_ITEM(args_, 0));
-          if (!c0.convertible()) return 0;
-
-          typedef typename add_const<Data>::type target1;
-          typedef typename add_reference<target1>::type target;
-          arg_from_python<target> c1(PyTuple_GET_ITEM(args_, 1));
+   public:      
+      member(Data Class::*which) : m_which(which) {}
       
-          if (!c1.convertible()) return 0;
-
-          if (!policies.precall(args_)) return 0;
-
-          (c0(PyTuple_GET_ITEM(args_, 0)))->*pm = c1(PyTuple_GET_ITEM(args_, 1));
-        
-          return policies.postcall(args_, detail::none());
+      Data& operator()(Class& c) const
+      {
+          return c.*m_which;
       }
+
+      void operator()(Class& c, typename value_arg<Data>::type d) const
+      {
+          c.*m_which = d;
+      }
+   private:
+      Data Class::*m_which;
   };
+
+  // A small function object which handles the getting and setting of
+  // non-member objects.
+  template <class Data>
+  struct datum
+  {
+   public:      
+      datum(Data *which) : m_which(which) {}
+      
+      Data& operator()() const
+      {
+          return *m_which;
+      }
+
+      void operator()(typename value_arg<Data>::type d) const
+      {
+          *m_which = d;
+      }
+   private:
+      Data *m_which;
+  };
+  
+  //
+  // Helper metafunction for determining the default CallPolicy to use
+  // for attribute access.  If T is a [reference to a] class type X
+  // whose conversion to python would normally produce a new copy of X
+  // in a wrapped X class instance (as opposed to types such as
+  // std::string, which are converted to native Python types, and
+  // smart pointer types which produce a wrapped class instance of the
+  // pointee type), to-python conversions will attempt to produce an
+  // object which refers to the original C++ object, rather than a
+  // copy.  See default_member_getter_policy for rationale.
+  // 
+  template <class T>
+  struct default_getter_by_ref
+      : mpl::and_<
+          mpl::bool_<
+              to_python_value<
+                  typename value_arg<T>::type
+              >::uses_registry
+          >
+        , indirect_traits::is_reference_to_class<
+              typename value_arg<T>::type
+          >
+       >
+  {
+  };
+
+  // Metafunction computing the default CallPolicy to use for reading
+  // data members
+  //
+  // If it's a regular class type (not an object manager or other
+  // type for which we have to_python specializations, use
+  // return_internal_reference so that we can do things like
+  //    x.y.z =  1
+  // and get the right result.
+  template <class T>
+  struct default_member_getter_policy
+    : mpl::if_<
+          default_getter_by_ref<T>
+        , return_internal_reference<>
+        , return_value_policy<return_by_value>
+      >
+  {};
+
+  // Metafunction computing the default CallPolicy to use for reading
+  // non-member data.
+  template <class T>
+  struct default_datum_getter_policy
+    : mpl::if_<
+          default_getter_by_ref<T>
+        , return_value_policy<reference_existing_object>
+        , return_value_policy<return_by_value>
+      >
+  {};
+
+  //
+  // make_getter helper function family -- These helpers to
+  // boost::python::make_getter are used to dispatch behavior.  The
+  // third argument is a workaround for a CWPro8 partial ordering bug
+  // with pointers to data members.  It should be convertible to
+  // mpl::true_ iff the first argument is a pointer-to-member, and
+  // mpl::false_ otherwise.  The fourth argument is for compilers
+  // which don't support partial ordering at all and should always be
+  // passed 0L.
+  //
+
+#if BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
+  template <class D, class P>
+  inline object make_getter(D& d, P& p, mpl::false_, ...);
+#endif
+
+  // Handle non-member pointers with policies
+  template <class D, class Policies>
+  inline object make_getter(D* d, Policies const& policies, mpl::false_, int)
+  {
+      return python::make_function(
+          detail::datum<D>(d), policies, mpl::vector1<D&>()
+      );
+  }
+  
+  // Handle non-member pointers without policies
+  template <class D>
+  inline object make_getter(D* d, not_specified, mpl::false_, long)
+  {
+      typedef typename default_datum_getter_policy<D>::type policies;
+      return detail::make_getter(d, policies(), mpl::false_(), 0);
+  }
+
+  // Handle pointers-to-members with policies
+  template <class C, class D, class Policies>
+  inline object make_getter(D C::*pm, Policies const& policies, mpl::true_, int)
+  {
+#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
+      typedef typename remove_cv<C>::type Class;
+#else
+      typedef C Class;
+#endif 
+      return python::make_function(
+          detail::member<D,Class>(pm)
+        , policies
+        , mpl::vector2<D&,Class&>()
+      );
+  }
+      
+  // Handle pointers-to-members without policies
+  template <class C, class D>
+  inline object make_getter(D C::*pm, not_specified, mpl::true_, long)
+  {
+      typedef typename default_member_getter_policy<D>::type policies;
+      return detail::make_getter(pm, policies(), mpl::true_(), 0);
+  }
+
+  // Handle references
+  template <class D, class P>
+  inline object make_getter(D& d, P& p, mpl::false_, ...)
+  {
+      // Just dispatch to the handler for pointer types.
+      return detail::make_getter(&d, p, mpl::false_(), 0L);
+  }
+
+  //
+  // make_setter helper function family -- These helpers to
+  // boost::python::make_setter are used to dispatch behavior.  The
+  // third argument is for compilers which don't support partial
+  // ordering at all and should always be passed 0.
+  //
+
+  
+  // Handle non-member pointers
+  template <class D, class Policies>
+  inline object make_setter(D* p, Policies const& policies, mpl::false_, int)
+  {
+      return python::make_function(
+          detail::datum<D>(p), policies, mpl::vector2<void,D const&>()
+      );
+  }
+
+  // Handle pointers-to-members
+  template <class C, class D, class Policies>
+  inline object make_setter(D C::*pm, Policies const& policies, mpl::true_, int)
+  {
+      return python::make_function(
+          detail::member<D,C>(pm)
+        , policies
+        , mpl::vector3<void, C&, D const&>()
+      );
+  }
+
+  // Handle references
+  template <class D, class Policies>
+  inline object make_setter(D& x, Policies const& policies, mpl::false_, ...)
+  {
+      return detail::make_setter(&x, policies, mpl::false_(), 0L);
+  }
 }
 
-template <class C, class D>
-object make_getter(D C::*pm)
+//
+// make_getter function family -- build a callable object which
+// retrieves data through the first argument and is appropriate for
+// use as the `get' function in Python properties .  The second,
+// policies argument, is optional.  We need both D& and D const&
+// overloads in order be able to handle rvalues.
+//
+template <class D, class Policies>
+inline object make_getter(D& d, Policies const& policies)
 {
-    typedef return_value_policy<copy_non_const_reference> default_policy;
-    
-    return objects::function_object(
-        ::boost::bind(
-            &detail::member<D,C,default_policy>::get, pm, _1, _2
-            , default_policy())
-        , 1);
-        
+    return detail::make_getter(d, policies, is_member_pointer<D>(), 0L);
 }
 
-template <class C, class D, class Policies>
-object make_getter(D C::*pm, Policies const& policies)
+template <class D, class Policies>
+inline object make_getter(D const& d, Policies const& policies)
 {
-    return objects::function_object(
-            ::boost::bind(
-                &detail::member<D,C,Policies>::get, pm, _1, _2
-                , policies)
-        , 1);
+    return detail::make_getter(d, policies, is_member_pointer<D>(), 0L);
 }
 
-template <class C, class D>
-object make_setter(D C::*pm)
+template <class D>
+inline object make_getter(D& x)
 {
-    return objects::function_object(
-        ::boost::bind(
-            &detail::member<D,C,default_call_policies>::set, pm, _1, _2
-            , default_call_policies())
-        , 2);
+    detail::not_specified policy;
+    return detail::make_getter(x, policy, is_member_pointer<D>(), 0L);
 }
 
-template <class C, class D, class Policies>
-object make_setter(D C::*pm, Policies const& policies)
+#  if !BOOST_WORKAROUND(__EDG_VERSION__, <= 238) && !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+template <class D>
+inline object make_getter(D const& d)
 {
-    return objects::function_object(
-        ::boost::bind(
-            &detail::member<D,C,Policies>::set, pm, _1, _2
-            , policies)
-        , 2);
+    detail::not_specified policy;
+    return detail::make_getter(d, policy, is_member_pointer<D>(), 0L);
+}
+#  endif
+
+//
+// make_setter function family -- build a callable object which
+// writes data through the first argument and is appropriate for
+// use as the `set' function in Python properties .  The second,
+// policies argument, is optional.  We need both D& and D const&
+// overloads in order be able to handle rvalues.
+//
+template <class D, class Policies>
+inline object make_setter(D& x, Policies const& policies)
+{
+    return detail::make_setter(x, policies, is_member_pointer<D>(), 0);
 }
 
-    
+template <class D, class Policies>
+inline object make_setter(D const& x, Policies const& policies)
+{
+    return detail::make_setter(x, policies, is_member_pointer<D>(), 0);
+}
+
+template <class D>
+inline object make_setter(D& x)
+{
+    return detail::make_setter(x, default_call_policies(), is_member_pointer<D>(), 0);
+}
+
+# if !(BOOST_WORKAROUND(BOOST_MSVC, <= 1300) || BOOST_WORKAROUND(__EDG_VERSION__, <= 238))
+template <class D>
+inline object make_setter(D const& x)
+{
+    return detail::make_setter(x, default_call_policies(), is_member_pointer<D>(), 0);
+}
+# endif
+
 }} // namespace boost::python
 
 #endif // DATA_MEMBERS_DWA2002328_HPP

include/boost/python/def.hpp

@@ -1,108 +1,113 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 DEF_DWA200292_HPP
 # define DEF_DWA200292_HPP
 
+# include <boost/python/detail/prefix.hpp>
+
 # include <boost/python/object_fwd.hpp>
 # include <boost/python/make_function.hpp>
 # include <boost/python/detail/def_helper.hpp>
-# include <boost/python/detail/defaults_def.hpp>
+# include <boost/python/detail/overloads_fwd.hpp>
 # include <boost/python/scope.hpp>
 # include <boost/python/signature.hpp>
+# include <boost/python/detail/scope.hpp>
 
 namespace boost { namespace python {
 
 namespace detail
 {
-  void BOOST_PYTHON_DECL scope_setattr_doc(char const* name, object const& obj, char const* doc);
+  namespace error
+  {
+    // Compile-time error messages
+    template <bool> struct multiple_functions_passed_to_def;
+    template <> struct multiple_functions_passed_to_def<false> { typedef char type; };
+  }
+  
+  //
+  // def_from_helper --
+  //
+  // Use a def_helper to define a regular wrapped function in the current scope.
+  template <class F, class Helper>
+  void def_from_helper(
+      char const* name, F const& fn, Helper const& helper)
+  {
+      // Must not try to use default implementations except with method definitions.
+      typedef typename error::multiple_functions_passed_to_def<
+          Helper::has_default_implementation
+          >::type assertion;
+      
+      detail::scope_setattr_doc(
+          name, boost::python::make_function(
+              fn
+              , helper.policies()
+              , helper.keywords())
+          , helper.doc()
+          );
+  }
 
-    template <class Fn, class CallPolicyOrDoc>
-    void
-    dispatch_def(
-        void const*,
-        char const* name,
-        Fn fn,
-        CallPolicyOrDoc const& policy_or_doc)
-    {
-        typedef detail::def_helper<CallPolicyOrDoc> helper;
+  //
+  // 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.
+  //
+  template <class Fn, class A1>
+  void
+  def_maybe_overloads(
+      char const* name
+      , Fn fn
+      , A1 const& a1
+      , ...)
+  {
+      detail::def_from_helper(name, fn, def_helper<A1>(a1));
+  }
 
-        detail::scope_setattr_doc(
-            name, boost::python::make_function(fn, helper::get_policy(policy_or_doc)),
-            helper::get_doc(policy_or_doc, 0));
-    }
+  template <class StubsT, class SigT>
+  void def_maybe_overloads(
+      char const* name
+      , SigT sig
+      , StubsT const& stubs
+      , detail::overloads_base const*)
+  {
+      scope current;
+      
+      detail::define_with_defaults(
+          name, stubs, current, detail::get_signature(sig));
+  }
 
-    template <class Fn, class CallPolicyOrDoc1, class CallPolicyOrDoc2>
-    void dispatch_def(
-        void const*,
-        char const* name,
-        Fn fn,
-        CallPolicyOrDoc1 const& policy_or_doc1,
-        CallPolicyOrDoc2 const& policy_or_doc2)
-    {
-        typedef detail::def_helper<CallPolicyOrDoc1> helper;
+  template <class T>
+  object make_function1(T fn, ...) { return make_function(fn); }
 
-        detail::scope_setattr_doc(
-            name, boost::python::make_function(
-                fn, helper::get_policy(policy_or_doc1, policy_or_doc2)),
-            helper::get_doc(policy_or_doc1, policy_or_doc2));
-    }
-
-    template <class StubsT, class SigT>
-    void dispatch_def(
-        detail::overloads_base const*,
-        char const* name,
-        SigT sig,
-        StubsT const& stubs)
-    {
-        //  convert sig to a type_list (see detail::get_signature in signature.hpp)
-        //  before calling detail::define_with_defaults.
-
-        scope current;
-        detail::define_with_defaults(
-            name, stubs, current, detail::get_signature(sig));
-    }
+  inline
+  object make_function1(object const& x, object const*) { return x; }
 }
 
 template <class Fn>
 void def(char const* name, Fn fn)
 {
-    detail::scope_setattr_doc(name, boost::python::make_function(fn), 0);
+    detail::scope_setattr_doc(name, detail::make_function1(fn, &fn), 0);
 }
 
 template <class Arg1T, class Arg2T>
 void def(char const* name, Arg1T arg1, Arg2T const& arg2)
 {
-    //  The arguments may be:
-    //      def(name, function)
-    //      def(name, function, policy)
-    //      def(name, function, doc_string)
-    //      def(name, signature, stubs)
-
-    detail::dispatch_def(&arg2, name, arg1, arg2);
+    detail::def_maybe_overloads(name, arg1, arg2, &arg2);
 }
 
-template <class Arg1T, class Arg2T, class Arg3T>
-void def(char const* name, Arg1T arg1, Arg2T const& arg2, Arg3T const& arg3)
+template <class F, class A1, class A2>
+void def(char const* name, F f, A1 const& a1, A2 const& a2)
 {
-    //  The arguments are definitely:
-    //      def(name, function, policy, doc_string) // TODO: exchange policy, doc_string position
-
-    detail::dispatch_def(&arg2, name, arg1, arg2, arg3);
+    detail::def_from_helper(name, f, detail::def_helper<A1,A2>(a1,a2));
 }
 
-//template <class Arg1T, class Arg2T, class Arg3T>
-//void def(char const* name, Arg1T arg1, Arg2T const& arg2, Arg3T const& arg3, char const* doc)
-//{
-//    //  The arguments are definitely:
-//    //  arg1:   signature
-//    //  arg2:   stubs
-//    //  arg3:   policy
-//
-//    detail::dispatch_def(&arg2, name, arg1, arg2, arg3, doc);
-//}
+template <class F, class A1, class A2, class A3>
+void def(char const* name, F f, A1 const& a1, A2 const& a2, A3 const& a3)
+{
+    detail::def_from_helper(name, f, detail::def_helper<A1,A2,A3>(a1,a2,a3));
+}
 
 }} // namespace boost::python
 

include/boost/python/def_visitor.hpp

@@ -0,0 +1,86 @@
+// Copyright David Abrahams 2003.
+// 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 DEF_VISITOR_DWA2003810_HPP
+# define DEF_VISITOR_DWA2003810_HPP
+
+# include <boost/python/detail/prefix.hpp>
+# include <boost/detail/workaround.hpp>
+
+namespace boost { namespace python { 
+
+template <class DerivedVisitor> class def_visitor;
+template <class T, class X1, class X2, class X3> class class_;
+
+class def_visitor_access
+{
+# if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)                  \
+    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+    // Tasteless as this may seem, making all members public allows member templates
+    // to work in the absence of member template friends.
+ public:
+# else      
+    template <class Derived> friend class def_visitor;
+# endif
+    
+    // unnamed visit, c.f. init<...>, container suites
+    template <class V, class classT>
+    static void visit(V const& v, classT& c)
+    {
+        v.derived_visitor().visit(c);
+    }
+
+    // named visit, c.f. object, pure_virtual
+    template <class V, class classT, class OptionalArgs>
+    static void visit(
+        V const& v
+      , classT& c
+      , char const* name
+      , OptionalArgs const& options
+    ) 
+    {
+        v.derived_visitor().visit(c, name, options);
+    }
+    
+};
+
+
+template <class DerivedVisitor>
+class def_visitor
+{
+    friend class def_visitor_access;
+    
+# if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)                  \
+    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+    // Tasteless as this may seem, making all members public allows member templates
+    // to work in the absence of member template friends.
+ public:
+# else      
+    template <class T, class X1, class X2, class X3> friend class class_;
+# endif
+    
+    // unnamed visit, c.f. init<...>, container suites
+    template <class classT>
+    void visit(classT& c) const
+    {
+        def_visitor_access::visit(*this, c);
+    }
+
+    // named visit, c.f. object, pure_virtual
+    template <class classT, class OptionalArgs>
+    void visit(classT& c, char const* name, OptionalArgs const& options) const
+    {
+        def_visitor_access::visit(*this, c, name, options);
+    }
+    
+ protected:
+    DerivedVisitor const& derived_visitor() const
+    {
+        return static_cast<DerivedVisitor const&>(*this);
+    }
+};
+
+}} // namespace boost::python
+
+#endif // DEF_VISITOR_DWA2003810_HPP

include/boost/python/default_call_policies.hpp

@@ -1,14 +1,18 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 DEFAULT_CALL_POLICIES_DWA2002131_HPP
 # define DEFAULT_CALL_POLICIES_DWA2002131_HPP
-# include <boost/python/detail/wrap_python.hpp>
+
+# include <boost/python/detail/prefix.hpp>
 # include <boost/mpl/if.hpp>
 # include <boost/python/to_python_value.hpp>
+# include <boost/python/detail/value_arg.hpp>
 # include <boost/type_traits/transform_traits.hpp>
+# include <boost/type_traits/is_pointer.hpp>
+# include <boost/type_traits/is_reference.hpp>
+# include <boost/mpl/or.hpp>
 
 namespace boost { namespace python { 
 
@@ -17,7 +21,7 @@ template <class T> struct to_python_value;
 namespace detail
 {
 // for "readable" error messages
-  template <class T> struct specify_a_result_policy_to_wrap_functions_returning
+  template <class T> struct specify_a_return_value_policy_to_wrap_functions_returning
 # if defined(__GNUC__) && __GNUC__ >= 3 || defined(__EDG__)
   {}
 # endif 
@@ -28,19 +32,23 @@ struct default_result_converter;
 
 struct default_call_policies
 {
-    // Nothing to do
-    static bool precall(PyObject*)
+    // Ownership of this argument tuple will ultimately be adopted by
+    // the caller.
+    template <class ArgumentPackage>
+    static bool precall(ArgumentPackage const&)
     {
         return true;
     }
 
     // Pass the result through
-    static PyObject* postcall(PyObject*, PyObject* result)
+    template <class ArgumentPackage>
+    static PyObject* postcall(ArgumentPackage const&, PyObject* result)
     {
         return result;
     }
 
     typedef default_result_converter result_converter;
+    typedef PyObject* argument_package;
 };
 
 struct default_result_converter
@@ -48,14 +56,12 @@ struct default_result_converter
     template <class R>
     struct apply
     {
-        BOOST_STATIC_CONSTANT(bool, is_illegal = is_reference<R>::value || is_pointer<R>::value);
-        
-        typedef typename mpl::if_c<
-            is_illegal
-            , detail::specify_a_result_policy_to_wrap_functions_returning<R>
-            , boost::python::to_python_value<
-                typename add_reference<typename add_const<R>::type>::type
-                >
+        typedef typename mpl::if_<
+            mpl::or_<is_pointer<R>, is_reference<R> >
+          , detail::specify_a_return_value_policy_to_wrap_functions_returning<R>
+          , boost::python::to_python_value<
+                typename detail::value_arg<R>::type
+            >
         >::type type;
     };
 };

include/boost/python/detail/aix_init_module.hpp

@@ -1,13 +1,15 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 AIX_INIT_MODULE_DWA2002529_HPP
 # define AIX_INIT_MODULE_DWA2002529_HPP
 # ifdef _AIX
-# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/detail/prefix.hpp>
 # include <cstdio>
+# ifdef __KCC
+#  include <iostream> // this works around a problem in KCC 4.0f
+# endif 
 
 namespace boost { namespace python { namespace detail { 
 

include/boost/python/detail/api_placeholder.hpp

@@ -1,3 +1,7 @@
+// 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 BOOST_PYTHON_API_PLACE_HOLDER_HPP
 #define BOOST_PYTHON_API_PLACE_HOLDER_HPP
 

include/boost/python/detail/arg_tuple_size.hpp

@@ -1,127 +0,0 @@
-#if !defined(BOOST_PP_IS_ITERATING)
-
-//  (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-//
-//  This work was funded in part by Lawrence Berkeley National Labs
-//
-//  This file generated for 5-argument member functions and 6-argument free
-//  functions by gen_arg_tuple_size.python
-
-#ifndef ARG_TUPLE_SIZE_DWA20011201_HPP
-# define ARG_TUPLE_SIZE_DWA20011201_HPP 
-
-# include <boost/config.hpp>
-
-# include <boost/python/detail/char_array.hpp>
-# include <boost/python/detail/preprocessor.hpp>
-
-# include <boost/preprocessor/comma_if.hpp>
-# include <boost/preprocessor/iterate.hpp>
-# include <boost/preprocessor/debug/line.hpp>
-
-namespace boost { namespace python { namespace detail {
-
-// Computes (at compile-time) the number of elements that a Python
-// argument tuple must have in order to be passed to a wrapped C++
-// (member) function of the given type.
-template <class F> struct arg_tuple_size;
-
-// We will use the "sizeof() trick" to work around the lack of
-// partial specialization in MSVC6 and its broken-ness in borland.
-// See http://opensource.adobe.com  or
-// http://groups.yahoo.com/group/boost/message/5441 for
-// more examples
-
-// The following helper functions are never actually called, since
-// they are only used within a sizeof() expression, but the type of
-// their return value is used to discriminate between various free
-// and member function pointers at compile-time.
-
-// Specializations for function pointers
-# define BOOST_PP_ITERATION_PARAMS_1 \
-     (4, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/detail/arg_tuple_size.hpp>, BOOST_PYTHON_FUNCTION_POINTER))
-# include BOOST_PP_ITERATE()
-
-// Specializations for member function pointers
-# define BOOST_PP_ITERATION_PARAMS_1 \
-    (4, (0, BOOST_PYTHON_CV_COUNT - 1, <boost/python/detail/arg_tuple_size.hpp>, BOOST_PYTHON_POINTER_TO_MEMBER))
-# include BOOST_PP_ITERATE()
-
-# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-
-template <class F>
-struct arg_tuple_size
-{
-    // The sizeof() magic happens here
-    BOOST_STATIC_CONSTANT(std::size_t, value
-        = sizeof(arg_tuple_size_helper(F(0)).elements) - 1);
-};
-
-# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-}}} // namespace boost::python::detail
-
-#endif // ARG_TUPLE_SIZE_DWA20011201_HPP
-
-// --------------- function pointers --------------- //
-#elif BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == BOOST_PYTHON_FUNCTION_POINTER
-# line BOOST_PP_LINE(__LINE__, arg_tuple_size.hpp(function pointers))
-
-# define N BOOST_PP_ITERATION()
-
-# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-
-template <class R BOOST_PP_COMMA_IF(N) BOOST_PYTHON_UNARY_ENUM(N, class A)>
-struct arg_tuple_size<R (*)(BOOST_PYTHON_UNARY_ENUM(N, A))>
-{
-    BOOST_STATIC_CONSTANT(std::size_t, value = N);
-};
-
-# else
-
-template<class R BOOST_PP_COMMA_IF(N) BOOST_PYTHON_UNARY_ENUM(N, class A)>
-char_array<N> arg_tuple_size_helper(
-        R (*)(BOOST_PYTHON_UNARY_ENUM(N, A)));
-
-# endif // !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-
-# undef N
-
-// --------------- pointers-to-members --------------- //
-#elif BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == BOOST_PYTHON_POINTER_TO_MEMBER
-// Outer iteration over cv-qualifications
-
-# define BOOST_PP_ITERATION_PARAMS_2 \
-    (3, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/detail/arg_tuple_size.hpp>))
-# include BOOST_PP_ITERATE()
-
-#elif BOOST_PP_ITERATION_DEPTH() == 2 && BOOST_PP_RELATIVE_FLAGS(1) == BOOST_PYTHON_POINTER_TO_MEMBER
-# line BOOST_PP_LINE(__LINE__, arg_tuple_size.hpp(pointers-to-members))
-// Inner iteration over arities
-    
-# define N BOOST_PP_ITERATION()
-# define Q BOOST_PYTHON_CV_QUALIFIER(BOOST_PP_RELATIVE_ITERATION(1))
-
-# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-
-template <class R, class T BOOST_PP_COMMA_IF(N) BOOST_PYTHON_UNARY_ENUM(N, class A)>
-struct arg_tuple_size<R (T::*)(BOOST_PYTHON_UNARY_ENUM(N, A)) Q>
-{
-    BOOST_STATIC_CONSTANT(std::size_t, value = N + 1U);
-};
-
-# else
-
-template <class R, class T BOOST_PP_COMMA_IF(N) BOOST_PYTHON_UNARY_ENUM(N, class A)>
-char_array<N + 1> arg_tuple_size_helper(
-    R (T::*)(BOOST_PYTHON_UNARY_ENUM(N, A)) Q);
-
-# endif // !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-
-# undef Q
-# undef N
-
-#endif // !defined(BOOST_PP_IS_ITERATING)

include/boost/python/detail/base_object.hpp

@@ -1,60 +0,0 @@
-//  (C) Copyright David Abrahams 2000. Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-//
-//  The author gratefully acknowleges the support of Dragon Systems, Inc., in
-//  producing this work.
-//
-// Revision History:
-// Mar 01 01  Use PyObject_INIT() instead of trying to hand-initialize (David Abrahams)
-
-#ifndef BASE_OBJECT_DWA051600_H_
-# define BASE_OBJECT_DWA051600_H_
-
-# include <boost/python/detail/config.hpp>
-# include <boost/python/detail/wrap_python.hpp>
-# include <cstring>
-
-namespace boost { namespace python { namespace detail {
-
-// base_object - adds a constructor and non-virtual destructor to a
-// base Python type (e.g. PyObject, PyTypeObject).
-template <class PythonType>
-struct base_object : PythonType
-{
-    typedef PythonType base_python_type;
-
-    // Initializes type and reference count. All other fields of base_python_type are 0
-    base_object(PyTypeObject* type_obj);
-
-    // Decrements reference count on the type
-    ~base_object();
-};
-
-// Easy typedefs for common usage
-typedef base_object<PyObject> python_object;
-typedef base_object<PyTypeObject> python_type;
-
-
-//
-// base_object member function implementations 
-//
-template <class PythonType>
-base_object<PythonType>::base_object(PyTypeObject* type_obj)
-{
-    base_python_type* bp = this;
-    BOOST_CSTD_::memset(bp, 0, sizeof(base_python_type));
-    Py_INCREF(type_obj);
-    PyObject_INIT(bp, type_obj);
-}
-
-template <class PythonType>
-inline base_object<PythonType>::~base_object()
-{
-    Py_DECREF(ob_type);
-}
-
-}}} // namespace boost::python::detail
-
-#endif // BASE_OBJECT_DWA051600_H_

include/boost/python/detail/borrowed_ptr.hpp

@@ -1,10 +1,9 @@
 #ifndef BORROWED_PTR_DWA20020601_HPP
 # define BORROWED_PTR_DWA20020601_HPP
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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)
 
 # include <boost/config.hpp>
 # include <boost/type.hpp>

include/boost/python/detail/call_object.hpp

@@ -1,66 +0,0 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef CALL_OBJECT_DWA20011222_HPP
-# define CALL_OBJECT_DWA20011222_HPP
-# include <boost/python/errors.hpp>
-# include <boost/python/detail/types.hpp>
-# include <boost/bind.hpp>
-
-namespace boost { namespace python {
-
-namespace detail
-{
-  // A function object adaptor which turns a function returning R into
-  // an "equivalent" function returning void, but taking an R& in
-  // which the adapted function's result is stored.
-  template <class R, class F>
-  struct return_by_reference
-  {
-      typedef void return_type;
-      
-      return_by_reference(R& result, F f)
-          : m_result(result)
-          , m_f(f)
-      {
-      }
-      
-      void operator()() const
-      {
-          m_result = m_f();
-      }
-      
-      R& m_result;
-      F m_f;
-  };
-
-  // An object generator for the above adaptors
-  template <class R, class F>
-  return_by_reference<R,F> bind_return(R& result, F f)
-  {
-      return return_by_reference<R,F>(result, f);
-  }
-
-  // Given a function object f with signature
-  //
-  //    R f(PyTypeObject*,PyObject*)
-  //
-  // calls f inside of handle_exception_impl, placing f's result in
-  // ret. Returns true iff an exception is thrown by f, leaving ret
-  // unmodified.
-  template <class R, class F>
-  bool call_object(R& ret, PyObject* obj, F f)
-  {
-      return handle_exception(
-          detail::bind_return(
-              ret
-              , boost::bind<R>(
-                  f, static_cast<type_object_base*>(obj->ob_type), obj)));
-  }
-} // namespace detail
-
-}} // namespace boost::python
-
-#endif // CALL_OBJECT_DWA20011222_HPP

include/boost/python/detail/caller.hpp

@@ -1,105 +1,220 @@
 #if !defined(BOOST_PP_IS_ITERATING)
 
-//  (C) Copyright David Abrahams 2000. Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-//
-//  The author gratefully acknowleges the support of Dragon Systems, Inc., in
-//  producing this work.
-//
-//  This file generated for 10-argument member functions and 11-argument free
-//  functions by gen_caller.python
+// 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 CALLER_DWA20011214_HPP
-#  define CALLER_DWA20011214_HPP
+# ifndef CALLER_DWA20021121_HPP
+#  define CALLER_DWA20021121_HPP
 
-#  include <boost/python/detail/wrap_python.hpp>
-#  include <boost/python/detail/returning.hpp>
+#  include <boost/python/type_id.hpp>
+#  include <boost/python/handle.hpp>
+
+#  include <boost/python/detail/invoke.hpp>
+#  include <boost/python/detail/signature.hpp>
 #  include <boost/python/detail/preprocessor.hpp>
 
-#  include <boost/type_traits/composite_traits.hpp>
-#  include <boost/type_traits/same_traits.hpp>
+#  include <boost/python/arg_from_python.hpp>
+#  include <boost/python/converter/context_result_converter.hpp>
 
-#  include <boost/preprocessor/comma_if.hpp>
 #  include <boost/preprocessor/iterate.hpp>
-#  include <boost/preprocessor/debug/line.hpp>
+#  include <boost/preprocessor/cat.hpp>
+#  include <boost/preprocessor/dec.hpp>
+#  include <boost/preprocessor/if.hpp>
+#  include <boost/preprocessor/iteration/local.hpp>
+#  include <boost/preprocessor/repetition/enum_trailing_params.hpp>
+#  include <boost/preprocessor/repetition/repeat.hpp>
 
-namespace boost { namespace python
+#  include <boost/compressed_pair.hpp>
+
+#  include <boost/type_traits/is_same.hpp>
+#  include <boost/type_traits/is_convertible.hpp>
+
+#  include <boost/mpl/apply.hpp>
+#  include <boost/mpl/eval_if.hpp>
+#  include <boost/mpl/identity.hpp>
+#  include <boost/mpl/size.hpp>
+#  include <boost/mpl/at.hpp>
+#  include <boost/mpl/int.hpp>
+#  include <boost/mpl/next.hpp>
+
+namespace boost { namespace python { namespace detail { 
+
+template <int N>
+inline PyObject* get(mpl::int_<N>, PyObject* const& args_)
 {
-    template <class T> struct to_python;
-}}
+    return PyTuple_GET_ITEM(args_,N);
+}
 
-namespace boost { namespace python { namespace detail {
+inline unsigned arity(PyObject* const& args_)
+{
+    return PyTuple_GET_SIZE(args_);
+}
 
+// This "result converter" is really just used as
+// a dispatch tag to invoke(...), selecting the appropriate
+// implementation
+typedef int void_result_to_python;
+
+// Given a model of CallPolicies and a C++ result type, this
+// metafunction selects the appropriate converter to use for
+// converting the result to python.
+template <class Policies, class Result>
+struct select_result_converter
+  : mpl::eval_if<
+        is_same<Result,void>
+      , mpl::identity<void_result_to_python>
+      , mpl::apply1<typename Policies::result_converter,Result>
+    >
+{
+};
+
+template <class ArgPackage, class ResultConverter>
+inline ResultConverter create_result_converter(
+    ArgPackage const& args_
+  , ResultConverter*
+  , converter::context_result_converter*
+)
+{
+    return ResultConverter(args_);
+}
+    
+template <class ArgPackage, class ResultConverter>
+inline ResultConverter create_result_converter(
+    ArgPackage const&
+  , ResultConverter*
+  , ...
+)
+{
+    return ResultConverter();
+}
+    
+template <unsigned> struct caller_arity;
+
+template <class F, class CallPolicies, class Sig>
+struct caller;
+
+#  define BOOST_PYTHON_NEXT(init,name,n)                                                        \
+    typedef BOOST_PP_IF(n,typename mpl::next< BOOST_PP_CAT(name,BOOST_PP_DEC(n)) >::type, init) name##n;
+
+#  define BOOST_PYTHON_ARG_CONVERTER(n)                                         \
+     BOOST_PYTHON_NEXT(typename mpl::next<first>::type, arg_iter,n)             \
+     typedef arg_from_python<BOOST_DEDUCED_TYPENAME arg_iter##n::type> c_t##n;  \
+     c_t##n c##n(get(mpl::int_<n>(), inner_args));                              \
+     if (!c##n.convertible())                                                   \
+          return 0;
+
+#  define BOOST_PP_ITERATION_PARAMS_1                                            \
+        (3, (0, BOOST_PYTHON_MAX_ARITY + 1, <boost/python/detail/caller.hpp>))
+#  include BOOST_PP_ITERATE()
+
+#  undef BOOST_PYTHON_ARG_CONVERTER
+#  undef BOOST_PYTHON_NEXT
+
+// A metafunction returning the base class used for caller<class F,
+// class ConverterGenerators, class CallPolicies, class Sig>.
+template <class F, class CallPolicies, class Sig>
+struct caller_base_select
+{
+    enum { arity = mpl::size<Sig>::value - 1 };
+    typedef typename caller_arity<arity>::template impl<F,CallPolicies,Sig> type;
+};
+
+// A function object type which wraps C++ objects as Python callable
+// objects.
+//
+// Template Arguments:
+//
+//   F -
+//      the C++ `function object' that will be called. Might
+//      actually be any data for which an appropriate invoke_tag() can
+//      be generated. invoke(...) takes care of the actual invocation syntax.
+//
+//   CallPolicies -
+//      The precall, postcall, and what kind of resultconverter to
+//      generate for mpl::front<Sig>::type
+//
+//   Sig -
+//      The `intended signature' of the function. An MPL sequence
+//      beginning with a result type and continuing with a list of
+//      argument types.
+template <class F, class CallPolicies, class Sig>
 struct caller
+    : caller_base_select<F,CallPolicies,Sig>::type
 {
+    typedef typename caller_base_select<
+        F,CallPolicies,Sig
+        >::type base;
+
     typedef PyObject* result_type;
-
-    // function pointers
-#  define BOOST_PP_ITERATION_PARAMS_1 \
-    (4, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/detail/caller.hpp>, BOOST_PYTHON_FUNCTION_POINTER))
-#  include BOOST_PP_ITERATE()
-
-    // pointers-to-members
-#  define BOOST_PP_ITERATION_PARAMS_1 \
-    (4, (0, 3, <boost/python/detail/caller.hpp>, BOOST_PYTHON_POINTER_TO_MEMBER))
-#  include BOOST_PP_ITERATE()
+    
+    caller(F f, CallPolicies p) : base(f,p) {}
 
 };
 
 }}} // namespace boost::python::detail
 
-# endif // CALLER_DWA20011214_HPP
+# endif // CALLER_DWA20021121_HPP
 
-/* ---------- function pointers --------- */
-#elif BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == BOOST_PYTHON_FUNCTION_POINTER
-# line BOOST_PP_LINE(__LINE__, detail/caller.hpp(function pointers))
+#else
 
 # define N BOOST_PP_ITERATION()
 
-template <
-    class P, class R
-    BOOST_PP_COMMA_IF(N) BOOST_PYTHON_UNARY_ENUM(N, class A)
-    >
-PyObject* operator()(
-    R (*pf)(BOOST_PYTHON_UNARY_ENUM(N, A))
-    , PyObject* args
-    , PyObject* keywords
-    , P const& policies) const
+template <>
+struct caller_arity<N>
 {
-    return returning<R>::call(pf, args, keywords, &policies);
-}
+    template <class F, class Policies, class Sig>
+    struct impl
+    {
+        impl(F f, Policies p) : m_data(f,p) {}
 
-# undef N
+        PyObject* operator()(PyObject* args_, PyObject*) // eliminate
+                                                         // this
+                                                         // trailing
+                                                         // keyword dict
+        {
+            typedef typename mpl::begin<Sig>::type first;
+            typedef typename first::type result_t;
+            typedef typename select_result_converter<Policies, result_t>::type result_converter;
+            typedef typename Policies::argument_package argument_package;
+            
+            argument_package inner_args(args_);
 
-/* ---------- pointers-to-members ---------- */
-#elif BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == BOOST_PYTHON_POINTER_TO_MEMBER
-// outer over cv-qualifiers
+# if N
+#  define BOOST_PP_LOCAL_MACRO(i) BOOST_PYTHON_ARG_CONVERTER(i)
+#  define BOOST_PP_LOCAL_LIMITS (0, N-1)
+#  include BOOST_PP_LOCAL_ITERATE()
+# endif 
+            // all converters have been checked. Now we can do the
+            // precall part of the policy
+            if (!m_data.second().precall(inner_args))
+                return 0;
 
-# define BOOST_PP_ITERATION_PARAMS_2 (3, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/detail/caller.hpp>))
-# include BOOST_PP_ITERATE()
+            PyObject* result = detail::invoke(
+                detail::invoke_tag<result_t,F>()
+              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
+              , m_data.first()
+                BOOST_PP_ENUM_TRAILING_PARAMS(N, c)
+            );
+            
+            return m_data.second().postcall(inner_args, result);
+        }
 
-#elif BOOST_PP_ITERATION_DEPTH() == 2
-// inner over arities
+        static unsigned min_arity() { return N; }
+        
+        static signature_element const* signature()
+        {
+            return detail::signature<Sig>::elements();
+        }
+        
+     private:
+        compressed_pair<F,Policies> m_data;
+    };
+};
 
-#define N BOOST_PP_ITERATION()
-#define Q BOOST_PYTHON_CV_QUALIFIER(BOOST_PP_RELATIVE_ITERATION(1))
 
-template <
-    class P, class R, class T
-    BOOST_PP_COMMA_IF(N) BOOST_PYTHON_UNARY_ENUM(N, class A)
-    >
-PyObject* operator()(
-    R (T::*pmf)(BOOST_PYTHON_UNARY_ENUM(N, A)) Q
-    , PyObject* args, PyObject* keywords
-    , P const& policies
-    ) const
-{
-    return returning<R>::call(pmf, args, keywords, &policies);
-}
 
-#undef N
-#undef Q
+#endif // BOOST_PP_IS_ITERATING 
+
 
-#endif

include/boost/python/detail/cast.hpp

@@ -1,81 +0,0 @@
-//  (C) Copyright David Abrahams 2000. Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-//
-//  The author gratefully acknowleges the support of Dragon Systems, Inc., in
-//  producing this work.
-
-#ifndef CAST_DWA052500_H_
-# define CAST_DWA052500_H_
-
-# ifndef BOOST_PYTHON_V2
-#  include <boost/python/detail/wrap_python.hpp>
-#  include <boost/operators.hpp>
-
-namespace boost { namespace python {
-
-namespace detail {
-  inline PyTypeObject* as_base_object(const PyTypeObject*, PyObject* p)
-  {
-      return reinterpret_cast<PyTypeObject*>(p);
-  }
-
-  inline PyObject* as_base_object(const PyObject*, PyObject* p)
-  {
-      return p;
-  }
-
-  inline const PyTypeObject* as_base_object(const PyTypeObject*, const PyObject* p)
-  {
-      return reinterpret_cast<const PyTypeObject*>(p);
-  }
-
-  inline const PyObject* as_base_object(const PyObject*, const PyObject* p)
-  {
-      return p;
-  }
-} // namespace detail
-
-// Convert a pointer to any type derived from PyObject or PyTypeObject to a PyObject*
-inline PyObject* as_object(PyObject* p) { return p; }
-inline PyObject* as_object(PyTypeObject* p) { return reinterpret_cast<PyObject*>(p); }
-
-// If I didn't have to support stupid MSVC6 we could just use a simple template function:
-// template <class T> T* downcast(PyObject*).
-template <class T>
-struct downcast
-{
-    downcast(PyObject* p)
-        : m_p(static_cast<T*>(detail::as_base_object((T*)0, p)))
-        {}
-    
-    downcast(const PyObject* p)
-        : m_p(static_cast<T*>(detail::as_base_object((const T*)0, p)))
-        {}
-    
-    downcast(PyTypeObject* p)
-        : m_p(static_cast<T*>(p))
-        {}
-    
-    downcast(const PyTypeObject* p)
-        : m_p(static_cast<T*>(p))
-        {}
-    
-    operator T*() const { return m_p; }
-
-    // MSVC doesn't like boost::dereferencable unless T has a default
-    // constructor, so operator-> must be defined by hand :(
-    T* operator->() const { return &**this; }
-    
-    T* get() const { return m_p; }
-    T& operator*() const { return *m_p; }
- private:
-    T* m_p;
-};
-
-}} // namespace boost::python
-
-# endif // BOOST_PYTHON_V2
-
-#endif // CAST_DWA052500_H_

include/boost/python/detail/char_array.hpp

@@ -1,23 +0,0 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef CHAR_ARRAY_DWA2002129_HPP
-# define CHAR_ARRAY_DWA2002129_HPP
-
-namespace boost { namespace python { namespace detail { 
-
-// This little package is used to transmit the number of arguments
-// from the helper functions below to the sizeof() expression below.
-// Because we can never have an array of fewer than 1 element, we
-// add 1 to n and then subtract 1 from the result of sizeof() below.
-template <int n>
-struct char_array
-{
-    char elements[n+1];
-};
-
-}}} // namespace boost::python::detail
-
-#endif // CHAR_ARRAY_DWA2002129_HPP

include/boost/python/detail/config.hpp

@@ -1,7 +1,7 @@
-//  (C) Copyright David Abrahams 2000. Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
+//  (C) Copyright David Abrahams 2000.
+// 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)
 //
 //  The author gratefully acknowleges the support of Dragon Systems, Inc., in
 //  producing this work.
@@ -13,6 +13,7 @@
 # define CONFIG_DWA052200_H_
 
 # include <boost/config.hpp>
+# include <boost/detail/workaround.hpp>
 
 # ifdef BOOST_NO_OPERATORS_IN_NAMESPACE
    // A gcc bug forces some symbols into the global namespace
@@ -28,11 +29,14 @@
 # endif
 
 # if defined(BOOST_MSVC)
-#  if _MSC_VER <= 1200
+#  if _MSC_VER < 1300
 #   define BOOST_MSVC6_OR_EARLIER 1
 #  endif
 
-#  pragma warning (disable : 4786)
+#  pragma warning (disable : 4786) // disable truncated debug symbols
+#  pragma warning (disable : 4251) // disable exported dll function
+#  pragma warning (disable : 4800) //'int' : forcing value to bool 'true' or 'false'
+#  pragma warning (disable : 4275) // non dll-interface class
 
 # elif defined(__ICL) && __ICL < 600 // Intel C++ 5
 
@@ -43,7 +47,7 @@
 // The STLport puts all of the standard 'C' library names in std (as far as the
 // user is concerned), but without it you need a fix if you're using MSVC or
 // Intel C++
-# if defined(BOOST_MSVC_STD_ITERATOR)
+# if defined(BOOST_NO_STDC_NAMESPACE)
 #  define BOOST_CSTD_
 # else
 #  define BOOST_CSTD_ std
@@ -62,23 +66,30 @@
 #  define BOOST_PYTHON_DYNAMIC_LIB
 #endif
 
-#if defined(__MWERKS__) \
-  || (defined(__DECCXX_VER) && __DECCXX_VER <= 60590002) \
-  || (defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
-# define BOOST_PYTHON_NO_TEMPLATE_EXPORT
-#endif
+#if defined(BOOST_PYTHON_DYNAMIC_LIB)
 
-#if defined(BOOST_PYTHON_DYNAMIC_LIB) && defined(_WIN32)
-#  if defined(BOOST_PYTHON_SOURCE)
-#     define BOOST_PYTHON_DECL __declspec(dllexport)
-#     define BOOST_PYTHON_BUILD_DLL
-#  else
-#     define BOOST_PYTHON_DECL __declspec(dllimport)
-#  endif
+#  if !defined(_WIN32) && !defined(__CYGWIN__)                  \
+    && defined(__GNUC__) && __GNUC__ >= 3 && __GNUC_MINOR__ >=5 \
+    && !defined(BOOST_PYTHON_GCC_SYMBOL_VISIBILITY)
+#    define BOOST_PYTHON_USE_GCC_SYMBOL_VISIBILITY
+#  endif 
 
-// MinGW, at least, has some problems exporting template instantiations
-#  if defined(__GNUC__) && __GNUC__ < 3 && !defined(__CYGWIN__)
-#   define BOOST_PYTHON_NO_TEMPLATE_EXPORT
+#  if defined(BOOST_PYTHON_USE_GCC_SYMBOL_VISIBILITY)
+#     if defined(BOOST_PYTHON_SOURCE)
+#        define BOOST_PYTHON_DECL __attribute__ ((visibility("default")))
+#        define BOOST_PYTHON_BUILD_DLL
+#     else
+#        define BOOST_PYTHON_DECL
+#     endif
+#     define BOOST_PYTHON_DECL_FORWARD
+#     define BOOST_PYTHON_DECL_EXCEPTION __attribute__ ((visibility("default")))
+#  elif (defined(_WIN32) || defined(__CYGWIN__))
+#     if defined(BOOST_PYTHON_SOURCE)
+#        define BOOST_PYTHON_DECL __declspec(dllexport)
+#        define BOOST_PYTHON_BUILD_DLL
+#     else
+#        define BOOST_PYTHON_DECL __declspec(dllimport)
+#     endif
 #  endif
 
 #endif
@@ -87,26 +98,15 @@
 #  define BOOST_PYTHON_DECL
 #endif
 
-#ifndef BOOST_PYTHON_EXPORT
-# define BOOST_PYTHON_EXPORT extern
-#endif 
-
-#if !defined(BOOST_PYTHON_NO_TEMPLATE_EXPORT)
-# define BOOST_PYTHON_EXPORT_CLASS_TEMPLATE(instantiation) BOOST_PYTHON_EXPORT template class BOOST_PYTHON_DECL instantiation
-#else
-# define BOOST_PYTHON_EXPORT_CLASS_TEMPLATE(instantiation) struct ThIsTyPeNeVeRuSeD
+#ifndef BOOST_PYTHON_DECL_FORWARD
+#  define BOOST_PYTHON_DECL_FORWARD BOOST_PYTHON_DECL
 #endif
 
-#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730
-// Work around a compiler bug.
-// boost::python::detail::function has to be seen by the compiler before the
-// boost::function class template.
-namespace boost { namespace python { namespace detail {
-class function;
-}}}
+#ifndef BOOST_PYTHON_DECL_EXCEPTION
+#  define BOOST_PYTHON_DECL_EXCEPTION BOOST_PYTHON_DECL
 #endif
 
-#if (defined(__DECCXX_VER) && __DECCXX_VER <= 60590014)
+#if BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))
 // Replace broken Tru64/cxx offsetof macro
 # define BOOST_PYTHON_OFFSETOF(s_name, s_member) \
         ((size_t)__INTADDR__(&(((s_name *)0)->s_member)))

include/boost/python/detail/construct.hpp

@@ -1,8 +1,7 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 CONSTRUCT_REFERENCE_DWA2002716_HPP
 # define CONSTRUCT_REFERENCE_DWA2002716_HPP
 

include/boost/python/detail/convertible.hpp

@@ -1,8 +1,7 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 CONVERTIBLE_DWA2002614_HPP
 # define CONVERTIBLE_DWA2002614_HPP
 

include/boost/python/detail/copy_ctor_mutates_rhs.hpp

@@ -0,0 +1,21 @@
+// Copyright David Abrahams 2003.
+// 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 COPY_CTOR_MUTATES_RHS_DWA2003219_HPP
+# define COPY_CTOR_MUTATES_RHS_DWA2003219_HPP
+
+#include <boost/python/detail/is_auto_ptr.hpp>
+#include <boost/mpl/bool.hpp>
+
+namespace boost { namespace python { namespace detail { 
+
+template <class T>
+struct copy_ctor_mutates_rhs
+    : is_auto_ptr<T>
+{
+};
+
+}}} // namespace boost::python::detail
+
+#endif // COPY_CTOR_MUTATES_RHS_DWA2003219_HPP

include/boost/python/detail/cv_category.hpp

@@ -1,8 +1,7 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 CV_CATEGORY_DWA200222_HPP
 # define CV_CATEGORY_DWA200222_HPP
 # include <boost/type_traits/cv_traits.hpp>
@@ -24,9 +23,12 @@ typedef cv_tag<true,true> const_volatile_;
 template <class T>
 struct cv_category
 {
-    BOOST_STATIC_CONSTANT(bool, c = is_const<T>::value);
-    BOOST_STATIC_CONSTANT(bool, v = is_volatile<T>::value);
-    typedef cv_tag<c,v> type;
+//    BOOST_STATIC_CONSTANT(bool, c = is_const<T>::value);
+//    BOOST_STATIC_CONSTANT(bool, v = is_volatile<T>::value);
+    typedef cv_tag<
+        ::boost::is_const<T>::value
+      , ::boost::is_volatile<T>::value
+    > type;
 };
 
 }}} // namespace boost::python::detail

include/boost/python/detail/dealloc.hpp

@@ -0,0 +1,17 @@
+// Copyright Gottfried Ganßauge 2003.
+// 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 BOOST_PYTHON_DETAIL_DEALLOC_HPP_
+# define BOOST_PYTHON_DETAIL_DEALLOC_HPP_
+namespace boost { namespace python { namespace detail {
+    extern "C"
+    {
+        inline void dealloc(PyObject* self)
+        {
+          PyObject_Del(self);
+        }
+    }
+}}} // namespace boost::python::detail
+# endif    // BOOST_PYTHON_DETAIL_DEALLOC_HPP_

include/boost/python/detail/decorated_type_id.hpp

@@ -1,8 +1,7 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 DECORATED_TYPE_ID_DWA2002517_HPP
 # define DECORATED_TYPE_ID_DWA2002517_HPP
 
@@ -38,9 +37,9 @@ inline decorated_type_info decorated_type_id(boost::type<T>* = 0)
     return decorated_type_info(
         type_id<T>()
         , decorated_type_info::decoration(
-            (is_const<T>::value || python::detail::is_reference_to_const<T>::value
+            (is_const<T>::value || indirect_traits::is_reference_to_const<T>::value
              ? decorated_type_info::const_ : 0)
-            | (is_volatile<T>::value || python::detail::is_reference_to_volatile<T>::value
+            | (is_volatile<T>::value || indirect_traits::is_reference_to_volatile<T>::value
                ? decorated_type_info::volatile_ : 0)
             | (is_reference<T>::value ? decorated_type_info::reference : 0)
             )

include/boost/python/detail/decref_guard.hpp

@@ -0,0 +1,21 @@
+// 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 DECREF_GUARD_DWA20021220_HPP
+# define DECREF_GUARD_DWA20021220_HPP
+
+namespace boost { namespace python { namespace detail { 
+
+struct decref_guard
+{
+    decref_guard(PyObject* o) : obj(o) {}
+    ~decref_guard() { Py_XDECREF(obj); }
+    void cancel() { obj = 0; }
+ private:
+    PyObject* obj;
+};
+
+}}} // namespace boost::python::detail
+
+#endif // DECREF_GUARD_DWA20021220_HPP

include/boost/python/detail/def_helper.hpp

@@ -1,77 +1,212 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 DEF_HELPER_DWA200287_HPP
 # define DEF_HELPER_DWA200287_HPP
 
+# include <boost/python/args.hpp>
 # include <boost/type_traits/ice.hpp>
 # include <boost/type_traits/same_traits.hpp>
-# include <boost/python/detail/string_literal.hpp>
+# include <boost/python/detail/indirect_traits.hpp>
+# include <boost/mpl/not.hpp>
+# include <boost/mpl/and.hpp>
+# include <boost/mpl/or.hpp>
+# include <boost/type_traits/add_reference.hpp>
+# include <boost/mpl/lambda.hpp>
+# include <boost/mpl/apply.hpp>
+# include <boost/tuple/tuple.hpp>
+# include <boost/python/detail/not_specified.hpp>
+# include <boost/python/detail/def_helper_fwd.hpp>
 
-namespace boost { namespace python { namespace detail {
+namespace boost { namespace python {
 
-//
-// def_helper<T> --
-//
-//      A helper for def() functions which determines how to interpret
-//      an argument of type T which could be either CallPolicies or a
-//      string literal representing a docstring.
-//
-//      Generates two static functions:
-//
-//        get_policy(x), where x is of type T, returns a policies
-//        object: either a reference to x or default_call_policies()
-//        if x is a string literal.
-//
-//        get_doc(x, s), where s convertible to char const*, returns x
-//        if x is a string literal, s otherwise.
+struct default_call_policies;
 
-template <bool is_string = false>
-struct def_helper_impl
+namespace detail
 {
-    template <class P>
-    static P const&
-    get_policy(P const& x) { return x; }
+  // tuple_extract<Tuple,Predicate>::extract(t) returns the first
+  // element of a Tuple whose type E satisfies the given Predicate
+  // applied to add_reference<E>. The Predicate must be an MPL
+  // metafunction class.
+  template <class Tuple, class Predicate>
+  struct tuple_extract;
 
-    template <class P1, class P2>
-    static P1 const&
-    get_policy(P1 const& x, P2 const&) { return x; } // select left
+  // Implementation class for when the tuple's head type does not
+  // satisfy the Predicate
+  template <bool matched>
+  struct tuple_extract_impl
+  {
+      template <class Tuple, class Predicate>
+      struct apply
+      {
+          typedef typename Tuple::head_type result_type;
+          
+          static typename Tuple::head_type extract(Tuple const& x)
+          {
+              return x.get_head();
+          }
+      };
+  };
 
-    template <class P>
-    static char const*
-    get_doc(P const&, char const* doc) { return doc; } // select right
-};
+  // Implementation specialization for when the tuple's head type
+  // satisfies the predicate
+  template <>
+  struct tuple_extract_impl<false>
+  {
+      template <class Tuple, class Predicate>
+      struct apply
+      {
+          // recursive application of tuple_extract on the tail of the tuple
+          typedef tuple_extract<typename Tuple::tail_type, Predicate> next;
+          typedef typename next::result_type result_type;
+          
+          static result_type extract(Tuple const& x)
+          {
+              return next::extract(x.get_tail());
+          }
+      };
+  };
 
-template <>
-struct def_helper_impl<true>
-{
-    static python::default_call_policies
-    get_policy(char const*)
-    { return default_call_policies(); }
+  // A metafunction which selects a version of tuple_extract_impl to
+  // use for the implementation of tuple_extract
+  template <class Tuple, class Predicate>
+  struct tuple_extract_base_select
+  {
+      typedef typename Tuple::head_type head_type;
+      typedef typename mpl::apply1<Predicate, typename add_reference<head_type>::type>::type match_t;
+      BOOST_STATIC_CONSTANT(bool, match = match_t::value);
+      typedef typename tuple_extract_impl<match>::template apply<Tuple,Predicate> type;
+  };
+  
+  template <class Tuple, class Predicate>
+  struct tuple_extract
+      : tuple_extract_base_select<
+         Tuple
+         , typename mpl::lambda<Predicate>::type
+      >::type
+  {
+  };
 
-    template <class P1, class P2>
-    static P2 const&
-    get_policy(P1 const&, P2 const& y) { return y; } // select right
 
-    template <class P>
-    static char const*
-    get_doc(char const* doc, P const&) // select left
-    { return doc; }
-};
+  //
+  // Specialized extractors for the docstring, keywords, CallPolicies,
+  // and default implementation of virtual functions
+  //
 
-template <class T>
-struct def_helper
-    : def_helper_impl<
-    type_traits::ice_or<
-    is_string_literal<T const>::value
-    , is_same<T, char const*>::value
-    , is_same<T, char*>::value
->::value
->
-{};
+  template <class Tuple>
+  struct doc_extract
+      : tuple_extract<
+        Tuple
+        , mpl::not_<
+           mpl::or_<
+               indirect_traits::is_reference_to_class<mpl::_1>
+             , indirect_traits::is_reference_to_member_function_pointer<mpl::_1 >
+           >
+        >
+     >
+  {
+  };
+  
+  template <class Tuple>
+  struct keyword_extract
+      : tuple_extract<Tuple, is_reference_to_keywords<mpl::_1 > >
+  {
+  };
 
-}}} // namespace boost::python::detail
+  template <class Tuple>
+  struct policy_extract
+      : tuple_extract<
+          Tuple
+          , mpl::and_<
+             mpl::not_<is_same<not_specified const&,mpl::_1> >
+              , indirect_traits::is_reference_to_class<mpl::_1 >
+              , mpl::not_<is_reference_to_keywords<mpl::_1 > >
+          >
+        >
+  {
+  };
+
+  template <class Tuple>
+  struct default_implementation_extract
+      : tuple_extract<
+          Tuple
+          , indirect_traits::is_reference_to_member_function_pointer<mpl::_1 >
+          >
+  {
+  };
+
+  //
+  // A helper class for decoding the optional arguments to def()
+  // invocations, which can be supplied in any order and are
+  // discriminated by their type properties. The template parameters
+  // are expected to be the types of the actual (optional) arguments
+  // passed to def().
+  //
+  template <class T1, class T2, class T3, class T4>
+  struct def_helper
+  {
+      // A tuple type which begins with references to the supplied
+      // arguments and ends with actual representatives of the default
+      // types.
+      typedef boost::tuples::tuple<
+          T1 const&
+          , T2 const&
+          , T3 const&
+          , T4 const&
+          , default_call_policies
+          , keywords<0>
+          , char const*
+          , void(not_specified::*)()   // A function pointer type which is never an
+                                       // appropriate default implementation
+          > all_t;
+
+      // Constructors; these initialize an member of the tuple type
+      // shown above.
+      def_helper(T1 const& a1) : m_all(a1,m_nil,m_nil,m_nil) {}
+      def_helper(T1 const& a1, T2 const& a2) : m_all(a1,a2,m_nil,m_nil) {}
+      def_helper(T1 const& a1, T2 const& a2, T3 const& a3) : m_all(a1,a2,a3,m_nil) {}
+      def_helper(T1 const& a1, T2 const& a2, T3 const& a3, T4 const& a4) : m_all(a1,a2,a3,a4) {}
+
+   private: // types
+      typedef typename default_implementation_extract<all_t>::result_type default_implementation_t;
+      
+   public: // Constants which can be used for static assertions.
+
+      // Users must not supply a default implementation for non-class
+      // methods.
+      BOOST_STATIC_CONSTANT(
+          bool, has_default_implementation = (
+              !is_same<default_implementation_t, void(not_specified::*)()>::value));
+      
+   public: // Extractor functions which pull the appropriate value out
+           // of the tuple
+      char const* doc() const
+      {
+          return doc_extract<all_t>::extract(m_all);
+      }
+      
+      typename keyword_extract<all_t>::result_type keywords() const
+      {
+          return keyword_extract<all_t>::extract(m_all);
+      }
+      
+      typename policy_extract<all_t>::result_type policies() const
+      {
+          return policy_extract<all_t>::extract(m_all);
+      }
+
+      default_implementation_t default_implementation() const
+      {
+          return default_implementation_extract<all_t>::extract(m_all);
+      }
+      
+   private: // data members
+      all_t m_all; 
+      not_specified m_nil; // for filling in not_specified slots
+  };
+}
+
+}} // namespace boost::python::detail
 
 #endif // DEF_HELPER_DWA200287_HPP

include/boost/python/detail/def_helper_fwd.hpp

@@ -0,0 +1,17 @@
+// Copyright David Abrahams 2003.
+// 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 DEF_HELPER_FWD_DWA2003810_HPP
+# define DEF_HELPER_FWD_DWA2003810_HPP
+
+# include <boost/python/detail/not_specified.hpp>
+
+namespace boost { namespace python { namespace detail { 
+
+template <class T1, class T2 = not_specified, class T3 = not_specified, class T4 = not_specified>
+struct def_helper;
+
+}}} // namespace boost::python::detail
+
+#endif // DEF_HELPER_FWD_DWA2003810_HPP

include/boost/python/detail/defaults_def.hpp

@@ -1,10 +1,9 @@
 ///////////////////////////////////////////////////////////////////////////////
 //
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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)
 //
 ///////////////////////////////////////////////////////////////////////////////
 #if !defined(BOOST_PP_IS_ITERATING)
@@ -19,9 +18,11 @@
 #include <boost/static_assert.hpp>
 #include <boost/preprocessor/iterate.hpp>
 #include <boost/python/class_fwd.hpp>
-#include <boost/python/object/function.hpp>
 #include <boost/python/scope.hpp>
 #include <boost/preprocessor/debug/line.hpp>
+#include <boost/python/detail/scope.hpp>
+#include <boost/python/detail/make_keyword_range_fn.hpp>
+#include <boost/python/object/add_to_namespace.hpp>
 
 ///////////////////////////////////////////////////////////////////////////////
 namespace boost { namespace python {
@@ -33,195 +34,232 @@ namespace objects
   struct class_base;
 }
 
-namespace detail {
-
-template <class Func, class CallPolicies, class NameSpaceT>
-static void name_space_def(
-    NameSpaceT& name_space,
-    char const* name,
-    Func f,
-    CallPolicies const& policies,
-    char const* doc,
-    objects::class_base*
-    )
+namespace detail
 {
-    name_space.def(
-        name, f, policies, doc);
-}
+  // Called as::
+  //
+  //    name_space_def(ns, "func", func, kw, policies, docstring, &ns)
+  //
+  // Dispatch to properly add f to namespace ns.
+  //
+  // @group define_stub_function helpers { 
+  template <class Func, class CallPolicies, class NameSpaceT>
+  static void name_space_def(
+      NameSpaceT& name_space
+      , char const* name
+      , Func f
+      , keyword_range const& kw
+      , CallPolicies const& policies
+      , char const* doc
+      , objects::class_base*
+      )
+  {
+      typedef typename NameSpaceT::wrapped_type wrapped_type;
+      
+      objects::add_to_namespace(
+          name_space, name,
+          detail::make_keyword_range_function(
+              f, policies, kw, get_signature(f, (wrapped_type*)0))
+        , doc
+      );
+  }
 
-template <class Func, class CallPolicies>
-static void name_space_def(
-    object& name_space,
-    char const* name,
-    Func f,
-    CallPolicies const& policies,
-    char const* doc,
-    ...
-    )
-{
-    scope within(name_space);
+  template <class Func, class CallPolicies>
+  static void name_space_def(
+      object& name_space
+      , char const* name
+      , Func f
+      , keyword_range const& kw
+      , CallPolicies const& policies
+      , char const* doc
+      , ...
+      )
+  {
+      scope within(name_space);
 
-    def(name, f, policies, doc);
-}
+      detail::scope_setattr_doc(
+          name
+          , detail::make_keyword_range_function(f, policies, kw)
+          , doc);
+  }
 
-// For backward compatibility
-template <class Func, class CallPolicies, class NameSpaceT>
-static void name_space_def(
-    NameSpaceT& name_space,
-    char const* name,
-    Func f,
-    CallPolicies const& policies,
-    char const* doc,
-    module*
-    )
-{
-    name_space.def(
-        name, f, policies, doc);
-}
+  // For backward compatibility -- is this obsolete?
+  template <class Func, class CallPolicies, class NameSpaceT>
+  static void name_space_def(
+      NameSpaceT& name_space
+      , char const* name
+      , Func f
+      , keyword_range const& kw // ignored
+      , CallPolicies const& policies
+      , char const* doc
+      , module*
+      )
+  {
+      name_space.def(name, f, policies, doc);
+  }
+  // }
 
-///////////////////////////////////////////////////////////////////////////////
-//
-//  This Boost PP code generates expansions for
-//
-//      template <typename StubsT, typename NameSpaceT>
-//      inline void
-//      define_stub_function(
-//          char const* name, StubsT s, NameSpaceT& name_space, mpl::int_c<N>)
-//      {
-//          name_space.def(name, &StubsT::func_N);
-//      }
-//
-//  where N runs from 0 to BOOST_PYTHON_MAX_ARITY
-//
-//  The set of overloaded functions (define_stub_function) expects:
-//
-//      1. char const* name:    function name that will be visible to python
-//      2. StubsT:              a function stubs struct (see defaults_gen.hpp)
-//      3. NameSpaceT& name_space:     a python::class_ or python::module instance
-//      4. int_t<N>:            the Nth overloaded function (StubsT::func_N)
-//                                  (see defaults_gen.hpp)
-//      5. char const* name:    doc string
-//
-///////////////////////////////////////////////////////////////////////////////
-template <int N>
-struct define_stub_function {};
+
+  //  Expansions of ::
+  //
+  //      template <typename OverloadsT, typename NameSpaceT>
+  //      inline void
+  //      define_stub_function(
+  //          char const* name, OverloadsT s, NameSpaceT& name_space, mpl::int_<N>)
+  //      {
+  //          name_space.def(name, &OverloadsT::func_N);
+  //      }
+  //
+  //  where N runs from 0 to BOOST_PYTHON_MAX_ARITY.
+  //
+  //  The set of overloaded functions (define_stub_function) expects:
+  //
+  //      1. char const* name:        function name that will be visible to python
+  //      2. OverloadsT:              a function overloads struct (see defaults_gen.hpp)
+  //      3. NameSpaceT& name_space:  a python::class_ or python::module instance
+  //      4. int_t<N>:                the Nth overloaded function (OverloadsT::func_N)
+  //                                  (see defaults_gen.hpp)
+  //      5. char const* name:        doc string
+  //
+  // @group define_stub_function<N> {
+  template <int N>
+  struct define_stub_function {};
 
 #define BOOST_PP_ITERATION_PARAMS_1                                             \
     (3, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/detail/defaults_def.hpp>))
 
 #include BOOST_PP_ITERATE()
+  
+  // }
+  
+  //  This helper template struct does the actual recursive
+  //  definition.  There's a generic version
+  //  define_with_defaults_helper<N> and a terminal case
+  //  define_with_defaults_helper<0>. The struct and its
+  //  specialization has a sole static member function def that
+  //  expects:
+  //
+  //    1. char const* name:        function name that will be
+  //                                visible to python
+  //
+  //    2. OverloadsT:              a function overloads struct
+  //                                (see defaults_gen.hpp)
+  //
+  //    3. NameSpaceT& name_space:  a python::class_ or
+  //                                python::module instance
+  //
+  //    4. char const* name:        doc string
+  //
+  //  The def static member function calls a corresponding
+  //  define_stub_function<N>. The general case recursively calls
+  //  define_with_defaults_helper<N-1>::def until it reaches the
+  //  terminal case case define_with_defaults_helper<0>.
+  template <int N>
+  struct define_with_defaults_helper {
 
-///////////////////////////////////////////////////////////////////////////////
-//
-//  define_with_defaults_helper<N>
-//
-//  This helper template struct does the actual recursive definition.
-//  There's a generic version define_with_defaults_helper<N> and a
-//  terminal case define_with_defaults_helper<0>. The struct and its
-//  specialization has a sole static member function def that expects:
-//
-//      1. char const* name:    function name that will be visible to python
-//      2. StubsT:              a function stubs struct (see defaults_gen.hpp)
-//      3. NameSpaceT& name_space:     a python::class_ or python::module instance
-//      4. char const* name:    doc string
-//
-//  The def static member function calls a corresponding
-//  define_stub_function<N>. The general case recursively calls
-//  define_with_defaults_helper<N-1>::def until it reaches the
-//  terminal case case define_with_defaults_helper<0>.
-//
-///////////////////////////////////////////////////////////////////////////////
-    template <int N>
-    struct define_with_defaults_helper {
+      template <class StubsT, class CallPolicies, class NameSpaceT>
+      static void
+      def(
+          char const* name,
+          StubsT stubs,
+          keyword_range kw,
+          CallPolicies const& policies,
+          NameSpaceT& name_space,
+          char const* doc)
+      {
+          //  define the NTH stub function of stubs
+          define_stub_function<N>::define(name, stubs, kw, policies, name_space, 0);
 
-        template <class StubsT, class CallPolicies, class NameSpaceT>
-        static void
-        def(
-            char const* name,
-            StubsT stubs,
-            CallPolicies const& policies,
-            NameSpaceT& name_space,
-            char const* doc)
-        {
-            //  define the NTH stub function of stubs
-            define_stub_function<N>::define(name, stubs, policies, name_space, doc);
-            //  call the next define_with_defaults_helper
-            define_with_defaults_helper<N-1>::def(name, stubs, policies, name_space, doc);
-        }
-    };
+          if (kw.second > kw.first)
+              --kw.second;
 
-///////////////////////////////////////
-    template <>
-    struct define_with_defaults_helper<0> {
+          //  call the next define_with_defaults_helper
+          define_with_defaults_helper<N-1>::def(name, stubs, kw, policies, name_space, doc);
+      }
+  };
 
-        template <class StubsT, class CallPolicies, class NameSpaceT>
-        static void
-        def(
-            char const* name,
-            StubsT stubs,
-            CallPolicies const& policies,
-            NameSpaceT& name_space,
-            char const* doc)
-        {
-            //  define the Oth stub function of stubs
-            define_stub_function<0>::define(name, stubs, policies, name_space, doc);
-            //  return
-        }
-    };
+  template <>
+  struct define_with_defaults_helper<0> {
 
-///////////////////////////////////////////////////////////////////////////////
-//
-//  define_with_defaults
-//
-//      1. char const* name:        function name that will be visible to python
-//      2. StubsT:                  a function stubs struct (see defaults_gen.hpp)
-//      3. CallPolicies& policies:  Call policies
-//      4. NameSpaceT& name_space:  a python::class_ or python::module instance
-//      5. SigT sig:                Function signature typelist (see defaults_gen.hpp)
-//      6. char const* name:        doc string
-//
-//  This is the main entry point. This function recursively defines all
-//  stub functions of StubT (see defaults_gen.hpp) in NameSpaceT name_space which
-//  can be either a python::class_ or a python::module. The sig argument
-//  is a typelist that specifies the return type, the class (for member
-//  functions, and the arguments. Here are some SigT examples:
-//
-//      int foo(int)        mpl::list<int, int>
-//      void bar(int, int)  mpl::list<void, int, int>
-//      void C::foo(int)    mpl::list<void, C, int>
-//
-///////////////////////////////////////////////////////////////////////////////
-    template <class StubsT, class NameSpaceT, class SigT>
-    inline void
-    define_with_defaults(
-        char const* name,
-        StubsT const& stubs,
-        NameSpaceT& name_space,
-        SigT sig)
-    {
-        typedef typename mpl::front<SigT>::type return_type;
-        typedef typename StubsT::void_return_type void_return_type;
-        typedef typename StubsT::non_void_return_type non_void_return_type;
+      template <class StubsT, class CallPolicies, class NameSpaceT>
+      static void
+      def(
+          char const* name,
+          StubsT stubs,
+          keyword_range const& kw,
+          CallPolicies const& policies,
+          NameSpaceT& name_space,
+          char const* doc)
+      {
+          //  define the Oth stub function of stubs
+          define_stub_function<0>::define(name, stubs, kw, policies, name_space, doc);
+          //  return
+      }
+  };
 
-        typedef typename mpl::if_c<
-            boost::is_same<void, return_type>::value
-            , void_return_type
-            , non_void_return_type
-        >::type stubs_type;
+  //  define_with_defaults
+  //
+  //      1. char const* name:        function name that will be
+  //                                  visible to python
+  //
+  //      2. OverloadsT:              a function overloads struct
+  //                                  (see defaults_gen.hpp)
+  //
+  //      3. CallPolicies& policies:  Call policies
+  //      4. NameSpaceT& name_space:  a python::class_ or
+  //                                  python::module instance
+  //
+  //      5. SigT sig:                Function signature typelist
+  //                                  (see defaults_gen.hpp)
+  //
+  //      6. char const* name:        doc string
+  //
+  //  This is the main entry point. This function recursively
+  //  defines all stub functions of StubT (see defaults_gen.hpp) in
+  //  NameSpaceT name_space which can be either a python::class_ or
+  //  a python::module. The sig argument is a typelist that
+  //  specifies the return type, the class (for member functions,
+  //  and the arguments. Here are some SigT examples:
+  //
+  //      int foo(int)        mpl::vector<int, int>
+  //      void bar(int, int)  mpl::vector<void, int, int>
+  //      void C::foo(int)    mpl::vector<void, C, int>
+  //
+  template <class OverloadsT, class NameSpaceT, class SigT>
+  inline void
+  define_with_defaults(
+      char const* name,
+      OverloadsT const& overloads,
+      NameSpaceT& name_space,
+      SigT const&)
+  {
+      typedef typename mpl::front<SigT>::type return_type;
+      typedef typename OverloadsT::void_return_type void_return_type;
+      typedef typename OverloadsT::non_void_return_type non_void_return_type;
 
-        BOOST_STATIC_ASSERT(
-            (stubs_type::max_args) <= mpl::size<SigT>::value);
+      typedef typename mpl::if_c<
+          boost::is_same<void, return_type>::value
+          , void_return_type
+          , non_void_return_type
+      >::type stubs_type;
 
-        typedef typename stubs_type::template gen<SigT> gen_type;
-        define_with_defaults_helper<stubs_type::n_funcs-1>::def
-            (name, gen_type(), stubs.call_policies(), name_space, stubs.doc_string());
-    }
+      BOOST_STATIC_ASSERT(
+          (stubs_type::max_args) <= mpl::size<SigT>::value);
+
+      typedef typename stubs_type::template gen<SigT> gen_type;
+      define_with_defaults_helper<stubs_type::n_funcs-1>::def(
+          name
+          , gen_type()
+          , overloads.keywords()
+          , overloads.call_policies()
+          , name_space
+          , overloads.doc_string());
+  }
 
 } // namespace detail
 
 }} // namespace boost::python
 
-///////////////////////////////////////////////////////////////////////////////
 #endif // DEFAULTS_DEF_JDG20020811_HPP
 
 #else // defined(BOOST_PP_IS_ITERATING)
@@ -232,17 +270,21 @@ template <>
 struct define_stub_function<BOOST_PP_ITERATION()> {
     template <class StubsT, class CallPolicies, class NameSpaceT>
     static void define(
-        char const* name,
-        StubsT,
-        CallPolicies const& policies,
-        NameSpaceT& name_space,
-        char const* doc)
+        char const* name
+        , StubsT const&
+        , keyword_range const& kw
+        , CallPolicies const& policies
+        , NameSpaceT& name_space
+        , char const* doc)
     {
-        detail::name_space_def(name_space,
-            name,
-            &StubsT::BOOST_PP_CAT(func_, BOOST_PP_ITERATION()),
-            policies,
-            doc, &name_space);
+        detail::name_space_def(
+            name_space
+            , name
+            , &StubsT::BOOST_PP_CAT(func_, BOOST_PP_ITERATION())
+            , kw
+            , policies
+            , doc
+            , &name_space);
     }
 };
 

include/boost/python/detail/defaults_gen.hpp

@@ -1,10 +1,9 @@
 ///////////////////////////////////////////////////////////////////////////////
 //
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 DEFAULTS_GEN_JDG20020807_HPP
@@ -15,6 +14,7 @@
 #include <boost/preprocessor/repeat_from_to.hpp>
 #include <boost/preprocessor/enum.hpp>
 #include <boost/preprocessor/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
 #include <boost/preprocessor/tuple.hpp>
 #include <boost/preprocessor/cat.hpp>
 #include <boost/preprocessor/arithmetic/sub.hpp>
@@ -23,112 +23,137 @@
 #include <boost/preprocessor/empty.hpp>
 #include <boost/preprocessor/comma_if.hpp>
 #include <boost/config.hpp>
-#include <boost/mpl/at.hpp>
-#include <boost/mpl/front.hpp>
+#include <boost/mpl/begin_end.hpp>
+#include <boost/mpl/next.hpp>
+#include <boost/mpl/deref.hpp>
+#include <cstddef>
 
 namespace boost { namespace python {
 
-    //  overloads_base is used as a base class for all function
-    //  stubs. This class holds the doc_string of the stubs.
-
-    namespace detail
-    {
-        struct overloads_base
-        {
-            overloads_base(char const* doc_)
-            : doc(doc_) {}
-
-            char const* doc_string() const
-            { return doc; }
-
-            char const* doc;
-        };
-    }
-
-//  overloads_proxy is generated by the overloads_common operator[] (see
-//  below). This class holds a user defined call policies of the stubs.
-
-template <class CallPoliciesT, class OverloadsT>
-struct overloads_proxy
-: public detail::overloads_base
+namespace detail
 {
-    typedef typename OverloadsT::non_void_return_type   non_void_return_type;
-    typedef typename OverloadsT::void_return_type       void_return_type;
+  // overloads_base is used as a base class for all function
+  // stubs. This class holds the doc_string of the stubs.
+  struct overloads_base
+  {
+      overloads_base(char const* doc_)
+          : m_doc(doc_) {}
 
-    overloads_proxy(CallPoliciesT const& policies_, char const* doc)
-    : detail::overloads_base(doc), policies(policies_) {}
+      overloads_base(char const* doc_, detail::keyword_range const& kw)
+          : m_doc(doc_), m_keywords(kw) {}
 
-    CallPoliciesT
-    call_policies() const
-    { return policies; }
+      char const* doc_string() const
+      {
+          return m_doc;
+      }
 
-    CallPoliciesT policies;
-};
+      detail::keyword_range const& keywords() const
+      {
+          return m_keywords;
+      }
 
-//  overloads_common is our default function stubs base class. This class
-//  returns the default_call_policies in its call_policies() member function.
-//  It can generate a overloads_proxy however through its operator[]
+   private:
+      char const* m_doc;
+      detail::keyword_range m_keywords;
+  };
 
-template <class DerivedT>
-struct overloads_common
-: public detail::overloads_base {
+  // overloads_proxy is generated by the overloads_common operator[] (see
+  // below). This class holds a user defined call policies of the stubs.
+  template <class CallPoliciesT, class OverloadsT>
+  struct overloads_proxy
+      : public overloads_base
+  {
+      typedef typename OverloadsT::non_void_return_type   non_void_return_type;
+      typedef typename OverloadsT::void_return_type       void_return_type;
 
-    overloads_common(char const* doc)
-    : detail::overloads_base(doc) {}
+      overloads_proxy(
+          CallPoliciesT const& policies_
+          , char const* doc
+          , keyword_range const& kw
+          )
+          : overloads_base(doc, kw)
+            , policies(policies_)
+      {}
 
-    default_call_policies
-    call_policies() const
-    { return default_call_policies(); }
+      CallPoliciesT
+      call_policies() const
+      {
+          return policies;
+      }
 
-    template <class CallPoliciesT>
-    ::boost::python::overloads_proxy<CallPoliciesT, DerivedT>
-    operator[](CallPoliciesT const& policies) const
-    {
-        return overloads_proxy<CallPoliciesT, DerivedT>
-            (policies, doc);
-    }
-};
+      CallPoliciesT policies;
+  };
+
+  // overloads_common is our default function stubs base class. This
+  // class returns the default_call_policies in its call_policies()
+  // member function.  It can generate a overloads_proxy however through
+  // its operator[]
+  template <class DerivedT>
+  struct overloads_common
+      : public overloads_base
+  {
+      overloads_common(char const* doc)
+          : overloads_base(doc) {}
+
+      overloads_common(char const* doc, keyword_range const& kw)
+          : overloads_base(doc, kw) {}
+
+      default_call_policies
+      call_policies() const
+      {
+          return default_call_policies();
+      }
+
+      template <class CallPoliciesT>
+      overloads_proxy<CallPoliciesT, DerivedT>
+      operator[](CallPoliciesT const& policies) const
+      {
+          return overloads_proxy<CallPoliciesT, DerivedT>(
+              policies, this->doc_string(), this->keywords());
+      }
+  };
+
+}}} // namespace boost::python::detail
 
-}} // namespace boost::python
 
-///////////////////////////////////////////////////////////////////////////////
 #define BOOST_PYTHON_TYPEDEF_GEN(z, index, data)                                \
-    typedef typename BOOST_PP_CAT(iter, index)::next                            \
+    typedef typename ::boost::mpl::next<BOOST_PP_CAT(iter, index)>::type        \
         BOOST_PP_CAT(iter, BOOST_PP_INC(index));                                \
-    typedef typename BOOST_PP_CAT(iter, index)::type BOOST_PP_CAT(T, index);    \
+    typedef typename ::boost::mpl::deref<BOOST_PP_CAT(iter, index)>::type       \
+        BOOST_PP_CAT(T, index);
 
-#define BOOST_PYTHON_FUNC_WRAPPER_GEN(z, index, data)                           \
-    static RT BOOST_PP_CAT(func_,                                               \
-        BOOST_PP_SUB_D(1, index, BOOST_PP_TUPLE_ELEM(3, 1, data))) (            \
-        BOOST_PYTHON_BINARY_ENUM(                                               \
-            index, T, arg))                                                     \
-    {                                                                           \
-        BOOST_PP_TUPLE_ELEM(3, 2, data)                                         \
-        BOOST_PP_TUPLE_ELEM(3, 0, data)(                                        \
-            BOOST_PP_ENUM_PARAMS(                                               \
-                index,                                                          \
-                arg));                                                          \
+#define BOOST_PYTHON_FUNC_WRAPPER_GEN(z, index, data)                   \
+    static RT BOOST_PP_CAT(func_,                                       \
+        BOOST_PP_SUB_D(1, index, BOOST_PP_TUPLE_ELEM(3, 1, data))) (    \
+        BOOST_PP_ENUM_BINARY_PARAMS_Z(                                  \
+            1, index, T, arg))                                          \
+    {                                                                   \
+        BOOST_PP_TUPLE_ELEM(3, 2, data)                                 \
+        BOOST_PP_TUPLE_ELEM(3, 0, data)(                                \
+            BOOST_PP_ENUM_PARAMS(                                       \
+                index,                                                  \
+                arg));                                                  \
     }
 
 #define BOOST_PYTHON_GEN_FUNCTION(fname, fstubs_name, n_args, n_dflts, ret)     \
-    struct fstubs_name {                                                        \
-                                                                                \
+    struct fstubs_name                                                          \
+    {                                                                           \
         BOOST_STATIC_CONSTANT(int, n_funcs = BOOST_PP_INC(n_dflts));            \
         BOOST_STATIC_CONSTANT(int, max_args = n_funcs);                         \
                                                                                 \
         template <typename SigT>                                                \
-        struct gen {                                                            \
-                                                                                \
+        struct gen                                                              \
+        {                                                                       \
             typedef typename ::boost::mpl::begin<SigT>::type rt_iter;           \
-            typedef typename rt_iter::type RT;                                  \
-            typedef typename rt_iter::next iter0;                               \
+            typedef typename ::boost::mpl::deref<rt_iter>::type RT;             \
+            typedef typename ::boost::mpl::next<rt_iter>::type iter0;           \
                                                                                 \
             BOOST_PP_REPEAT_2ND(                                                \
                 n_args,                                                         \
                 BOOST_PYTHON_TYPEDEF_GEN,                                       \
                 0)                                                              \
                                                                                 \
-            BOOST_PP_REPEAT_FROM_TO(                                            \
+            BOOST_PP_REPEAT_FROM_TO_2(                                          \
                 BOOST_PP_SUB_D(1, n_args, n_dflts),                             \
                 BOOST_PP_INC(n_args),                                           \
                 BOOST_PYTHON_FUNC_WRAPPER_GEN,                                  \
@@ -140,8 +165,8 @@ struct overloads_common
 #define BOOST_PYTHON_MEM_FUNC_WRAPPER_GEN(z, index, data)                       \
     static RT BOOST_PP_CAT(func_,                                               \
         BOOST_PP_SUB_D(1, index, BOOST_PP_TUPLE_ELEM(3, 1, data))) (            \
-            ClassT& obj BOOST_PP_COMMA_IF(index)                                \
-            BOOST_PYTHON_BINARY_ENUM(index, T, arg)                             \
+            ClassT obj BOOST_PP_COMMA_IF(index)                                 \
+            BOOST_PP_ENUM_BINARY_PARAMS_Z(1, index, T, arg)                     \
         )                                                                       \
     {                                                                           \
         BOOST_PP_TUPLE_ELEM(3, 2, data) obj.BOOST_PP_TUPLE_ELEM(3, 0, data)(    \
@@ -150,27 +175,27 @@ struct overloads_common
     }
 
 #define BOOST_PYTHON_GEN_MEM_FUNCTION(fname, fstubs_name, n_args, n_dflts, ret) \
-    struct fstubs_name {                                                        \
-                                                                                \
+    struct fstubs_name                                                          \
+    {                                                                           \
         BOOST_STATIC_CONSTANT(int, n_funcs = BOOST_PP_INC(n_dflts));            \
         BOOST_STATIC_CONSTANT(int, max_args = n_funcs + 1);                     \
                                                                                 \
         template <typename SigT>                                                \
-        struct gen {                                                            \
-                                                                                \
+        struct gen                                                              \
+        {                                                                       \
             typedef typename ::boost::mpl::begin<SigT>::type rt_iter;           \
-            typedef typename rt_iter::type RT;                                  \
+            typedef typename ::boost::mpl::deref<rt_iter>::type RT;             \
                                                                                 \
-            typedef typename rt_iter::next class_iter;                          \
-            typedef typename class_iter::type ClassT;                           \
-            typedef typename class_iter::next iter0;                            \
+            typedef typename ::boost::mpl::next<rt_iter>::type class_iter;      \
+            typedef typename ::boost::mpl::deref<class_iter>::type ClassT;      \
+            typedef typename ::boost::mpl::next<class_iter>::type iter0;        \
                                                                                 \
             BOOST_PP_REPEAT_2ND(                                                \
                 n_args,                                                         \
                 BOOST_PYTHON_TYPEDEF_GEN,                                       \
                 0)                                                              \
                                                                                 \
-            BOOST_PP_REPEAT_FROM_TO(                                            \
+            BOOST_PP_REPEAT_FROM_TO_2(                                          \
                 BOOST_PP_SUB_D(1, n_args, n_dflts),                             \
                 BOOST_PP_INC(n_args),                                           \
                 BOOST_PYTHON_MEM_FUNC_WRAPPER_GEN,                              \
@@ -178,75 +203,80 @@ struct overloads_common
         };                                                                      \
     };
 
-///////////////////////////////////////////////////////////////////////////////
-#if defined(BOOST_NO_VOID_RETURNS)
+#define BOOST_PYTHON_OVERLOAD_CONSTRUCTORS(fstubs_name, n_args, n_dflts)                    \
+    fstubs_name(char const* doc = 0)                                                        \
+        : ::boost::python::detail::overloads_common<fstubs_name>(doc) {}                    \
+    template <std::size_t N>                                                                \
+    fstubs_name(char const* doc, ::boost::python::detail::keywords<N> const& keywords)      \
+        : ::boost::python::detail::overloads_common<fstubs_name>(                           \
+            doc, keywords.range())                                                          \
+    {                                                                                       \
+        typedef typename ::boost::python::detail::                                          \
+            error::more_keywords_than_function_arguments<                                   \
+                N,n_args>::too_many_keywords assertion;                                     \
+    }                                                                                       \
+    template <std::size_t N>                                                                \
+    fstubs_name(::boost::python::detail::keywords<N> const& keywords, char const* doc = 0)  \
+        : ::boost::python::detail::overloads_common<fstubs_name>(                           \
+            doc, keywords.range())                                                          \
+    {                                                                                       \
+        typedef typename ::boost::python::detail::                                          \
+            error::more_keywords_than_function_arguments<                                   \
+                N,n_args>::too_many_keywords assertion;                                     \
+    }
 
-#define BOOST_PYTHON_GEN_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts)     \
-    BOOST_PYTHON_GEN_FUNCTION                                                   \
-        (fname, BOOST_PP_CAT(fstubs_name, _NV), n_args, n_dflts, return)        \
-    BOOST_PYTHON_GEN_FUNCTION                                                   \
-        (fname, BOOST_PP_CAT(fstubs_name, _V), n_args, n_dflts, ;)              \
+# if defined(BOOST_NO_VOID_RETURNS)
+
+#  define BOOST_PYTHON_GEN_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts)   \
     struct fstubs_name                                                          \
-    : public boost::python::overloads_common<fstubs_name>                       \
+        : public ::boost::python::detail::overloads_common<fstubs_name>         \
     {                                                                           \
-        typedef BOOST_PP_CAT(fstubs_name, _NV)  non_void_return_type;           \
-        typedef BOOST_PP_CAT(fstubs_name, _V)   void_return_type;               \
+        BOOST_PYTHON_GEN_FUNCTION(                                              \
+            fname, non_void_return_type, n_args, n_dflts, return)               \
+        BOOST_PYTHON_GEN_FUNCTION(                                              \
+            fname, void_return_type, n_args, n_dflts, ;)                        \
                                                                                 \
-        fstubs_name(char const* doc = 0)                                        \
-        : boost::python::                                                       \
-            overloads_common<fstubs_name>(doc) {}                               \
-    };                                                                          \
+        BOOST_PYTHON_OVERLOAD_CONSTRUCTORS(fstubs_name, n_args, n_dflts)        \
+    };
 
-///////////////////////////////////////////////////////////////////////////////
-#define BOOST_PYTHON_GEN_MEM_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts) \
-    BOOST_PYTHON_GEN_MEM_FUNCTION                                               \
-        (fname, BOOST_PP_CAT(fstubs_name, _NV), n_args, n_dflts, return)        \
-    BOOST_PYTHON_GEN_MEM_FUNCTION                                               \
-        (fname, BOOST_PP_CAT(fstubs_name, _V), n_args, n_dflts, ;)              \
+#  define BOOST_PYTHON_GEN_MEM_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts)       \
+    struct fstubs_name                                                                  \
+        : public ::boost::python::detail::overloads_common<fstubs_name>                 \
+    {                                                                                   \
+        BOOST_PYTHON_GEN_MEM_FUNCTION(                                                  \
+            fname, non_void_return_type, n_args, n_dflts, return)                       \
+        BOOST_PYTHON_GEN_MEM_FUNCTION(                                                  \
+            fname, void_return_type, n_args, n_dflts, ;)                                \
+                                                                                        \
+        BOOST_PYTHON_OVERLOAD_CONSTRUCTORS(fstubs_name, n_args, n_dflts)                \
+    };
+
+# else // !defined(BOOST_NO_VOID_RETURNS)
+
+#  define BOOST_PYTHON_GEN_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts)   \
     struct fstubs_name                                                          \
-    : public boost::python::overloads_common<fstubs_name>                       \
+        : public ::boost::python::detail::overloads_common<fstubs_name>         \
     {                                                                           \
-        typedef BOOST_PP_CAT(fstubs_name, _NV)  non_void_return_type;           \
-        typedef BOOST_PP_CAT(fstubs_name, _V)   void_return_type;               \
+        BOOST_PYTHON_GEN_FUNCTION(                                              \
+            fname, non_void_return_type, n_args, n_dflts, return)               \
                                                                                 \
-        fstubs_name(char const* doc = 0)                                        \
-        : boost::python::                                                       \
-            overloads_common<fstubs_name>(doc) {}                               \
-    };                                                                          \
+        typedef non_void_return_type void_return_type;                          \
+        BOOST_PYTHON_OVERLOAD_CONSTRUCTORS(fstubs_name, n_args, n_dflts)        \
+    };
 
-#else
 
-///////////////////////////////////////////////////////////////////////////////
-#define BOOST_PYTHON_GEN_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts)     \
-    BOOST_PYTHON_GEN_FUNCTION                                                   \
-        (fname, BOOST_PP_CAT(fstubs_name, _NV), n_args, n_dflts, return)        \
-    struct fstubs_name                                                          \
-    : public boost::python::overloads_common<fstubs_name>                       \
-    {                                                                           \
-        typedef BOOST_PP_CAT(fstubs_name, _NV)  non_void_return_type;           \
-        typedef BOOST_PP_CAT(fstubs_name, _NV)  void_return_type;               \
-                                                                                \
-        fstubs_name(char const* doc = 0)                                        \
-        : boost::python::                                                       \
-            overloads_common<fstubs_name>(doc) {}                               \
-    };                                                                          \
+#  define BOOST_PYTHON_GEN_MEM_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts)       \
+    struct fstubs_name                                                                  \
+        : public ::boost::python::detail::overloads_common<fstubs_name>                 \
+    {                                                                                   \
+        BOOST_PYTHON_GEN_MEM_FUNCTION(                                                  \
+            fname, non_void_return_type, n_args, n_dflts, return)                       \
+                                                                                        \
+        typedef non_void_return_type void_return_type;                                  \
+        BOOST_PYTHON_OVERLOAD_CONSTRUCTORS(fstubs_name, n_args, n_dflts)                \
+    };
 
-///////////////////////////////////////////////////////////////////////////////
-#define BOOST_PYTHON_GEN_MEM_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts) \
-    BOOST_PYTHON_GEN_MEM_FUNCTION                                               \
-        (fname, BOOST_PP_CAT(fstubs_name, _NV), n_args, n_dflts, return)        \
-    struct fstubs_name                                                          \
-    : public boost::python::overloads_common<fstubs_name>                       \
-    {                                                                           \
-        typedef BOOST_PP_CAT(fstubs_name, _NV)  non_void_return_type;           \
-        typedef BOOST_PP_CAT(fstubs_name, _NV)  void_return_type;               \
-                                                                                \
-        fstubs_name(char const* doc = 0)                                        \
-        : boost::python::                                                       \
-            overloads_common<fstubs_name>(doc) {}                               \
-    };                                                                          \
-
-#endif // defined(BOOST_MSVC)
+# endif // !defined(BOOST_NO_VOID_RETURNS)
 
 ///////////////////////////////////////////////////////////////////////////////
 //
@@ -277,14 +307,14 @@ struct overloads_common
 //
 //      Generates this code:
 //
-//      struct foo_stubs_NV  {
-//
+//      struct foo_stubsNonVoid
+//      {
 //          static const int n_funcs = 4;
 //          static const int max_args = n_funcs;
 //
 //          template <typename SigT>
-//          struct gen {
-//
+//          struct gen
+//          {
 //              typedef typename ::boost::mpl::begin<SigT>::type    rt_iter;
 //              typedef typename rt_iter::type                      RT;
 //              typedef typename rt_iter::next                      iter0;
@@ -311,26 +341,27 @@ struct overloads_common
 //          };
 //      };
 //
-//      struct foo_stubs
-//      : public boost::python::overloads_common<foo_stubs>
+//      struct foo_overloads
+//          : public boost::python::detail::overloads_common<foo_overloads>
+//      {
+//          typedef foo_overloadsNonVoid    non_void_return_type;
+//          typedef foo_overloadsNonVoid    void_return_type;
 //
-//          typedef foo_stubs_NV    non_void_return_type;
-//          typedef foo_stubs_NV    void_return_type;
-//
-//          fstubs_name(char const* doc = 0)
-//          : boost::python::
-//              overloads_common<foo_stubs>(doc) {}
+//          foo_overloads(char const* doc = 0)
+//             : boost::python::detail::overloads_common<foo_overloads>(doc) {}
 //      };
 //
-//      The typedefs non_void_return_type and void_return_type are used to handle compilers that
-//      do not support void returns. The example above typedefs non_void_return_type
-//      and void_return_type to foo_stubs_NV. On compilers that do not support
-//      void returns, there are two versions: foo_stubs_NV and foo_stubs_V.
-//      The "V" version is almost identical to the "NV" version except
+//      The typedefs non_void_return_type and void_return_type are
+//      used to handle compilers that do not support void returns. The
+//      example above typedefs non_void_return_type and
+//      void_return_type to foo_overloadsNonVoid. On compilers that do
+//      not support void returns, there are two versions:
+//      foo_overloadsNonVoid and foo_overloadsVoid.  The "Void"
+//      version is almost identical to the "NonVoid" version except
 //      for the return type (void) and the lack of the return keyword.
 //
-//      See the overloads_common above for a description of the foo_stubs'
-//      base class.
+//      See the overloads_common above for a description of the
+//      foo_overloads' base class.
 //
 ///////////////////////////////////////////////////////////////////////////////
 #define BOOST_PYTHON_FUNCTION_OVERLOADS(generator_name, fname, min_args, max_args)          \

include/boost/python/detail/dependent.hpp

@@ -1,8 +1,7 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 DEPENDENT_DWA200286_HPP
 # define DEPENDENT_DWA200286_HPP
 

include/boost/python/detail/destroy.hpp

@@ -1,20 +1,31 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 DESTROY_DWA2002221_HPP
 # define DESTROY_DWA2002221_HPP
 
-# include <boost/type_traits/composite_traits.hpp>
-# include <boost/type_traits/object_traits.hpp>
-
+# include <boost/type_traits/is_array.hpp>
+# include <boost/detail/workaround.hpp>
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+#  include <boost/type_traits/is_enum.hpp>
+# endif 
 namespace boost { namespace python { namespace detail { 
 
-template <bool array, bool trivial_destructor> struct value_destroyer;
-
+template <
+    bool array
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+  , bool enum_  // vc7 has a problem destroying enums
+# endif 
+    > struct value_destroyer;
+    
 template <>
-struct value_destroyer<false,false>
+struct value_destroyer<
+    false
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+  , false
+# endif 
+    >
 {
     template <class T>
     static void execute(T const volatile* p)
@@ -24,16 +35,25 @@ struct value_destroyer<false,false>
 };
 
 template <>
-struct value_destroyer<true,false>
+struct value_destroyer<
+    true
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+  , false
+# endif 
+    >
 {
     template <class A, class T>
     static void execute(A*, T const volatile* const first)
     {
         for (T const volatile* p = first; p != first + sizeof(A)/sizeof(T); ++p)
+        {
             value_destroyer<
                 boost::is_array<T>::value
-                ,boost::has_trivial_destructor<T>::value
-                >::execute(p);
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+              , boost::is_enum<T>::value
+# endif 
+            >::execute(p);
+        }
     }
     
     template <class T>
@@ -43,11 +63,12 @@ struct value_destroyer<true,false>
     }
 };
 
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
 template <>
 struct value_destroyer<true,true>
 {
     template <class T>
-    static void execute(T const volatile* p)
+    static void execute(T const volatile*)
     {
     }
 };
@@ -56,11 +77,11 @@ template <>
 struct value_destroyer<false,true>
 {
     template <class T>
-    static void execute(T const volatile* p)
+    static void execute(T const volatile*)
     {
     }
 };
-
+# endif 
 template <class T>
 inline void destroy_referent_impl(void* p, T& (*)())
 {
@@ -68,8 +89,10 @@ inline void destroy_referent_impl(void* p, T& (*)())
     // must come *before* T for metrowerks
     value_destroyer<
          (boost::is_array<T>::value)
-        ,(boost::has_trivial_destructor<T>::value)
-        >::execute((const volatile T*)p);
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+       , (boost::is_enum<T>::value)
+# endif 
+    >::execute((const volatile T*)p);
 }
 
 template <class T>

include/boost/python/detail/enable_if.hpp

@@ -0,0 +1,72 @@
+// 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 ENABLE_IF_DWA2004722_HPP
+# define ENABLE_IF_DWA2004722_HPP
+
+# include <boost/python/detail/sfinae.hpp>
+# include <boost/detail/workaround.hpp>
+
+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+#  include <boost/mpl/if.hpp>
+
+namespace boost { namespace python { namespace detail { 
+
+template <class T> struct always_void { typedef void type; };
+
+template <class C, class T = int>
+struct enable_if_arg
+{
+    typedef typename mpl::if_<C,T,int&>::type type;
+};
+             
+template <class C, class T = int>
+struct disable_if_arg
+{
+    typedef typename mpl::if_<C,int&,T>::type type;
+};
+             
+template <class C, class T = typename always_void<C>::type>
+struct enable_if_ret
+{
+    typedef typename mpl::if_<C,T,int[2]>::type type;
+};
+             
+template <class C, class T = typename always_void<C>::type>
+struct disable_if_ret
+{
+    typedef typename mpl::if_<C,int[2],T>::type type;
+};
+             
+}}} // namespace boost::python::detail
+
+# elif !defined(BOOST_NO_SFINAE)
+#  include <boost/utility/enable_if.hpp>
+
+namespace boost { namespace python { namespace detail { 
+
+template <class C, class T = int>
+struct enable_if_arg
+  : enable_if<C,T>
+{};
+             
+template <class C, class T = int>
+struct disable_if_arg
+  : disable_if<C,T>
+{};
+             
+template <class C, class T = void>
+struct enable_if_ret
+  : enable_if<C,T>
+{};
+             
+template <class C, class T = void>
+struct disable_if_ret
+  : disable_if<C,T>
+{};
+             
+}}} // namespace boost::python::detail
+
+# endif
+
+#endif // ENABLE_IF_DWA2004722_HPP

include/boost/python/detail/exception_handler.hpp

@@ -1,11 +1,11 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 EXCEPTION_HANDLER_DWA2002810_HPP
 # define EXCEPTION_HANDLER_DWA2002810_HPP
 
+# include <boost/python/detail/config.hpp>
 # include <boost/function/function0.hpp>
 # include <boost/function/function2.hpp>
 

include/boost/python/detail/force_instantiate.hpp

@@ -1,8 +1,7 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 FORCE_INSTANTIATE_DWA200265_HPP
 # define FORCE_INSTANTIATE_DWA200265_HPP
 
@@ -11,7 +10,7 @@ namespace boost { namespace python { namespace detail {
 // Allows us to force the argument to be instantiated without
 // incurring unused variable warnings
 
-# if !defined(BOOST_MSVC) || BOOST_MSVC == 1200 || _MSC_FULL_VER > 13102196
+# if !defined(BOOST_MSVC) || BOOST_MSVC < 1300 || _MSC_FULL_VER > 13102196
 
 template <class T>
 inline void force_instantiate(T const&) {}

include/boost/python/detail/functions.hpp

@@ -1,311 +0,0 @@
-//  (C) Copyright David Abrahams 2000. Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-//
-//  The author gratefully acknowleges the support of Dragon Systems, Inc., in
-//  producing this work.
-
-#ifndef FUNCTIONS_DWA051400_H_
-# define FUNCTIONS_DWA051400_H_
-
-# include <boost/python/detail/config.hpp>
-# include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/reference.hpp>
-# include <boost/python/detail/signatures.hpp>
-# include <boost/python/caller.hpp>
-# include <boost/call_traits.hpp>
-# include <boost/python/objects.hpp>
-# include <boost/python/detail/base_object.hpp>
-# include <typeinfo>
-# include <vector>
-
-namespace boost { namespace python { namespace detail {
-
-// forward declaration
-class extension_instance;
-
-
-// function --
-//      the common base class for all overloadable function and method objects
-//      supplied by the library.
-class BOOST_PYTHON_DECL function : public python_object
-{
- public:
-    function();
-    // function objects are reasonably rare, so we guess we can afford a virtual table.
-    // This cuts down on the number of distinct type objects which need to be defined.
-    virtual ~function() {}
-
-    PyObject* call(PyObject* args, PyObject* keywords) const;
-    static void add_to_namespace(reference<function> f, const char* name, PyObject* dict);
-    
- private:
-    virtual PyObject* do_call(PyObject* args, PyObject* keywords) const = 0;
-    virtual const char* description() const = 0;
- private:
-    struct type_object;
- private:
-    reference<function> m_overloads; // A linked list of the function overloads
-};
-
-// wrapped_function_pointer<> --
-//      A single function or member function pointer wrapped and presented to
-//      Python as a callable object.
-//
-//   Template parameters:
-//      R - the return type of the function pointer
-//      F - the complete type of the wrapped function pointer
-template <class R, class F>
-struct wrapped_function_pointer : function
-{
-    typedef F ptr_fun; // pointer-to--function or pointer-to-member-function
-    
-    wrapped_function_pointer(ptr_fun pf)
-        : m_pf(pf) {}
-
- private:
-    PyObject* do_call(PyObject* args, PyObject* keywords) const
-        {
-            // This is where the boundary between the uniform Python function
-            // interface and the statically-checked C++ function interface is
-            // crossed.
-            return caller<R>::call(m_pf, args, keywords);
-        }
-    
-    const char* description() const
-        { return typeid(F).name(); }
-    
- private:
-    const ptr_fun m_pf;
-};
-
-// raw_arguments_function
-//      A function that passes the Python argument tuple and keyword dictionary 
-//      verbatim to C++ (useful for customized argument parsing and variable
-//      argument lists)
-template <class Ret, class Args, class Keywords>
-struct raw_arguments_function : function
-{
-    typedef Ret (*ptr_fun)(Args, Keywords); 
-    
-    raw_arguments_function(ptr_fun pf)
-        : m_pf(pf) {}
-
- private:
-    PyObject* do_call(PyObject* args, PyObject* keywords) const
-    { 
-        ref dict(keywords ? 
-                 ref(keywords, ref::increment_count) :
-                 ref(PyDict_New()));
-            
-        return to_python(
-            (*m_pf)(from_python(args, boost::python::type<Args>()),
-                    from_python(dict.get(), boost::python::type<Keywords>()))); 
-    }
-    
-    const char* description() const
-        { return typeid(ptr_fun).name(); }
-    
- private:
-    const ptr_fun m_pf;
-};
-
-// virtual_function<> --
-//      A virtual function with a default implementation wrapped and presented
-//      to Python as a callable object.
-//
-//   Template parameters:
-//      T - the type of the target class
-//      R - the return type of the function pointer
-//      V - the virtual function pointer being wrapped
-//          (should be of the form R(T::*)(<args>), or R (*)(T, <args>))
-//      D - a function which takes a T&, const T&, T*, or const T* first
-//          parameter and calls T::f on it /non-virtually/, where V
-//          approximates &T::f.
-template <class T, class R, class V, class D>
-class virtual_function : public function
-{
- public:
-    virtual_function(V virtual_function_ptr, D default_implementation)
-        : m_virtual_function_ptr(virtual_function_ptr),
-          m_default_implementation(default_implementation)
-        {}
-
- private:
-    PyObject* do_call(PyObject* args, PyObject* keywords) const;
-    
-    const char* description() const
-        { return typeid(V).name(); }
-    
- private:
-    const V m_virtual_function_ptr;
-    const D m_default_implementation;
-};
-
-// A helper function for new_member_function(), below.  Implements the core
-// functionality once the return type has already been deduced. R is expected to
-// be type<X>, where X is the actual return type of pmf.
-template <class F, class R>
-function* new_wrapped_function_aux(R, F pmf)
-{
-    // We can't just use "typename R::Type" below because MSVC (incorrectly) pukes.
-    typedef typename R::type return_type;
-    return new wrapped_function_pointer<return_type, F>(pmf);
-}
-
-// Create and return a new member function object wrapping the given
-// pointer-to-member function
-template <class F>
-inline function* new_wrapped_function(F pmf)
-{
-    // Deduce the return type and pass it off to the helper function above
-    return new_wrapped_function_aux(return_value(pmf), pmf);
-}
-
-template <class R, class Args, class keywords>
-function* new_raw_arguments_function(R (*pmf)(Args, keywords))
-{
-    return new raw_arguments_function<R, Args, keywords>(pmf);
-}
-
-
-// A helper function for new_virtual_function(), below.  Implements the core
-// functionality once the return type has already been deduced. R is expected to
-// be type<X>, where X is the actual return type of V.
-template <class T, class R, class V, class D>
-inline function* new_virtual_function_aux(
-    type<T>, R, V virtual_function_ptr, D default_implementation
-    )
-{
-    // We can't just use "typename R::Type" below because MSVC (incorrectly) pukes.
-    typedef typename R::type return_type;
-    return new virtual_function<T, return_type, V, D>(
-        virtual_function_ptr, default_implementation);
-}
-
-// Create and return a new virtual_function object wrapping the given
-// virtual_function_ptr and default_implementation
-template <class T, class V, class D>
-inline function* new_virtual_function(
-    type<T>, V virtual_function_ptr, D default_implementation
-    )
-{
-    // Deduce the return type and pass it off to the helper function above
-    return new_virtual_function_aux(
-        type<T>(), return_value(virtual_function_ptr),
-        virtual_function_ptr, default_implementation);
-}
-
-// A function with a bundled "bound target" object. This is what is produced by
-// the expression a.b where a is an instance or extension_instance object and b
-// is a callable object not found in the obj namespace but on its class or
-// a base class.
-class BOOST_PYTHON_DECL bound_function : public python_object
-{
- public:
-    static bound_function* create(const ref& target, const ref& fn);
-    
-    bound_function(const ref& target, const ref& fn);
-    PyObject* call(PyObject*args, PyObject* keywords) const;
-    PyObject* getattr(const char* name) const;
-    
- private:
-    struct type_object;
-    friend struct type_object;
-    
-    ref m_target;
-    ref m_unbound_function;
-    
- private: // data members for allocation/deallocation optimization
-    bound_function* m_free_list_link;
-
-    static bound_function* free_list;
-};
-
-// Special functions designed to access data members of a wrapped C++ object.
-template <class ClassType, class MemberType>
-class getter_function : public function
-{
- public:
-    typedef MemberType ClassType::* pointer_to_member;
-    
-    getter_function(pointer_to_member pm)
-        : m_pm(pm) {}
-
- private:
-    PyObject* do_call(PyObject* args, PyObject* keywords) const;
-    
-    const char* description() const
-        { return typeid(MemberType (*)(const ClassType&)).name(); }
- private:
-    pointer_to_member m_pm;
-};
-
-template <class ClassType, class MemberType>
-class setter_function : public function
-{
- public:
-    typedef MemberType ClassType::* pointer_to_member;
-    
-    setter_function(pointer_to_member pm)
-        : m_pm(pm) {}
-
- private:
-    PyObject* do_call(PyObject* args, PyObject* keywords) const;
-    
-    const char* description() const
-        { return typeid(void (*)(const ClassType&, const MemberType&)).name(); }
- private:
-    pointer_to_member m_pm;
-};
-
-template <class ClassType, class MemberType>
-PyObject* getter_function<ClassType, MemberType>::do_call(
-    PyObject* args, PyObject* /* keywords */) const
-{
-    PyObject* self;
-    if (!PyArg_ParseTuple(args, const_cast<char*>("O"), &self))
-        return 0;
-
-    return to_python(
-        from_python(self, type<const ClassType*>())->*m_pm);
-}
-
-template <class ClassType, class MemberType>
-PyObject* setter_function<ClassType, MemberType>::do_call(
-    PyObject* args, PyObject* /* keywords */) const
-{
-    PyObject* self;
-    PyObject* value;
-    if (!PyArg_ParseTuple(args, const_cast<char*>("OO"), &self, &value))
-        return 0;
-    
-    typedef typename boost::call_traits<MemberType>::const_reference extract_type;
-    from_python(self, type<ClassType*>())->*m_pm
-        = from_python(value, type<extract_type>());
-    
-    return none();
-}
-
-template <class T, class R, class V, class D>
-PyObject* virtual_function<T,R,V,D>::do_call(PyObject* args, PyObject* keywords) const
-{
-    // If the target object is held by pointer, we must call through the virtual
-    // function pointer to the most-derived override.
-    PyObject* target = PyTuple_GetItem(args, 0);
-    if (target != 0)
-    {
-        extension_instance* self = get_extension_instance(target);
-        if (self->wrapped_objects().size() == 1
-            && !self->wrapped_objects()[0]->held_by_value())
-        {
-            return caller<R>::call(m_virtual_function_ptr, args, keywords);
-        }
-    }
-    return caller<R>::call(m_default_implementation, args, keywords);
-}
-    
-}}} // namespace boost::python::detail
-
-#endif // FUNCTIONS_DWA051400_H_

include/boost/python/detail/if_else.hpp

@@ -1,8 +1,7 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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 IF_ELSE_DWA2002322_HPP
 # define IF_ELSE_DWA2002322_HPP
 # include <boost/config.hpp>

include/boost/python/detail/indirect_traits.hpp

@@ -1,395 +1,13 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef INDIRECT_TRAITS_DWA2002131_HPP
-# define INDIRECT_TRAITS_DWA2002131_HPP
-# include <boost/type_traits/is_function.hpp>
-# include <boost/type_traits/detail/ice_and.hpp>
-# include <boost/type_traits/is_reference.hpp>
-# include <boost/type_traits/is_pointer.hpp>
-# include <boost/type_traits/is_class.hpp>
-# include <boost/type_traits/is_const.hpp>
-# include <boost/type_traits/is_volatile.hpp>
-# include <boost/type_traits/remove_cv.hpp>
-# include <boost/type_traits/remove_reference.hpp>
-# include <boost/type_traits/remove_pointer.hpp>
-# include <boost/mpl/if.hpp>
+// 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 INDIRECT_TRAITS_DWA2004915_HPP
+# define INDIRECT_TRAITS_DWA2004915_HPP
 
-namespace boost { namespace python { namespace detail { 
+# include <boost/detail/indirect_traits.hpp>
 
-#  ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <class T>
-struct is_reference_to_const
-{
-    BOOST_STATIC_CONSTANT(bool, value = false);
-};
+namespace boost { namespace python {
+namespace indirect_traits = boost::detail::indirect_traits;
+}} // namespace boost::python::detail
 
-template <class T>
-struct is_reference_to_const<T const&>
-{
-    BOOST_STATIC_CONSTANT(bool, value = true);
-};
-
-#   if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround
-template<class T>
-struct is_reference_to_const<T const volatile&>
-{
-    static const bool value = true;
-};
-#   endif 
-
-#   if 0 // Corresponding code doesn't work on MSVC yet
-template <class T>
-struct is_reference_to_function
-{
-    BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-template <class T>
-struct is_reference_to_function<T&>
-{
-    BOOST_STATIC_CONSTANT(bool, value = is_function<T>::value);
-};
-
-template <class T>
-struct is_reference_to_function<T const&>
-{
-    BOOST_STATIC_CONSTANT(bool, value = is_function<T>::value);
-};
-
-template <class T>
-struct is_reference_to_function<T volatile&>
-{
-    BOOST_STATIC_CONSTANT(bool, value = is_function<T>::value);
-};
-
-template <class T>
-struct is_reference_to_function<T const volatile&>
-{
-    BOOST_STATIC_CONSTANT(bool, value = is_function<T>::value);
-};
-#   endif
-
-template <class T>
-struct is_pointer_to_function
-{
-    BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-template <class T>
-struct is_pointer_to_function<T*>
-{
-    // There's no such thing as a pointer-to-cv-function, so we don't need specializations for those
-    BOOST_STATIC_CONSTANT(bool, value = is_function<T>::value);
-};
-
-template <class T>
-struct is_reference_to_non_const
-{
-    BOOST_STATIC_CONSTANT(
-        bool, value = (
-            ::boost::type_traits::ice_and<
-            ::boost::is_reference<T>::value
-            , ::boost::type_traits::ice_not<
-                ::boost::python::detail::is_reference_to_const<T>::value>::value
-            >::value)
-        );
-};
-
-template <class T>
-struct is_reference_to_volatile
-{
-    BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-template <class T>
-struct is_reference_to_volatile<T volatile&>
-{
-    BOOST_STATIC_CONSTANT(bool, value = true);
-};
-
-#   if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround
-template <class T>
-struct is_reference_to_volatile<T const volatile&>
-{
-    static const bool value = true;
-};
-#   endif 
-
-
-template <class T>
-struct is_reference_to_pointer
-{
-    BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-template <class T>
-struct is_reference_to_pointer<T*&>
-{
-    BOOST_STATIC_CONSTANT(bool, value = true);
-};
-
-template <class T>
-struct is_reference_to_pointer<T* const&>
-{
-    BOOST_STATIC_CONSTANT(bool, value = true);
-};
-
-template <class T>
-struct is_reference_to_pointer<T* volatile&>
-{
-    BOOST_STATIC_CONSTANT(bool, value = true);
-};
-
-template <class T>
-struct is_reference_to_pointer<T* const volatile&>
-{
-    BOOST_STATIC_CONSTANT(bool, value = true);
-};
-
-template <class T>
-struct is_reference_to_class
-{
-    BOOST_STATIC_CONSTANT(
-        bool, value
-        = (boost::type_traits::ice_and<
-           is_reference<T>::value
-           , is_class<
-                typename remove_cv<
-                    typename remove_reference<T>::type
-                >::type
-             >::value
-         >::value)
-        );
-};
-
-template <class T>
-struct is_pointer_to_class
-{
-    BOOST_STATIC_CONSTANT(
-        bool, value
-        = (boost::type_traits::ice_and<
-           is_pointer<T>::value
-           , is_class<
-                typename remove_cv<
-                    typename remove_pointer<T>::type
-                >::type
-             >::value
-         >::value)
-        );
-};
-
-#  else
-
-typedef char (&inner_yes_type)[3];
-typedef char (&inner_no_type)[2];
-typedef char (&outer_no_type)[1];
-
-template <typename V>
-struct is_const_help
-{
-    typedef typename mpl::if_c<
-        is_const<V>::value
-        , inner_yes_type
-        , inner_no_type
-        >::type type;
-};
-
-template <typename V>
-struct is_volatile_help
-{
-    typedef typename mpl::if_c<
-        is_volatile<V>::value
-        , inner_yes_type
-        , inner_no_type
-        >::type type;
-};
-
-template <typename V>
-struct is_pointer_help
-{
-    typedef typename mpl::if_c<
-        is_pointer<V>::value
-        , inner_yes_type
-        , inner_no_type
-        >::type type;
-};
-
-template <typename V>
-struct is_class_help
-{
-    typedef typename mpl::if_c<
-        is_class<V>::value
-        , inner_yes_type
-        , inner_no_type
-        >::type type;
-};
-
-#   if 0 // doesn't seem to work yet
-template <class T>
-struct is_reference_to_function
-{
-    static T t;
-    BOOST_STATIC_CONSTANT(
-        bool, value
-        = sizeof(::boost::type_traits::is_function_ptr_tester(t)) == sizeof(::boost::type_traits::yes_type));
-#   endif
-
-template <class T>
-struct is_pointer_to_function
-{
-    static T t;
-    BOOST_STATIC_CONSTANT(
-        bool, value
-        = sizeof(::boost::type_traits::is_function_ptr_tester(t)) == sizeof(::boost::type_traits::yes_type));
-};
-
-struct false_helper1
-{
-    template <class T>
-    struct apply
-    {
-        BOOST_STATIC_CONSTANT(bool, value = false);
-    };
-};
-
-template <typename V>
-typename is_const_help<V>::type reference_to_const_helper(V&);    
-outer_no_type
-reference_to_const_helper(...);
-
-template <bool ref = true>
-struct is_reference_to_const_helper1
-{
-    template <class T>
-    struct apply
-    {
-        static T t;
-        BOOST_STATIC_CONSTANT(
-            bool, value
-            = sizeof(reference_to_const_helper(t)) == sizeof(inner_yes_type));
-    };
-};
-
-template <>
-struct is_reference_to_const_helper1<false> : false_helper1
-{
-};
-
-
-template <class T>
-struct is_reference_to_const
-    : is_reference_to_const_helper1<is_reference<T>::value>::template apply<T>
-{
-};
-
-
-
-template <bool ref = true>
-struct is_reference_to_non_const_helper1
-{
-    template <class T>
-    struct apply
-    {
-        static T t;
-        BOOST_STATIC_CONSTANT(
-            bool, value
-            = sizeof(reference_to_const_helper(t)) == sizeof(inner_no_type));
-    };
-};
-
-template <>
-struct is_reference_to_non_const_helper1<false> : false_helper1
-{
-};
-
-
-template <class T>
-struct is_reference_to_non_const
-    : is_reference_to_non_const_helper1<is_reference<T>::value>::template apply<T>
-{
-};
-
-
-template <typename V>
-typename is_volatile_help<V>::type reference_to_volatile_helper(V&);    
-outer_no_type
-reference_to_volatile_helper(...);
-
-template <bool ref = true>
-struct is_reference_to_volatile_helper1
-{
-    template <class T>
-    struct apply
-    {
-        static T t;
-        BOOST_STATIC_CONSTANT(
-            bool, value
-            = sizeof(reference_to_volatile_helper(t)) == sizeof(inner_yes_type));
-    };
-};
-
-template <>
-struct is_reference_to_volatile_helper1<false> : false_helper1
-{
-};
-
-
-template <class T>
-struct is_reference_to_volatile
-    : is_reference_to_volatile_helper1<is_reference<T>::value>::template apply<T>
-{
-};
-
-
-template <typename V>
-typename is_pointer_help<V>::type reference_to_pointer_helper(V&);
-outer_no_type reference_to_pointer_helper(...);
-
-template <class T>
-struct is_reference_to_pointer
-{
-    static T t;
-    BOOST_STATIC_CONSTANT(
-        bool, value
-        = (is_reference<T>::value
-           && sizeof(reference_to_pointer_helper(t)) == sizeof(inner_yes_type))
-        );
-};
-
-template <typename V>
-typename is_class_help<V>::type reference_to_class_helper(V const volatile&);
-outer_no_type reference_to_class_helper(...);
-
-template <class T>
-struct is_reference_to_class
-{
-    static T t;
-    BOOST_STATIC_CONSTANT(
-        bool, value
-        = (is_reference<T>::value
-           && sizeof(reference_to_class_helper(t)) == sizeof(inner_yes_type))
-        );
-};
-
-template <typename V>
-typename is_class_help<V>::type pointer_to_class_helper(V const volatile*);
-outer_no_type pointer_to_class_helper(...);
-
-template <class T>
-struct is_pointer_to_class
-{
-    static T t;
-    BOOST_STATIC_CONSTANT(
-        bool, value
-        = (is_pointer<T>::value
-           && sizeof(pointer_to_class_helper(t)) == sizeof(inner_yes_type))
-        );
-};
-#  endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION 
-
-}}} // namespace boost::python::detail
-
-#endif // INDIRECT_TRAITS_DWA2002131_HPP
+#endif // INDIRECT_TRAITS_DWA2004915_HPP

include/boost/python/detail/init_function.hpp

@@ -1,562 +0,0 @@
-//  (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-//
-//  The author gratefully acknowleges the support of Dragon Systems, Inc., in
-//  producing this work.
-//
-//  This file was generated for %d-argument constructors by gen_init_function.python
-
-#ifndef INIT_FUNCTION_DWA052000_H_
-# define INIT_FUNCTION_DWA052000_H_
-
-# include <boost/python/detail/config.hpp>
-# include <boost/python/detail/functions.hpp>
-# include <boost/python/detail/signatures.hpp>
-# include <typeinfo>
-
-namespace boost { namespace python {
-
-namespace detail {
-
-  // parameter_traits - so far, this is a way to pass a const T& when we can be
-  // sure T is not a reference type, and a raw T otherwise. This should be
-  // rolled into boost::call_traits. Ordinarily, parameter_traits would be
-  // written:
-  //
-  //    template <class T> struct parameter_traits
-  //    {
-  //        typedef const T& const_reference;
-  //    };
-  //
-  //    template <class T> struct parameter_traits<T&>
-  //    {
-  //        typedef T& const_reference;
-  //    };
-  //
-  //    template <> struct parameter_traits<void>
-  //    {
-  //        typedef void const_reference;
-  //    };
-  //
-  // ...but since we can't partially specialize on reference types, we need this
-  // long-winded but equivalent incantation.
-
-  // const_ref_selector -- an implementation detail of parameter_traits (below). This uses
-  // the usual "poor man's partial specialization" hack for MSVC. 
-  template <bool is_ref>
-  struct const_ref_selector
-  {
-      template <class T>
-      struct const_ref
-      {
-          typedef const T& type;
-      };
-  };
-
-  template <>
-  struct const_ref_selector<true>
-  {
-      template <class T>
-      struct const_ref
-      {
-          typedef T type;
-      };
-  };
-
-# ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable: 4181)
-# endif // BOOST_MSVC
-  template <class T>
-  struct parameter_traits
-  {
-   private:
-      enum { is_ref = boost::is_reference<T>::value };
-      typedef const_ref_selector<is_ref> selector;
-   public:
-      typedef typename selector::template const_ref<T>::type const_reference;
-  };
-# ifdef BOOST_MSVC
-#  pragma warning(pop)
-# endif // BOOST_MSVC
-
-  // Full spcialization for void
-  template <>
-  struct parameter_traits<void>
-  {
-      typedef void const_reference;
-  };
-
-  struct reference_parameter_base {};
-
-  template <class T>
-  class reference_parameter
-      : public reference_parameter_base
-  {
-   public:
-      typedef typename parameter_traits<T>::const_reference const_reference;
-      reference_parameter(const_reference value)
-          : value(value) {}
-      operator const_reference() { return value; }
-   private:
-      const_reference value;
-  };
-
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-  template <class T>
-  struct unwrap_parameter
-  {
-      typedef typename boost::add_reference<T>::type type;
-  };
-
-  template <class T>
-  struct unwrap_parameter<reference_parameter<T> >
-  {
-      typedef typename reference_parameter<T>::const_reference type;
-  };
-# else
-  template <bool is_wrapped>
-  struct unwrap_parameter_helper
-  {
-      template <class T>
-      struct apply
-      {
-          typedef typename T::const_reference type;
-      };
-  };
-
-  template <>
-  struct unwrap_parameter_helper<false>
-  {
-      template <class T>
-      struct apply
-      {
-          typedef typename add_reference<T>::type type;
-      };
-  };
-
-  template <class T>
-  struct unwrap_parameter
-  {
-      BOOST_STATIC_CONSTANT(
-          bool, is_wrapped = (is_base_and_derived<T,reference_parameter_base>::value));
-      
-      typedef typename unwrap_parameter_helper<
-          is_wrapped
-      >::template apply<T>::type type;
-  };
-# endif 
-  
-class extension_instance;
-class instance_holder_base;
-
-class init;
-template <class T> struct init0;
-template <class T, class A1> struct init1;
-template <class T, class A1, class A2> struct init2;
-template <class T, class A1, class A2, class A3> struct init3;
-template <class T, class A1, class A2, class A3, class A4> struct init4;
-template <class T, class A1, class A2, class A3, class A4, class A5> struct init5;
-template <class T, class A1, class A2, class A3, class A4, class A5, class A6> struct init6;
-template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct init7;
-template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct init8;
-template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct init9;
-template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10> struct init10;
-
-template <class T>
-struct init_function
-{
-# ifdef BOOST_MSVC6_OR_EARLIER
-#  define typename
-# endif 
-    static init* create(signature0) {
-        return new init0<T>;
-    }
-
-    template <class A1>
-    static init* create(signature1<A1>) {
-        return new init1<T,
-                       typename detail::parameter_traits<A1>::const_reference>;
-    }
-
-    template <class A1, class A2>
-    static init* create(signature2<A1, A2>) {
-        return new init2<T,
-                       typename detail::parameter_traits<A1>::const_reference,
-                       typename detail::parameter_traits<A2>::const_reference>;
-    }
-
-    template <class A1, class A2, class A3>
-    static init* create(signature3<A1, A2, A3>) {
-        return new init3<T,
-                       typename detail::parameter_traits<A1>::const_reference,
-                       typename detail::parameter_traits<A2>::const_reference,
-                       typename detail::parameter_traits<A3>::const_reference>;
-    }
-
-    template <class A1, class A2, class A3, class A4>
-    static init* create(signature4<A1, A2, A3, A4>) {
-        return new init4<T,
-                       typename detail::parameter_traits<A1>::const_reference,
-                       typename detail::parameter_traits<A2>::const_reference,
-                       typename detail::parameter_traits<A3>::const_reference,
-                       typename detail::parameter_traits<A4>::const_reference>;
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5>
-    static init* create(signature5<A1, A2, A3, A4, A5>) {
-        return new init5<T,
-                       typename detail::parameter_traits<A1>::const_reference,
-                       typename detail::parameter_traits<A2>::const_reference,
-                       typename detail::parameter_traits<A3>::const_reference,
-                       typename detail::parameter_traits<A4>::const_reference,
-                       typename detail::parameter_traits<A5>::const_reference>;
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6>
-    static init* create(signature6<A1, A2, A3, A4, A5, A6>) {
-        return new init6<T,
-                       typename detail::parameter_traits<A1>::const_reference,
-                       typename detail::parameter_traits<A2>::const_reference,
-                       typename detail::parameter_traits<A3>::const_reference,
-                       typename detail::parameter_traits<A4>::const_reference,
-                       typename detail::parameter_traits<A5>::const_reference,
-                       typename detail::parameter_traits<A6>::const_reference>;
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    static init* create(signature7<A1, A2, A3, A4, A5, A6, A7>) {
-        return new init7<T,
-                       typename detail::parameter_traits<A1>::const_reference,
-                       typename detail::parameter_traits<A2>::const_reference,
-                       typename detail::parameter_traits<A3>::const_reference,
-                       typename detail::parameter_traits<A4>::const_reference,
-                       typename detail::parameter_traits<A5>::const_reference,
-                       typename detail::parameter_traits<A6>::const_reference,
-                       typename detail::parameter_traits<A7>::const_reference>;
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    static init* create(signature8<A1, A2, A3, A4, A5, A6, A7, A8>) {
-        return new init8<T,
-                       typename detail::parameter_traits<A1>::const_reference,
-                       typename detail::parameter_traits<A2>::const_reference,
-                       typename detail::parameter_traits<A3>::const_reference,
-                       typename detail::parameter_traits<A4>::const_reference,
-                       typename detail::parameter_traits<A5>::const_reference,
-                       typename detail::parameter_traits<A6>::const_reference,
-                       typename detail::parameter_traits<A7>::const_reference,
-                       typename detail::parameter_traits<A8>::const_reference>;
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    static init* create(signature9<A1, A2, A3, A4, A5, A6, A7, A8, A9>) {
-        return new init9<T,
-                       typename detail::parameter_traits<A1>::const_reference,
-                       typename detail::parameter_traits<A2>::const_reference,
-                       typename detail::parameter_traits<A3>::const_reference,
-                       typename detail::parameter_traits<A4>::const_reference,
-                       typename detail::parameter_traits<A5>::const_reference,
-                       typename detail::parameter_traits<A6>::const_reference,
-                       typename detail::parameter_traits<A7>::const_reference,
-                       typename detail::parameter_traits<A8>::const_reference,
-                       typename detail::parameter_traits<A9>::const_reference>;
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    static init* create(signature10<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>) {
-        return new init10<T,
-                       typename detail::parameter_traits<A1>::const_reference,
-                       typename detail::parameter_traits<A2>::const_reference,
-                       typename detail::parameter_traits<A3>::const_reference,
-                       typename detail::parameter_traits<A4>::const_reference,
-                       typename detail::parameter_traits<A5>::const_reference,
-                       typename detail::parameter_traits<A6>::const_reference,
-                       typename detail::parameter_traits<A7>::const_reference,
-                       typename detail::parameter_traits<A8>::const_reference,
-                       typename detail::parameter_traits<A9>::const_reference,
-                       typename detail::parameter_traits<A10>::const_reference>;
-    }
-#ifdef BOOST_MSVC6_OR_EARLIER
-# undef typename
-#endif 
-};
-
-class BOOST_PYTHON_DECL init : public function
-{
-private: // override function hook
-    PyObject* do_call(PyObject* args, PyObject* keywords) const;
-private:
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* tail_args, PyObject* keywords) const = 0;
-};
-
-
-template <class T>
-struct init0 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        if (!PyArg_ParseTuple(args, const_cast<char*>("")))
-            throw_argument_error();
-        return new T(self
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&)).name(); }
-};
-
-template <class T, class A1>
-struct init1 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        PyObject* a1;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("O"), &a1))
-            throw_argument_error();
-        return new T(self,
-            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>()))
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&, A1)).name(); }
-};
-
-template <class T, class A1, class A2>
-struct init2 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        PyObject* a1;
-        PyObject* a2;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OO"), &a1, &a2))
-            throw_argument_error();
-        return new T(self,
-            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
-            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>()))
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&, A1, A2)).name(); }
-};
-
-template <class T, class A1, class A2, class A3>
-struct init3 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOO"), &a1, &a2, &a3))
-            throw_argument_error();
-        return new T(self,
-            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
-            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
-            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>()))
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&, A1, A2, A3)).name(); }
-};
-
-template <class T, class A1, class A2, class A3, class A4>
-struct init4 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOO"), &a1, &a2, &a3, &a4))
-            throw_argument_error();
-        return new T(self,
-            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
-            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
-            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
-            boost::python::detail::reference_parameter<A4>(from_python(a4, type<A4>()))
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&, A1, A2, A3, A4)).name(); }
-};
-
-template <class T, class A1, class A2, class A3, class A4, class A5>
-struct init5 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOO"), &a1, &a2, &a3, &a4, &a5))
-            throw_argument_error();
-        return new T(self,
-            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
-            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
-            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
-            boost::python::detail::reference_parameter<A4>(from_python(a4, type<A4>())),
-            boost::python::detail::reference_parameter<A5>(from_python(a5, type<A5>()))
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&, A1, A2, A3, A4, A5)).name(); }
-};
-
-template <class T, class A1, class A2, class A3, class A4, class A5, class A6>
-struct init6 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        PyObject* a6;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6))
-            throw_argument_error();
-        return new T(self,
-            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
-            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
-            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
-            boost::python::detail::reference_parameter<A4>(from_python(a4, type<A4>())),
-            boost::python::detail::reference_parameter<A5>(from_python(a5, type<A5>())),
-            boost::python::detail::reference_parameter<A6>(from_python(a6, type<A6>()))
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&, A1, A2, A3, A4, A5, A6)).name(); }
-};
-
-template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-struct init7 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        PyObject* a6;
-        PyObject* a7;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7))
-            throw_argument_error();
-        return new T(self,
-            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
-            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
-            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
-            boost::python::detail::reference_parameter<A4>(from_python(a4, type<A4>())),
-            boost::python::detail::reference_parameter<A5>(from_python(a5, type<A5>())),
-            boost::python::detail::reference_parameter<A6>(from_python(a6, type<A6>())),
-            boost::python::detail::reference_parameter<A7>(from_python(a7, type<A7>()))
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&, A1, A2, A3, A4, A5, A6, A7)).name(); }
-};
-
-template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-struct init8 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        PyObject* a6;
-        PyObject* a7;
-        PyObject* a8;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8))
-            throw_argument_error();
-        return new T(self,
-            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
-            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
-            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
-            boost::python::detail::reference_parameter<A4>(from_python(a4, type<A4>())),
-            boost::python::detail::reference_parameter<A5>(from_python(a5, type<A5>())),
-            boost::python::detail::reference_parameter<A6>(from_python(a6, type<A6>())),
-            boost::python::detail::reference_parameter<A7>(from_python(a7, type<A7>())),
-            boost::python::detail::reference_parameter<A8>(from_python(a8, type<A8>()))
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&, A1, A2, A3, A4, A5, A6, A7, A8)).name(); }
-};
-
-template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-struct init9 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        PyObject* a6;
-        PyObject* a7;
-        PyObject* a8;
-        PyObject* a9;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9))
-            throw_argument_error();
-        return new T(self,
-            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
-            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
-            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
-            boost::python::detail::reference_parameter<A4>(from_python(a4, type<A4>())),
-            boost::python::detail::reference_parameter<A5>(from_python(a5, type<A5>())),
-            boost::python::detail::reference_parameter<A6>(from_python(a6, type<A6>())),
-            boost::python::detail::reference_parameter<A7>(from_python(a7, type<A7>())),
-            boost::python::detail::reference_parameter<A8>(from_python(a8, type<A8>())),
-            boost::python::detail::reference_parameter<A9>(from_python(a9, type<A9>()))
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&, A1, A2, A3, A4, A5, A6, A7, A8, A9)).name(); }
-};
-
-template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-struct init10 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        PyObject* a6;
-        PyObject* a7;
-        PyObject* a8;
-        PyObject* a9;
-        PyObject* a10;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10))
-            throw_argument_error();
-        return new T(self,
-            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
-            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
-            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
-            boost::python::detail::reference_parameter<A4>(from_python(a4, type<A4>())),
-            boost::python::detail::reference_parameter<A5>(from_python(a5, type<A5>())),
-            boost::python::detail::reference_parameter<A6>(from_python(a6, type<A6>())),
-            boost::python::detail::reference_parameter<A7>(from_python(a7, type<A7>())),
-            boost::python::detail::reference_parameter<A8>(from_python(a8, type<A8>())),
-            boost::python::detail::reference_parameter<A9>(from_python(a9, type<A9>())),
-            boost::python::detail::reference_parameter<A10>(from_python(a10, type<A10>()))
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)).name(); }
-};
-
-}}} // namespace boost::python::detail
-
-#endif // INIT_FUNCTION_DWA052000_H_

include/boost/python/detail/invoke.hpp

@@ -0,0 +1,100 @@
+#if !defined(BOOST_PP_IS_ITERATING)
+
+// 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 INVOKE_DWA20021122_HPP
+#  define INVOKE_DWA20021122_HPP
+
+#  include <boost/python/detail/prefix.hpp>
+#  include <boost/python/detail/preprocessor.hpp>
+#  include <boost/python/detail/none.hpp>
+
+#  include <boost/type_traits/is_member_function_pointer.hpp>
+
+#  include <boost/preprocessor/iterate.hpp>
+#  include <boost/preprocessor/facilities/intercept.hpp>
+#  include <boost/preprocessor/repetition/enum_trailing_params.hpp>
+#  include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
+#  include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#  include <boost/python/to_python_value.hpp>
+
+// This file declares a series of overloaded invoke(...)  functions,
+// used to invoke wrapped C++ function (object)s from Python. Each one
+// accepts:
+//
+//   - a tag which identifies the invocation syntax (e.g. member
+//   functions must be invoked with a different syntax from regular
+//   functions)
+//
+//   - a pointer to a result converter type, used solely as a way of
+//   transmitting the type of the result converter to the function (or
+//   an int, if the return type is void).
+//
+//   - the "function", which may be a function object, a function or
+//   member function pointer, or a defaulted_virtual_fn.
+//
+//   - The arg_from_python converters for each of the arguments to be
+//   passed to the function being invoked.
+
+namespace boost { namespace python { namespace detail { 
+
+// This "result converter" is really just used as a dispatch tag to
+// invoke(...), selecting the appropriate implementation
+typedef int void_result_to_python;
+
+template <bool void_return, bool member>
+struct invoke_tag_ {};
+
+// A metafunction returning the appropriate tag type for invoking an
+// object of type F with return type R.
+template <class R, class F>
+struct invoke_tag
+  : invoke_tag_<
+        is_same<R,void>::value
+      , is_member_function_pointer<F>::value
+    >
+{
+};
+
+#  define BOOST_PP_ITERATION_PARAMS_1                                            \
+        (3, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/detail/invoke.hpp>))
+#  include BOOST_PP_ITERATE()
+
+}}} // namespace boost::python::detail
+
+# endif // INVOKE_DWA20021122_HPP
+#else 
+
+# define N BOOST_PP_ITERATION()
+
+template <class RC, class F BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, class AC)>
+inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(1, N, AC, & ac) )
+{
+    return rc(f( BOOST_PP_ENUM_BINARY_PARAMS_Z(1, N, ac, () BOOST_PP_INTERCEPT) ));
+}
+                 
+template <class RC, class F BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, class AC)>
+inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(1, N, AC, & ac) )
+{
+    f( BOOST_PP_ENUM_BINARY_PARAMS_Z(1, N, ac, () BOOST_PP_INTERCEPT) );
+    return none();
+}
+
+template <class RC, class F, class TC BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, class AC)>
+inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(1, N, AC, & ac) )
+{
+    return rc( (tc().*f)(BOOST_PP_ENUM_BINARY_PARAMS_Z(1, N, ac, () BOOST_PP_INTERCEPT)) );
+}
+                 
+template <class RC, class F, class TC BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, class AC)>
+inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(1, N, AC, & ac) )
+{
+    (tc().*f)(BOOST_PP_ENUM_BINARY_PARAMS_Z(1, N, ac, () BOOST_PP_INTERCEPT));
+    return none();
+}
+
+# undef N
+
+#endif // BOOST_PP_IS_ITERATING 

include/boost/python/detail/is_auto_ptr.hpp

@@ -0,0 +1,30 @@
+// Copyright David Abrahams 2003.
+// 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 IS_AUTO_PTR_DWA2003224_HPP
+# define IS_AUTO_PTR_DWA2003224_HPP
+
+# ifndef BOOST_NO_AUTO_PTR
+#  include <boost/python/detail/is_xxx.hpp>
+#  include <memory>
+# endif
+
+namespace boost { namespace python { namespace detail { 
+
+# if !defined(BOOST_NO_AUTO_PTR)
+
+BOOST_PYTHON_IS_XXX_DEF(auto_ptr, std::auto_ptr, 1)
+
+# else
+
+template <class T>
+struct is_auto_ptr : mpl::false_
+{
+};
+
+# endif
+    
+}}} // namespace boost::python::detail
+
+#endif // IS_AUTO_PTR_DWA2003224_HPP

include/boost/python/detail/is_shared_ptr.hpp

@@ -0,0 +1,17 @@
+// Copyright David Abrahams 2003.
+// 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 IS_SHARED_PTR_DWA2003224_HPP
+# define IS_SHARED_PTR_DWA2003224_HPP
+
+# include <boost/python/detail/is_xxx.hpp>
+# include <boost/shared_ptr.hpp>
+
+namespace boost { namespace python { namespace detail { 
+
+BOOST_PYTHON_IS_XXX_DEF(shared_ptr, shared_ptr, 1)
+    
+}}} // namespace boost::python::detail
+
+#endif // IS_SHARED_PTR_DWA2003224_HPP