Operation.h

#ifndef DASH__ALGORITHM__OPERATION_H__
#define DASH__ALGORITHM__OPERATION_H__

#include <dash/Meta.h>
#include <dash/Types.h>

#include <dash/dart/if/dart_types.h>

#include <functional>


namespace dash {

namespace internal {


enum class OpKind {
  ARITHMETIC,
  BITWISE,
  NOOP
};

template <
  typename         ValueType,
  dart_operation_t OP,
  OpKind           KIND,
  bool             enabled = true >
class ReduceOperation {
  static constexpr const dart_operation_t _op   = OP;
  static constexpr const OpKind           _kind = KIND;
public:
  typedef ValueType value_type;

public:
  static constexpr dart_operation_t
  dart_operation() {
    return _op;
  }

  static constexpr OpKind
  op_kind() {
    return _kind;
  }
};

template<typename BinaryOperation, typename = void>
struct dart_reduce_operation
  : public std::integral_constant<dart_operation_t, DART_OP_UNDEFINED>
{ };

template<typename BinaryOperation>
struct dart_reduce_operation<BinaryOperation,
        typename std::enable_if<
          // no-ops cannot be used in DART collectives
          BinaryOperation::op_kind() != dash::internal::OpKind::NOOP &&
          // only pre-defined operations can be used in DART collectives,
          // they are derived from dash::internal::ReduceOperation
          std::is_base_of<
            dash::internal::ReduceOperation<
              typename BinaryOperation::value_type,
              BinaryOperation::dart_operation(),
              BinaryOperation::op_kind(), true>,
            BinaryOperation>::value>::type>
  : public std::integral_constant<dart_operation_t,
                                  BinaryOperation::dart_operation()>
{ };

} // namespace internal

#ifdef DOXYGEN

template<typename BinaryOperation>
struct dart_operation
{
  dart_operation_t value;
}
#endif // DOXYGEN

template< typename ValueType >
struct min
: public internal::ReduceOperation< ValueType, DART_OP_MIN,
                                    dash::internal::OpKind::ARITHMETIC,
                                    dash::is_arithmetic<ValueType>::value > {
  ValueType operator()(
    const ValueType & lhs,
    const ValueType & rhs) const {
    return (lhs < rhs) ? lhs : rhs;
  }
};

template< typename ValueType >
struct max
: public internal::ReduceOperation< ValueType, DART_OP_MAX,
                                    dash::internal::OpKind::ARITHMETIC,
                                    dash::is_arithmetic<ValueType>::value > {
  ValueType operator()(
    const ValueType & lhs,
    const ValueType & rhs) const {
    return (lhs > rhs) ? lhs : rhs;
  }
};

template< typename ValueType >
struct plus
: public internal::ReduceOperation< ValueType, DART_OP_SUM,
                                    dash::internal::OpKind::ARITHMETIC,
                                    dash::is_arithmetic<ValueType>::value > {
  ValueType operator()(
    const ValueType & lhs,
    const ValueType & rhs) const {
    return lhs + rhs;
  }
};

template< typename ValueType >
struct multiply
: public internal::ReduceOperation< ValueType, DART_OP_PROD,
                                    dash::internal::OpKind::ARITHMETIC,
                                    dash::is_arithmetic<ValueType>::value > {
  ValueType operator()(
    const ValueType & lhs,
    const ValueType & rhs) const {
    return lhs * rhs;
  }
};

template< typename ValueType >
struct first
: public internal::ReduceOperation< ValueType, DART_OP_NO_OP,
                                    dash::internal::OpKind::NOOP, true > {
  ValueType operator()(const ValueType& lhs, const ValueType& /*rhs*/) const
  {
    return lhs;
  }
};

template< typename ValueType >
struct second
: public internal::ReduceOperation< ValueType, DART_OP_REPLACE,
                                    dash::internal::OpKind::NOOP, true > {
  ValueType operator()(const ValueType& /*lhs*/, const ValueType& rhs) const
  {
    return rhs;
  }
};

template< typename ValueType >
struct bit_and
: public internal::ReduceOperation< ValueType, DART_OP_BAND,
                                    dash::internal::OpKind::BITWISE, true > {
  ValueType operator()(
    const ValueType & lhs,
    const ValueType & rhs) const {
    return lhs & rhs;
  }
};

template< typename ValueType >
struct bit_or
: public internal::ReduceOperation< ValueType, DART_OP_BOR,
                                    dash::internal::OpKind::BITWISE, true > {
  ValueType operator()(
    const ValueType & lhs,
    const ValueType & rhs) const {
    return lhs | rhs;
  }
};

template< typename ValueType >
struct bit_xor
: public internal::ReduceOperation< ValueType, DART_OP_BXOR,
                                    dash::internal::OpKind::BITWISE, true > {
  ValueType operator()(
    const ValueType & lhs,
    const ValueType & rhs) const {
    return lhs ^ rhs;
  }
};

}  // namespace dash

#endif // DASH__ALGORITHM__OPERATION_H__