--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ossrv_pub/boost_apis/boost/python/operators.hpp Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,364 @@
+// 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, *)
+BOOST_PYTHON_BINARY_OPERATOR(div, rdiv, /)
+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~)
+BOOST_PYTHON_UNARY_OPERATOR(nonzero, !!, operator!)
+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)
+# 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::pow;
+# endif
+
+#endif // OPERATORS_DWA2002530_HPP