object_core.hpp - use detail/is_xxx to generate template identifiers

dabrahams · dabrahams · commit d88e6bf6886f · 2003-07-30T23:48:06.000Z
object_operators.hpp - use SFINAE to prevent ADL from finding
        generalized operators inappropriately


[SVN r19377]
diff --git a/include/boost/python/object_core.hpp b/include/boost/python/object_core.hpp
@@ -25,6 +25,7 @@
 
 # include <boost/preprocessor/iterate.hpp>
 # include <boost/preprocessor/debug/line.hpp>
+# include <boost/python/detail/is_xxx.hpp>
 
 namespace boost { namespace python { 
 
@@ -60,31 +61,7 @@ namespace api
   //
   // is_proxy -- proxy type detection
   //
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-  template <class T>
-  struct is_proxy
-  {
-      BOOST_STATIC_CONSTANT(bool, value = false);
-  };
-  template <class T>
-  struct is_proxy<proxy<T> >
-  {
-      BOOST_STATIC_CONSTANT(bool, value = true);
-  };
-# else
-  typedef char yes_proxy;
-  typedef char (&no_proxy)[2];
-  template <class T>
-  yes_proxy is_proxy_helper(boost::type<proxy<T> >*);
-  no_proxy is_proxy_helper(...);
-  template <class T>
-  struct is_proxy
-  {
-      BOOST_STATIC_CONSTANT(
-          bool, value = (sizeof(is_proxy_helper((boost::type<T>*)0))
-                         == sizeof(yes_proxy)));
-  };
-# endif 
+  BOOST_PYTHON_IS_XXX_DEF(proxy, boost::python::api::proxy, 1)
 
   template <class T> struct object_initializer;
   
diff --git a/include/boost/python/object_operators.hpp b/include/boost/python/object_operators.hpp
@@ -10,9 +10,45 @@
 
 # include <boost/python/object_core.hpp>
 # include <boost/python/call.hpp>
+# include <boost/iterator/detail/enable_if.hpp>
+# include <boost/mpl/bool.hpp>
+
+# include <boost/iterator/detail/config_def.hpp>
 
 namespace boost { namespace python { namespace api {
 
+# if !defined(BOOST_NO_SFINAE) && !defined(BOOST_NO_IS_CONVERTIBLE)
+
+template <class X> char
+is_object_operators_helper(object_operators<X> const&);
+    
+typedef char (&no_type)[2];
+no_type is_object_operators_helper(...);
+
+template <class X> X& make();
+
+template <class L, class R>
+struct is_object_operators
+{
+    enum {
+        value 
+        = (sizeof(api::is_object_operators_helper(api::make<L>()))
+           + sizeof(api::is_object_operators_helper(api::make<R>()))
+           < 4
+        )
+    };
+    typedef mpl::bool_<value> type;
+};
+
+template <class L, class R, class T>
+struct enable_binary
+  : boost::iterators::enable_if<is_object_operators<L,R>, T>
+{};
+#  define BOOST_PYTHON_BINARY_RETURN(T) typename enable_binary<L,R,T>::type
+# else
+#  define BOOST_PYTHON_BINARY_RETURN(T) T
+# endif
+
 template <class U>
 object object_operators<U>::operator()() const
 {
@@ -37,12 +73,12 @@ object_operators<U>::operator!() const
     return !PyObject_IsTrue(x.ptr());
 }
 
-# define BOOST_PYTHON_COMPARE_OP(op, opid)                      \
-template <class L, class R>                                     \
-bool operator op(L const& l, R const& r)                        \
-{                                                               \
-    return PyObject_RichCompareBool(                            \
-        object(l).ptr(), object(r).ptr(), opid);                \
+# define BOOST_PYTHON_COMPARE_OP(op, opid)                              \
+template <class L, class R>                                             \
+BOOST_PYTHON_BINARY_RETURN(bool) operator op(L const& l, R const& r)    \
+{                                                                       \
+    return PyObject_RichCompareBool(                                    \
+        object(l).ptr(), object(r).ptr(), opid);                        \
 }
 BOOST_PYTHON_COMPARE_OP(>, Py_GT)
 BOOST_PYTHON_COMPARE_OP(>=, Py_GE)
@@ -55,7 +91,7 @@ BOOST_PYTHON_COMPARE_OP(!=, Py_NE)
 # define BOOST_PYTHON_BINARY_OPERATOR(op)                               \
 BOOST_PYTHON_DECL object operator op(object const& l, object const& r); \
 template <class L, class R>                                             \
-object operator op(L const& l, R const& r)                              \
+BOOST_PYTHON_BINARY_RETURN(object) operator op(L const& l, R const& r)  \
 {                                                                       \
     return object(l) op object(r);                                      \
 }
@@ -93,4 +129,6 @@ BOOST_PYTHON_INPLACE_OPERATOR(|=)
 
 }}} // namespace boost::python
 
+#include <boost/iterator/detail/config_undef.hpp>
+
 #endif // OBJECT_OPERATORS_DWA2002617_HPP
