Atomic.h

#ifndef DASH__ATOMIC_H__INCLUDED
#define DASH__ATOMIC_H__INCLUDED

#include <dash/Meta.h>

#include <type_traits>
#include <sstream>


namespace dash {

template <typename T>
class Atomic
{
  static_assert(
    dash::is_atomic_compatible<T>::value,
    "Type not supported for atomic operations");

private:
  T _value;
  typedef Atomic<T> self_t;

public:
  typedef T value_type;

  constexpr Atomic()                       = default;
  constexpr Atomic(const Atomic<T>& other) = default;
  constexpr Atomic(Atomic<T>&& other)      = default;

  self_t& operator=(const self_t& other)   = default;
  self_t& operator=(self_t&& other)        = default;

  constexpr Atomic(T value)
  : _value(value) { }

  T operator=(T value) = delete;

  operator T()         = delete;

  constexpr bool operator==(const self_t & other) const {
    return _value == other._value;
  }

  constexpr bool operator!=(const self_t & other) const {
    return !(*this == other);
  }

  template<typename T_>
  friend std::ostream & operator<<(
    std::ostream     & os,
    const Atomic<T_> & at);

}; // class Atomic

template<typename T>
std::ostream & operator<<(
  std::ostream    & os,
  const Atomic<T> & at)
{
  std::ostringstream ss;
  ss << dash::typestr(at) << "<phantom>";
  return operator<<(os, ss.str());
}

} // namespace dash

#include <dash/atomic/Type_traits.h>
#include <dash/atomic/GlobAtomicRef.h>
#include <dash/atomic/GlobAtomicAsyncRef.h>
#include <dash/atomic/Operation.h>

#endif // DASH__ATOMIC_H__INCLUDED