mirror of
https://github.com/boostorg/python.git
synced 2026-01-22 05:22:45 +00:00
414 lines
16 KiB
C++
414 lines
16 KiB
C++
#ifndef OPERATORS_UK112000_H_
|
|
#define OPERATORS_UK112000_H_
|
|
|
|
#include "functions.h"
|
|
#if !defined(__GNUC__) || defined(__SGI_STL_PORT)
|
|
# include <sstream>
|
|
#else
|
|
# include <strstream>
|
|
#endif
|
|
|
|
namespace py {
|
|
|
|
namespace detail {
|
|
|
|
template <long> struct define_operator;
|
|
|
|
// Base class which grants access to ExtensionClassBase::add_method() to its derived classes
|
|
struct add_operator_base
|
|
{
|
|
protected:
|
|
static inline void add_method(ExtensionClassBase* target, Function* method, const char* name)
|
|
{ target->add_method(method, name); }
|
|
};
|
|
|
|
//
|
|
// choose_op, choose_unary_op, and choose_rop
|
|
//
|
|
// These templates use "poor man's partial specialization" to generate the
|
|
// appropriate add_method() call (if any) for a given operator and argument set.
|
|
//
|
|
// Usage:
|
|
// choose_op<(which & op_add)>::template args<left_t,right_t>::add(ext_class);
|
|
//
|
|
// (see ExtensionClass<>::def_operators() for more examples).
|
|
//
|
|
template <long op_selector>
|
|
struct choose_op
|
|
{
|
|
template <class Left, class Right = Left>
|
|
struct args : add_operator_base
|
|
{
|
|
static inline void add(ExtensionClassBase* target)
|
|
{
|
|
typedef define_operator<op_selector> def_op;
|
|
add_method(target,
|
|
new typename def_op::template operator_function<Left, Right>(),
|
|
def_op::name());
|
|
}
|
|
|
|
};
|
|
};
|
|
|
|
// specialization for 0 has no effect
|
|
template <>
|
|
struct choose_op<0>
|
|
{
|
|
template <class Left, class Right = Left>
|
|
struct args
|
|
{
|
|
static inline void add(ExtensionClassBase*)
|
|
{
|
|
}
|
|
|
|
};
|
|
};
|
|
|
|
template <long op_selector>
|
|
struct choose_unary_op
|
|
{
|
|
template <class Operand>
|
|
struct args : add_operator_base
|
|
{
|
|
static inline void add(ExtensionClassBase* target)
|
|
{
|
|
typedef define_operator<op_selector> def_op;
|
|
add_method(target,
|
|
new typename def_op::template operator_function<Operand>(),
|
|
def_op::name());
|
|
}
|
|
|
|
};
|
|
};
|
|
|
|
// specialization for 0 has no effect
|
|
template <>
|
|
struct choose_unary_op<0>
|
|
{
|
|
template <class Operand>
|
|
struct args
|
|
{
|
|
static inline void add(ExtensionClassBase*)
|
|
{
|
|
}
|
|
|
|
};
|
|
};
|
|
|
|
template <long op_selector>
|
|
struct choose_rop
|
|
{
|
|
template <class Left, class Right = Left>
|
|
struct args : add_operator_base
|
|
{
|
|
static inline void add(ExtensionClassBase* target)
|
|
{
|
|
typedef define_operator<op_selector> def_op;
|
|
add_method(target,
|
|
new typename def_op::template roperator_function<Right, Left>(),
|
|
def_op::rname());
|
|
}
|
|
|
|
};
|
|
};
|
|
|
|
// specialization for 0 has no effect
|
|
template <>
|
|
struct choose_rop<0>
|
|
{
|
|
template <class Left, class Right = Left>
|
|
struct args
|
|
{
|
|
static inline void add(ExtensionClassBase*)
|
|
{
|
|
}
|
|
|
|
};
|
|
};
|
|
|
|
#define PY_DEFINE_BINARY_OPERATORS(id, oper) \
|
|
template <> \
|
|
struct define_operator<op_##id> \
|
|
{ \
|
|
template <class Left, class Right = Left> \
|
|
struct operator_function : Function \
|
|
{ \
|
|
PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const \
|
|
{ \
|
|
Tuple args(Ptr(arguments, Ptr::new_ref)); \
|
|
\
|
|
return PY_CONVERSION::to_python( \
|
|
PY_CONVERSION::from_python(args[0].get(), py::Type<Left>()) oper \
|
|
PY_CONVERSION::from_python(args[1].get(), py::Type<Right>())); \
|
|
} \
|
|
\
|
|
const char* description() const \
|
|
{ return "__" #id "__"; } \
|
|
}; \
|
|
\
|
|
template <class Right, class Left> \
|
|
struct roperator_function : Function \
|
|
{ \
|
|
PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const \
|
|
{ \
|
|
Tuple args(Ptr(arguments, Ptr::new_ref)); \
|
|
\
|
|
return PY_CONVERSION::to_python( \
|
|
PY_CONVERSION::from_python(args[1].get(), py::Type<Left>()) oper \
|
|
PY_CONVERSION::from_python(args[0].get(), py::Type<Right>())); \
|
|
} \
|
|
\
|
|
const char* description() const \
|
|
{ return "__r" #id "__"; } \
|
|
\
|
|
}; \
|
|
\
|
|
static const char * name() { return "__" #id "__"; } \
|
|
static const char * rname() { return "__r" #id "__"; } \
|
|
}
|
|
|
|
#define PY_DEFINE_UNARY_OPERATORS(id, oper) \
|
|
template <> \
|
|
struct define_operator<op_##id> \
|
|
{ \
|
|
template <class operand> \
|
|
struct operator_function : Function \
|
|
{ \
|
|
PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const \
|
|
{ \
|
|
Tuple args(Ptr(arguments, Ptr::new_ref)); \
|
|
\
|
|
return PY_CONVERSION::to_python( \
|
|
oper(PY_CONVERSION::from_python(args[0].get(), py::Type<operand>()))); \
|
|
} \
|
|
\
|
|
const char* description() const \
|
|
{ return "__" #id "__"; } \
|
|
}; \
|
|
\
|
|
static const char * name() { return "__" #id "__"; } \
|
|
}
|
|
|
|
PY_DEFINE_BINARY_OPERATORS(add, +);
|
|
PY_DEFINE_BINARY_OPERATORS(sub, -);
|
|
PY_DEFINE_BINARY_OPERATORS(mul, *);
|
|
PY_DEFINE_BINARY_OPERATORS(div, /);
|
|
PY_DEFINE_BINARY_OPERATORS(mod, %);
|
|
PY_DEFINE_BINARY_OPERATORS(lshift, <<);
|
|
PY_DEFINE_BINARY_OPERATORS(rshift, >>);
|
|
PY_DEFINE_BINARY_OPERATORS(and, &);
|
|
PY_DEFINE_BINARY_OPERATORS(xor, ^);
|
|
PY_DEFINE_BINARY_OPERATORS(or, |);
|
|
|
|
PY_DEFINE_UNARY_OPERATORS(neg, -);
|
|
PY_DEFINE_UNARY_OPERATORS(pos, +);
|
|
PY_DEFINE_UNARY_OPERATORS(abs, abs);
|
|
PY_DEFINE_UNARY_OPERATORS(invert, ~);
|
|
PY_DEFINE_UNARY_OPERATORS(int, int);
|
|
PY_DEFINE_UNARY_OPERATORS(long, long);
|
|
PY_DEFINE_UNARY_OPERATORS(float, double);
|
|
|
|
#undef PY_DEFINE_BINARY_OPERATORS
|
|
#undef PY_DEFINE_UNARY_OPERATORS
|
|
|
|
template <>
|
|
struct define_operator<op_pow>
|
|
{
|
|
template <class Left, class Right = Left>
|
|
struct operator_function : Function
|
|
{
|
|
PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const
|
|
{
|
|
Tuple args(Ptr(arguments, Ptr::new_ref));
|
|
|
|
if (args.size() == 3 && args[2]->ob_type != Py_None->ob_type)
|
|
{
|
|
PyErr_SetString(PyExc_TypeError, "expected 2 arguments, got 3");
|
|
throw ArgumentError();
|
|
}
|
|
|
|
return PY_CONVERSION::to_python(
|
|
pow(PY_CONVERSION::from_python(args[0].get(), py::Type<Left>()),
|
|
PY_CONVERSION::from_python(args[1].get(), py::Type<Right>())));
|
|
}
|
|
|
|
const char* description() const
|
|
{ return "__pow__"; }
|
|
|
|
};
|
|
|
|
template <class Right, class Left>
|
|
struct roperator_function : Function
|
|
{
|
|
PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const
|
|
{
|
|
Tuple args(Ptr(arguments, Ptr::new_ref));
|
|
|
|
if (args.size() == 3 && args[2]->ob_type != Py_None->ob_type)
|
|
{
|
|
PyErr_SetString(PyExc_TypeError, "bad operand type(s) for pow()");
|
|
throw ArgumentError();
|
|
}
|
|
|
|
return PY_CONVERSION::to_python(
|
|
pow(PY_CONVERSION::from_python(args[1].get(), py::Type<Left>()),
|
|
PY_CONVERSION::from_python(args[0].get(), py::Type<Right>())));
|
|
}
|
|
|
|
const char* description() const
|
|
{ return "__rpow__"; }
|
|
|
|
};
|
|
|
|
static const char * name() { return "__pow__"; }
|
|
static const char * rname() { return "__rpow__"; }
|
|
};
|
|
|
|
template <>
|
|
struct define_operator<op_divmod>
|
|
{
|
|
template <class Left, class Right = Left>
|
|
struct operator_function : Function
|
|
{
|
|
PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const
|
|
{
|
|
Tuple args(Ptr(arguments, Ptr::new_ref));
|
|
PyObject * res = PyTuple_New(2);
|
|
|
|
PyTuple_SET_ITEM(res, 0,
|
|
PY_CONVERSION::to_python(
|
|
PY_CONVERSION::from_python(args[0].get(), py::Type<Left>()) /
|
|
PY_CONVERSION::from_python(args[1].get(), py::Type<Right>())));
|
|
PyTuple_SET_ITEM(res, 1,
|
|
PY_CONVERSION::to_python(
|
|
PY_CONVERSION::from_python(args[0].get(), py::Type<Left>()) %
|
|
PY_CONVERSION::from_python(args[1].get(), py::Type<Right>())));
|
|
|
|
return res;
|
|
}
|
|
|
|
const char* description() const
|
|
{ return "__divmod__"; }
|
|
|
|
};
|
|
|
|
template <class Right, class Left>
|
|
struct roperator_function : Function
|
|
{
|
|
PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const
|
|
{
|
|
Tuple args(Ptr(arguments, Ptr::new_ref));
|
|
PyObject * res = PyTuple_New(2);
|
|
|
|
PyTuple_SET_ITEM(res, 0,
|
|
PY_CONVERSION::to_python(
|
|
PY_CONVERSION::from_python(args[1].get(), py::Type<Left>()) /
|
|
PY_CONVERSION::from_python(args[0].get(), py::Type<Right>())));
|
|
PyTuple_SET_ITEM(res, 1,
|
|
PY_CONVERSION::to_python(
|
|
PY_CONVERSION::from_python(args[1].get(), py::Type<Left>()) %
|
|
PY_CONVERSION::from_python(args[0].get(), py::Type<Right>())));
|
|
|
|
return res;
|
|
}
|
|
|
|
const char* description() const
|
|
{ return "__rdivmod__"; }
|
|
|
|
};
|
|
|
|
static const char * name() { return "__divmod__"; }
|
|
static const char * rname() { return "__rdivmod__"; }
|
|
};
|
|
|
|
template <>
|
|
struct define_operator<op_cmp>
|
|
{
|
|
template <class Left, class Right = Left>
|
|
struct operator_function : Function
|
|
{
|
|
PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const
|
|
{
|
|
Tuple args(Ptr(arguments, Ptr::new_ref));
|
|
|
|
return PY_CONVERSION::to_python(
|
|
(PY_CONVERSION::from_python(args[0].get(), py::Type<Left>()) <
|
|
PY_CONVERSION::from_python(args[1].get(), py::Type<Right>())) ?
|
|
- 1 :
|
|
(PY_CONVERSION::from_python(args[1].get(), py::Type<Right>()) <
|
|
PY_CONVERSION::from_python(args[0].get(), py::Type<Left>())) ?
|
|
1 :
|
|
0) ;
|
|
}
|
|
|
|
const char* description() const
|
|
{ return "__cmp__"; }
|
|
|
|
};
|
|
|
|
template <class Right, class Left>
|
|
struct roperator_function : Function
|
|
{
|
|
PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const
|
|
{
|
|
Tuple args(Ptr(arguments, Ptr::new_ref));
|
|
|
|
return PY_CONVERSION::to_python(
|
|
(PY_CONVERSION::from_python(args[1].get(), py::Type<Left>()) <
|
|
PY_CONVERSION::from_python(args[0].get(), py::Type<Right>())) ?
|
|
- 1 :
|
|
(PY_CONVERSION::from_python(args[0].get(), py::Type<Right>()) <
|
|
PY_CONVERSION::from_python(args[1].get(), py::Type<Left>())) ?
|
|
1 :
|
|
0) ;
|
|
}
|
|
|
|
const char* description() const
|
|
{ return "__rcmp__"; }
|
|
|
|
};
|
|
|
|
static const char * name() { return "__cmp__"; }
|
|
static const char * rname() { return "__rcmp__"; }
|
|
};
|
|
|
|
template <>
|
|
struct define_operator<op_str>
|
|
{
|
|
template <class operand>
|
|
struct operator_function : Function
|
|
{
|
|
PyObject* do_call(PyObject* arguments, PyObject*) const
|
|
{
|
|
Tuple args(Ptr(arguments, Ptr::new_ref));
|
|
|
|
#if !defined(__GNUC__) || defined(__SGI_STL_PORT)
|
|
std::ostringstream s;
|
|
s << PY_CONVERSION::from_python(args[0].get(), py::Type<operand>());
|
|
#else
|
|
std::ostrstream s;
|
|
s << PY_CONVERSION::from_python(args[0].get(), py::Type<operand>()) << char();
|
|
#endif
|
|
|
|
#if !defined(__GNUC__) || defined(__SGI_STL_PORT)
|
|
return PY_CONVERSION::to_python(s.str());
|
|
#else
|
|
return PY_CONVERSION::to_python(const_cast<char const *>(s.str()));
|
|
#endif
|
|
}
|
|
|
|
const char* description() const
|
|
{ return "__str__"; }
|
|
|
|
};
|
|
|
|
static const char * name() { return "__str__"; }
|
|
};
|
|
|
|
|
|
} // namespace detail
|
|
|
|
} // namespace py
|
|
|
|
#endif /* OPERATORS_UK112000_H_ */
|