pyOperators.h

//
// Copyright 2017 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
 
#ifndef PXR_BASE_VT_PY_OPERATORS_H
#define PXR_BASE_VT_PY_OPERATORS_H
 
#include "pxr/pxr.h"
#include "pxr/base/vt/api.h"
 
PXR_NAMESPACE_OPEN_SCOPE
 
namespace {
// Per-op helpers with auto return so the result type is deduced from the
// element operation.  This enables heterogeneous results for list/tuple
// operands (e.g. __sub__ on a TimeCode array produces a Duration array).
// The bool specialization preserves existing Hyrum's-Law behavior.
template <class T>
struct _ArrayPyOpHelp {
    static auto __add__(T l, T r) { return l + r; }
    static auto __sub__(T l, T r) { return l - r; }
    static auto __mul__(T l, T r) { return l * r; }
    static auto __div__(T l, T r) { return l / r; }
    static auto __mod__(T l, T r) { return l % r; }
};
 
// These operations on bool-arrays are highly questionable, but this preserves
// existing behavior in the name of Hyrum's Law.
template <>
struct _ArrayPyOpHelp<bool> {
    static bool __add__(bool l, bool r) { return l | r; }
    static bool __sub__(bool l, bool r) { return l ^ r; }
    static bool __mul__(bool l, bool r) { return l & r; }
    static bool __div__(bool l, bool r) { return l; }
    static bool __mod__(bool l, bool r) { return false; }
};
 
} // anon
 
// -------------------------------------------------------------------------
// Python operator definitions
// -------------------------------------------------------------------------
// These will define the operator to work with tuples and lists from Python.
 
// base macro called by wrapping layers below for various operators, python
// types (lists and tuples), and special methods.
// The return type is deduced from _ArrayPyOpHelp<T>::op so that heterogeneous
// results work correctly (e.g. __sub__ on a TimeCode array returns a Duration
// array).  Elements are extracted as T and the op result is stored in
// VtArray<RetElem>.
#define VTOPERATOR_WRAP_PYTYPE_BASE(op, method, pytype, isRightVer)          \
    template <typename T> static                                             \
    auto method##pytype(VtArray<T> vec, pytype obj)                          \
    {                                                                        \
        using RetElem = decltype(                                            \
            _ArrayPyOpHelp<T>:: op (std::declval<T>(), std::declval<T>()));  \
        size_t length = len(obj);                                            \
        if (length != vec.size()) {                                          \
            TfPyThrowValueError("Non-conforming inputs for operator "        \
                                #method);                                    \
            return VtArray<RetElem>();                                       \
        }                                                                    \
        VtArray<RetElem> ret(vec.size());                                    \
        for (size_t i = 0; i < length; ++i) {                                \
            if (!extract<T>(obj[i]).check())                                 \
                TfPyThrowValueError("Element is of incorrect type.");        \
            if (isRightVer) {                                                \
                ret[i] = _ArrayPyOpHelp<T>:: op (                            \
                    (T)extract<T>(obj[i]), vec[i]);                          \
            }                                                                \
            else {                                                           \
                ret[i] = _ArrayPyOpHelp<T>:: op (                            \
                    vec[i], (T)extract<T>(obj[i]));                          \
            }                                                                \
        }                                                                    \
        return ret;                                                          \
    }
 
// wrap Array op pytype
#define VTOPERATOR_WRAP_PYTYPE(op, method, pytype)                          \
    VTOPERATOR_WRAP_PYTYPE_BASE(op, method, pytype, false)
 
// wrap pytype op Array (for noncommutative ops like subtraction)
#define VTOPERATOR_WRAP_PYTYPE_R(op, method, pytype)                           \
    VTOPERATOR_WRAP_PYTYPE_BASE(op, method, pytype, true) 
 
 
// operator that needs a special method plus a reflected special method,
// each defined on tuples and lists
#define VTOPERATOR_WRAP(lmethod,rmethod)                                       \
    VTOPERATOR_WRAP_PYTYPE(lmethod,lmethod,tuple)                              \
    VTOPERATOR_WRAP_PYTYPE(lmethod,lmethod,list)                               \
    VTOPERATOR_WRAP_PYTYPE(lmethod,rmethod,tuple)                              \
    VTOPERATOR_WRAP_PYTYPE(lmethod,rmethod,list)                
 
// like above, but for non-commutative ops like subtraction
#define VTOPERATOR_WRAP_NONCOMM(lmethod,rmethod)            \
    VTOPERATOR_WRAP_PYTYPE(lmethod,lmethod,tuple)           \
    VTOPERATOR_WRAP_PYTYPE(lmethod,lmethod,list)            \
    VTOPERATOR_WRAP_PYTYPE_R(lmethod,rmethod,tuple)         \
    VTOPERATOR_WRAP_PYTYPE_R(lmethod,rmethod,list)                
 
// to be used to actually declare the wrapping with def() on the class
#define VTOPERATOR_WRAPDECLARE_BASE(op,method,rettype)      \
    .def(self op self)                                      \
    .def(self op Type())                                    \
    .def(Type() op self)                                    \
    .def(#method,method##tuple<rettype>)                    \
    .def(#method,method##list<rettype>)                      
 
#define VTOPERATOR_WRAPDECLARE(op,lmethod,rmethod)          \
    VTOPERATOR_WRAPDECLARE_BASE(op,lmethod,Type)            \
    .def(#rmethod,rmethod##tuple<Type>)                     \
    .def(#rmethod,rmethod##list<Type>)                
 
// array OP pytype
// pytype OP array
#define VTOPERATOR_WRAP_PYTYPE_BOOL(func,pytype,op)         \
        VTOPERATOR_WRAP_PYTYPE_BOOL_BASE(func,              \
            VtArray<T> const &vec, pytype const &obj,       \
            (vec[i] op (T)extract<T>(obj[i])) )             \
        VTOPERATOR_WRAP_PYTYPE_BOOL_BASE(func,              \
            pytype const &obj,VtArray<T> const &vec,        \
            ((T)extract<T>(obj[i]) op vec[i]) )             
 
#define VTOPERATOR_WRAP_BOOL(func,op)                       \
        VTOPERATOR_WRAP_PYTYPE_BOOL(func,list,op)           \
        VTOPERATOR_WRAP_PYTYPE_BOOL(func,tuple,op)          
                      
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_BASE_VT_PY_OPERATORS_H