Operation.h

#ifndef DASH__ATOMIC_OPERATION_H_
#define DASH__ATOMIC_OPERATION_H_

#include <dash/atomic/GlobAtomicRef.h>

namespace dash {

// forward decls
template<typename T>
class Atomic;

namespace atomic {

template<typename T>
T load(const dash::GlobRef<dash::Atomic<T>>& ref){
  return ref.load();
}

template<typename T>
void store(const dash::GlobRef<dash::Atomic<T>>& ref,
           const T & value)
{
  ref.store(value);
}

template<typename T>
T exchange(const dash::GlobRef<dash::Atomic<T>>& ref,
           const T & value)
{
  return ref.exchange(value);
}

template<typename T>
bool compare_exchange(
  const dash::GlobRef<dash::Atomic<T>>& ref,
  const T & expected,
  const T & desired)
{
  return ref.compare_exchange(expected, desired);
}

template<
  typename T,
  typename BinaryOp >
void op(
  const dash::GlobRef<dash::Atomic<T>>& ref,
  const BinaryOp  binary_op,
  const T & value)
{
  ref.op(binary_op, value);
}

template<
  typename T,
  typename BinaryOp >
T fetch_op(
  const dash::GlobRef<dash::Atomic<T>>& ref,
  const BinaryOp  binary_op,
  const T & value)
{
  return ref.fetch_op(binary_op, value);
}

template<typename T>
typename std::enable_if<
  std::is_integral<T>::value,
  void>::type
add(
  const dash::GlobRef<dash::Atomic<T>>& ref,
  const T & value)
{
  ref.add(value);
}

template<typename T>
typename std::enable_if<
  std::is_integral<T>::value,
  void>::type
sub(
  const dash::GlobRef<dash::Atomic<T>>& ref,
  const T & value)
{
  ref.sub(value);
}

template<typename T>
typename std::enable_if<
  std::is_integral<T>::value,
  void>::type
multiply(
  const dash::GlobRef<dash::Atomic<T>>& ref,
  const T & value)
{
  ref.multiply(value);
}


template<typename T>
typename std::enable_if<
  std::is_integral<T>::value,
  T>::type
fetch_add(
  const dash::GlobRef<dash::Atomic<T>>& ref,
  const T & value)
{
  return ref.fetch_add(value);
}

template<typename T>
typename std::enable_if<
  std::is_integral<T>::value,
  T>::type
fetch_sub(
  const dash::GlobRef<dash::Atomic<T>>& ref,
  const T & value)
{
  return ref.fetch_sub(value);
}

} // namespace atomic
} // namespace dash

#endif // DASH__ATOMIC_OPERATION_H_