boost/python/operators.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 OPERATORS_DWA2002530_HPP # define OPERATORS_DWA2002530_HPP # include <boost/python/detail/prefix.hpp> # include <boost/python/def_visitor.hpp> # include <boost/python/converter/arg_to_python.hpp> # include <boost/python/detail/operator_id.hpp> # include <boost/python/detail/not_specified.hpp> # include <boost/python/back_reference.hpp> # include <boost/mpl/if.hpp> # include <boost/mpl/eval_if.hpp> # include <boost/python/self.hpp> # include <boost/python/other.hpp> # include <boost/lexical_cast.hpp> # include <boost/python/refcount.hpp> # include <boost/python/detail/unwrap_wrapper.hpp> # include <string> # include <complex> namespace boost { namespace python { namespace detail { // This is essentially the old v1 to_python(). It will be eliminated // once the public interface for to_python is settled on. template <class T> PyObject* convert_result(T const& x) { return converter::arg_to_python<T>(x).release(); } // Operator implementation template declarations. The nested apply // declaration here keeps MSVC6 happy. template <operator_id> struct operator_l { template <class L, class R> struct apply; }; template <operator_id> struct operator_r { template <class L, class R> struct apply; }; template <operator_id> struct operator_1 { template <class T> struct apply; }; // MSVC6 doesn't want us to do this sort of inheritance on a nested // class template, so we use this layer of indirection to avoid // ::template<...> on the nested apply functions below template <operator_id id, class L, class R> struct operator_l_inner : operator_l<id>::template apply<L,R> {}; template <operator_id id, class L, class R> struct operator_r_inner : operator_r<id>::template apply<L,R> {}; template <operator_id id, class T> struct operator_1_inner : operator_1<id>::template apply<T> {}; // Define three different binary_op templates which take care of // these cases: // self op self // self op R // L op self // // The inner apply metafunction is used to adjust the operator to // the class type being defined. Inheritance of the outer class is // simply used to provide convenient access to the operation's // name(). // self op self template <operator_id id> struct binary_op : operator_l<id> { template <class T> struct apply : operator_l_inner<id,T,T> { }; }; // self op R template <operator_id id, class R> struct binary_op_l : operator_l<id> { template <class T> struct apply : operator_l_inner<id,T,R> { }; }; // L op self template <operator_id id, class L> struct binary_op_r : operator_r<id> { template <class T> struct apply : operator_r_inner<id,L,T> { }; }; template <operator_id id> struct unary_op : operator_1<id> { template <class T> struct apply : operator_1_inner<id,T> { }; }; // This type is what actually gets returned from operators used on // self_t template <operator_id id, class L = not_specified, class R = not_specified> struct operator_ : def_visitor<operator_<id,L,R> > { private: template <class ClassT> void visit(ClassT& cl) const { typedef typename mpl::eval_if< is_same<L,self_t> , mpl::if_< is_same<R,self_t> , binary_op<id> , binary_op_l< id , BOOST_DEDUCED_TYPENAME unwrap_other<R>::type > > , mpl::if_< is_same<L,not_specified> , unary_op<id> , binary_op_r< id , BOOST_DEDUCED_TYPENAME unwrap_other<L>::type > > >::type generator; cl.def( generator::name() , &generator::template apply< BOOST_DEDUCED_TYPENAME ClassT::wrapped_type >::execute ); } friend class python::def_visitor_access; }; } # define BOOST_PYTHON_BINARY_OPERATION(id, rid, expr) \ namespace detail \ { \ template <> \ struct operator_l<op_##id> \ { \ template <class L, class R> \ struct apply \ { \ typedef typename unwrap_wrapper_<L>::type lhs; \ typedef typename unwrap_wrapper_<R>::type rhs; \ static PyObject* execute(lhs& l, rhs const& r) \ { \ return detail::convert_result(expr); \ } \ }; \ static char const* name() { return "__" #id "__"; } \ }; \ \ template <> \ struct operator_r<op_##id> \ { \ template <class L, class R> \ struct apply \ { \ typedef typename unwrap_wrapper_<L>::type lhs; \ typedef typename unwrap_wrapper_<R>::type rhs; \ static PyObject* execute(rhs& r, lhs const& l) \ { \ return detail::convert_result(expr); \ } \ }; \ static char const* name() { return "__" #rid "__"; } \ }; \ } # define BOOST_PYTHON_BINARY_OPERATOR(id, rid, op) \ BOOST_PYTHON_BINARY_OPERATION(id, rid, l op r) \ namespace self_ns \ { \ template <class L, class R> \ inline detail::operator_<detail::op_##id,L,R> \ operator op(L const&, R const&) \ { \ return detail::operator_<detail::op_##id,L,R>(); \ } \ } BOOST_PYTHON_BINARY_OPERATOR(add, radd, +) BOOST_PYTHON_BINARY_OPERATOR(sub, rsub, -) BOOST_PYTHON_BINARY_OPERATOR(mul, rmul, *) #if PY_VERSION_HEX >= 0x03000000 BOOST_PYTHON_BINARY_OPERATOR(truediv, rtruediv, /) #else BOOST_PYTHON_BINARY_OPERATOR(div, rdiv, /) #endif BOOST_PYTHON_BINARY_OPERATOR(mod, rmod, %) BOOST_PYTHON_BINARY_OPERATOR(lshift, rlshift, <<) BOOST_PYTHON_BINARY_OPERATOR(rshift, rrshift, >>) BOOST_PYTHON_BINARY_OPERATOR(and, rand, &) BOOST_PYTHON_BINARY_OPERATOR(xor, rxor, ^) BOOST_PYTHON_BINARY_OPERATOR(or, ror, |) BOOST_PYTHON_BINARY_OPERATOR(gt, lt, >) BOOST_PYTHON_BINARY_OPERATOR(ge, le, >=) BOOST_PYTHON_BINARY_OPERATOR(lt, gt, <) BOOST_PYTHON_BINARY_OPERATOR(le, ge, <=) BOOST_PYTHON_BINARY_OPERATOR(eq, eq, ==) BOOST_PYTHON_BINARY_OPERATOR(ne, ne, !=) # undef BOOST_PYTHON_BINARY_OPERATOR // pow isn't an operator in C++; handle it specially. BOOST_PYTHON_BINARY_OPERATION(pow, rpow, pow(l,r)) # undef BOOST_PYTHON_BINARY_OPERATION namespace self_ns { # ifndef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP template <class L, class R> inline detail::operator_<detail::op_pow,L,R> pow(L const&, R const&) { return detail::operator_<detail::op_pow,L,R>(); } # else // When there's no argument-dependent lookup, we need these // overloads to handle the case when everything is imported into the // global namespace. Note that the plain overload below does /not/ // take const& arguments. This is needed by MSVC6 at least, or it // complains of ambiguities, since there's no partial ordering. inline detail::operator_<detail::op_pow,self_t,self_t> pow(self_t, self_t) { return detail::operator_<detail::op_pow,self_t,self_t>(); } template <class R> inline detail::operator_<detail::op_pow,self_t,R> pow(self_t const&, R const&) { return detail::operator_<detail::op_pow,self_t,R>(); } template <class L> inline detail::operator_<detail::op_pow,L,self_t> pow(L const&, self_t const&) { return detail::operator_<detail::op_pow,L,self_t>(); } # endif } # define BOOST_PYTHON_INPLACE_OPERATOR(id, op) \ namespace detail \ { \ template <> \ struct operator_l<op_##id> \ { \ template <class L, class R> \ struct apply \ { \ typedef typename unwrap_wrapper_<L>::type lhs; \ typedef typename unwrap_wrapper_<R>::type rhs; \ static PyObject* \ execute(back_reference<lhs&> l, rhs const& r) \ { \ l.get() op r; \ return python::incref(l.source().ptr()); \ } \ }; \ static char const* name() { return "__" #id "__"; } \ }; \ } \ namespace self_ns \ { \ template <class R> \ inline detail::operator_<detail::op_##id,self_t,R> \ operator op(self_t const&, R const&) \ { \ return detail::operator_<detail::op_##id,self_t,R>(); \ } \ } BOOST_PYTHON_INPLACE_OPERATOR(iadd,+=) BOOST_PYTHON_INPLACE_OPERATOR(isub,-=) BOOST_PYTHON_INPLACE_OPERATOR(imul,*=) BOOST_PYTHON_INPLACE_OPERATOR(idiv,/=) BOOST_PYTHON_INPLACE_OPERATOR(imod,%=) BOOST_PYTHON_INPLACE_OPERATOR(ilshift,<<=) BOOST_PYTHON_INPLACE_OPERATOR(irshift,>>=) BOOST_PYTHON_INPLACE_OPERATOR(iand,&=) BOOST_PYTHON_INPLACE_OPERATOR(ixor,^=) BOOST_PYTHON_INPLACE_OPERATOR(ior,|=) # define BOOST_PYTHON_UNARY_OPERATOR(id, op, func_name) \ namespace detail \ { \ template <> \ struct operator_1<op_##id> \ { \ template <class T> \ struct apply \ { \ typedef typename unwrap_wrapper_<T>::type self_t; \ static PyObject* execute(self_t& x) \ { \ return detail::convert_result(op(x)); \ } \ }; \ static char const* name() { return "__" #id "__"; } \ }; \ } \ namespace self_ns \ { \ inline detail::operator_<detail::op_##id> \ func_name(self_t const&) \ { \ return detail::operator_<detail::op_##id>(); \ } \ } # undef BOOST_PYTHON_INPLACE_OPERATOR BOOST_PYTHON_UNARY_OPERATOR(neg, -, operator-) BOOST_PYTHON_UNARY_OPERATOR(pos, +, operator+) BOOST_PYTHON_UNARY_OPERATOR(abs, abs, abs) BOOST_PYTHON_UNARY_OPERATOR(invert, ~, operator~) #if PY_VERSION_HEX >= 0x03000000 BOOST_PYTHON_UNARY_OPERATOR(bool, !!, operator!) #else BOOST_PYTHON_UNARY_OPERATOR(nonzero, !!, operator!) #endif BOOST_PYTHON_UNARY_OPERATOR(int, long, int_) BOOST_PYTHON_UNARY_OPERATOR(long, PyLong_FromLong, long_) BOOST_PYTHON_UNARY_OPERATOR(float, double, float_) BOOST_PYTHON_UNARY_OPERATOR(complex, std::complex<double>, complex_) BOOST_PYTHON_UNARY_OPERATOR(str, lexical_cast<std::string>, str) BOOST_PYTHON_UNARY_OPERATOR(repr, lexical_cast<std::string>, repr) # undef BOOST_PYTHON_UNARY_OPERATOR }} // namespace boost::python # ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP using boost::python::self_ns::abs; using boost::python::self_ns::int_; using boost::python::self_ns::long_; using boost::python::self_ns::float_; using boost::python::self_ns::complex_; using boost::python::self_ns::str; using boost::python::self_ns::repr; using boost::python::self_ns::pow; # endif #endif // OPERATORS_DWA2002530_HPP