1 // Copyright David Abrahams 2002.

     2 // Distributed under the Boost Software License, Version 1.0. (See

     3 // accompanying file LICENSE_1_0.txt or copy at

     4 // http://www.boost.org/LICENSE_1_0.txt)

     5 #ifndef OBJECT_OPERATORS_DWA2002617_HPP

     6 # define OBJECT_OPERATORS_DWA2002617_HPP

     7 

     8 # include <boost/python/detail/prefix.hpp>

     9 

    10 # include <boost/python/object_core.hpp>

    11 # include <boost/python/call.hpp>

    12 # include <boost/iterator/detail/enable_if.hpp>

    13 # include <boost/mpl/bool.hpp>

    14 

    15 # include <boost/iterator/detail/config_def.hpp>

    16 

    17 namespace boost { namespace python { namespace api {

    18 

    19 template <class X>

    20 char is_object_operators_helper(object_operators<X> const*);

    21     

    22 typedef char (&no_type)[2];

    23 no_type is_object_operators_helper(...);

    24 

    25 template <class X> X* make_ptr();

    26 

    27 template <class L, class R = L>

    28 struct is_object_operators

    29 {

    30     enum {

    31         value 

    32         = (sizeof(api::is_object_operators_helper(api::make_ptr<L>()))

    33            + sizeof(api::is_object_operators_helper(api::make_ptr<R>()))

    34            < 4

    35         )

    36     };

    37     typedef mpl::bool_<value> type;

    38 };

    39 

    40 # if !defined(BOOST_NO_SFINAE) && !defined(BOOST_NO_IS_CONVERTIBLE)

    41 template <class L, class R, class T>

    42 struct enable_binary

    43   : boost::iterators::enable_if<is_object_operators<L,R>, T>

    44 {};

    45 #  define BOOST_PYTHON_BINARY_RETURN(T) typename enable_binary<L,R,T>::type

    46 # else

    47 #  define BOOST_PYTHON_BINARY_RETURN(T) T

    48 # endif

    49 

    50 template <class U>

    51 object object_operators<U>::operator()() const

    52 {

    53     object_cref2 f = *static_cast<U const*>(this);

    54     return call<object>(f.ptr());

    55 }

    56 

    57 

    58 template <class U>

    59 inline

    60 object_operators<U>::operator bool_type() const

    61 {

    62     object_cref2 x = *static_cast<U const*>(this);

    63     return PyObject_IsTrue(x.ptr()) ? &object::ptr : 0;

    64 }

    65 

    66 template <class U>

    67 inline bool

    68 object_operators<U>::operator!() const

    69 {

    70     object_cref2 x = *static_cast<U const*>(this);

    71     return !PyObject_IsTrue(x.ptr());

    72 }

    73 

    74 # define BOOST_PYTHON_COMPARE_OP(op, opid)                              \

    75 template <class L, class R>                                             \

    76 BOOST_PYTHON_BINARY_RETURN(object) operator op(L const& l, R const& r)    \

    77 {                                                                       \

    78     return PyObject_RichCompare(                                    \

    79         object(l).ptr(), object(r).ptr(), opid);                        \

    80 }

    81 # undef BOOST_PYTHON_COMPARE_OP

    82     

    83 # define BOOST_PYTHON_BINARY_OPERATOR(op)                               \

    84 BOOST_PYTHON_DECL object operator op(object const& l, object const& r); \

    85 template <class L, class R>                                             \

    86 BOOST_PYTHON_BINARY_RETURN(object) operator op(L const& l, R const& r)  \

    87 {                                                                       \

    88     return object(l) op object(r);                                      \

    89 }

    90 BOOST_PYTHON_BINARY_OPERATOR(>)

    91 BOOST_PYTHON_BINARY_OPERATOR(>=)

    92 BOOST_PYTHON_BINARY_OPERATOR(<)

    93 BOOST_PYTHON_BINARY_OPERATOR(<=)

    94 BOOST_PYTHON_BINARY_OPERATOR(==)

    95 BOOST_PYTHON_BINARY_OPERATOR(!=)

    96 BOOST_PYTHON_BINARY_OPERATOR(+)

    97 BOOST_PYTHON_BINARY_OPERATOR(-)

    98 BOOST_PYTHON_BINARY_OPERATOR(*)

    99 BOOST_PYTHON_BINARY_OPERATOR(/)

   100 BOOST_PYTHON_BINARY_OPERATOR(%)

   101 BOOST_PYTHON_BINARY_OPERATOR(<<)

   102 BOOST_PYTHON_BINARY_OPERATOR(>>)

   103 BOOST_PYTHON_BINARY_OPERATOR(&)

   104 BOOST_PYTHON_BINARY_OPERATOR(^)

   105 BOOST_PYTHON_BINARY_OPERATOR(|)

   106 # undef BOOST_PYTHON_BINARY_OPERATOR

   107 

   108         

   109 # define BOOST_PYTHON_INPLACE_OPERATOR(op)                              \

   110 BOOST_PYTHON_DECL object& operator op(object& l, object const& r);      \

   111 template <class R>                                                      \

   112 object& operator op(object& l, R const& r)                              \

   113 {                                                                       \

   114     return l op object(r);                                              \

   115 }

   116 BOOST_PYTHON_INPLACE_OPERATOR(+=)

   117 BOOST_PYTHON_INPLACE_OPERATOR(-=)

   118 BOOST_PYTHON_INPLACE_OPERATOR(*=)

   119 BOOST_PYTHON_INPLACE_OPERATOR(/=)

   120 BOOST_PYTHON_INPLACE_OPERATOR(%=)

   121 BOOST_PYTHON_INPLACE_OPERATOR(<<=)

   122 BOOST_PYTHON_INPLACE_OPERATOR(>>=)

   123 BOOST_PYTHON_INPLACE_OPERATOR(&=)

   124 BOOST_PYTHON_INPLACE_OPERATOR(^=)

   125 BOOST_PYTHON_INPLACE_OPERATOR(|=)

   126 # undef BOOST_PYTHON_INPLACE_OPERATOR

   127 

   128 }}} // namespace boost::python

   129 

   130 #include <boost/iterator/detail/config_undef.hpp>

   131 

   132 #endif // OBJECT_OPERATORS_DWA2002617_HPP