GlobAsyncRef.h

#ifndef DASH__GLOB_ASYNC_REF_H__
#define DASH__GLOB_ASYNC_REF_H__

#include <iostream>

#include <dash/GlobPtr.h>
#include <dash/Onesided.h>

#include <dash/iterator/internal/GlobRefBase.h>


namespace dash {

// Forward declarations
template <class T>
class GlobRef;

template<typename T>
class GlobAsyncRef
{
  template<typename U>
  friend std::ostream & operator<<(
    std::ostream & os,
    const GlobAsyncRef<U> & gar);

  template <
    typename ElementT >
  friend class GlobAsyncRef;

  struct ReleaseHandle {
    void operator()(dart_handle_t handle)
    {
      DASH_ASSERT_RETURNS(
        dart_wait_local(&handle),
        DART_OK
      );
    }
  };

public:
  using value_type          = T;
  using const_value_type    = typename std::add_const<T>::type;
  using nonconst_value_type = typename std::remove_const<T>::type;
  using self_t              = GlobAsyncRef<T>;
  using const_type          = GlobAsyncRef<const_value_type>;
  using nonconst_type       = GlobAsyncRef<nonconst_value_type>;

private:
  dart_gptr_t  _gptr{};
  mutable nonconst_value_type _value;
  mutable std::
      unique_ptr<std::remove_pointer<dart_handle_t>::type, ReleaseHandle>
          _handle{DART_HANDLE_NULL};

private:

  template<typename ParentT>
  GlobAsyncRef(
    const GlobAsyncRef<ParentT> & parent,
    size_t                        offset)
  : _gptr(parent._gptr)
  {
     DASH_ASSERT_RETURNS(
      dart_gptr_incaddr(&_gptr, offset),
      DART_OK);
  }

  template<class ElementT, class MemSpaceT>
  explicit GlobAsyncRef(
    GlobPtr<ElementT, MemSpaceT> & gptr)
  : _gptr(gptr.dart_gptr())
  { }

public:

  explicit GlobAsyncRef(
    dart_gptr_t   dart_gptr)
  : _gptr(dart_gptr)
  { }

  template<typename _T,
           int = internal::enable_implicit_copy_ctor<value_type, _T>::value>
  GlobAsyncRef(const GlobAsyncRef<_T>& gref)
  : GlobAsyncRef(gref.dart_gptr())
  { }

  template <
      typename _T,
      long = internal::enable_explicit_copy_ctor<value_type, _T>::value>
  explicit GlobAsyncRef(const GlobAsyncRef<_T>& gref)
    : GlobAsyncRef(gref.dart_gptr())
  {
  }

  template <
      typename _T,
      int = internal::enable_implicit_copy_ctor<value_type, _T>::value>
  GlobAsyncRef(const GlobRef<_T>& gref)
    : GlobAsyncRef(gref.dart_gptr())
  {
  }

  template <
      typename _T,
      long = internal::enable_explicit_copy_ctor<value_type, _T>::value>
  explicit GlobAsyncRef(const GlobRef<_T>& gref)
    : GlobAsyncRef(gref.dart_gptr())
  {
  }

  ~GlobAsyncRef() = default;

  GlobAsyncRef(self_t&& other) = default;

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

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

  inline bool is_local() const noexcept
  {
    return dash::internal::is_local(this->_gptr);
  }

  template<typename MEMTYPE>
  GlobAsyncRef<typename internal::add_const_from_type<T, MEMTYPE>::type>
  member(size_t offs) const {
    return GlobAsyncRef<typename internal::add_const_from_type<T, MEMTYPE>::type>(*this, offs);
  }

  template<class MEMTYPE, class P=T>
  GlobAsyncRef<typename internal::add_const_from_type<T, MEMTYPE>::type>
  member(
    const MEMTYPE P::*mem) const {
    auto offs = (size_t) & (reinterpret_cast<P*>(0)->*mem);
    return member<typename internal::add_const_from_type<T, MEMTYPE>::type>(offs);
  }

  friend void swap(self_t & a, self_t & b) {
    static_assert(std::is_same<value_type, nonconst_value_type>::value,
                  "Cannot swap GlobAsyncRef<const T>!");
    nonconst_value_type temp = a->get();
    a = b->get();
    b = temp;
  }

  nonconst_value_type get() const {
    nonconst_value_type value;
    DASH_LOG_TRACE_VAR("GlobAsyncRef.T()", _gptr);
    dash::internal::get_blocking(_gptr, &value, 1);
    return value;
  }

  void get(nonconst_value_type *tptr) const {
    dash::internal::get(_gptr, tptr, 1);
  }

  void get(nonconst_value_type& tref) const {
    get(&tref);
  }

  void set(const_value_type* tptr) const {
    static_assert(std::is_same<value_type, nonconst_value_type>::value,
                  "Cannot modify value through GlobAsyncRef<const T>!");
    DASH_LOG_TRACE_VAR("GlobAsyncRef.set()", *tptr);
    DASH_LOG_TRACE_VAR("GlobAsyncRef.set()", _gptr);
    dash::internal::put(_gptr, tptr, 1);
  }

  void set(const_value_type& new_value) const {
    static_assert(std::is_same<value_type, nonconst_value_type>::value,
                  "Cannot modify value through GlobAsyncRef<const T>!");
    DASH_LOG_TRACE_VAR("GlobAsyncRef.set()", new_value);
    DASH_LOG_TRACE_VAR("GlobAsyncRef.set()", _gptr);

    _value = new_value;

    dart_handle_t new_handle;
    dash::internal::put_handle(_gptr, &_value, 1, &new_handle);

    _handle.reset(new_handle);
  }

  const self_t &
  operator=(const_value_type & new_value) const
  {
    set(new_value);
    return *this;
  }

  dart_gptr_t dart_gptr() const {
    return this->_gptr;
  }

  template <class ValueT>
  bool operator==(const GlobAsyncRef<ValueT> & other) = delete;

  template <class ValueT>
  bool operator!=(const GlobAsyncRef<ValueT> & other) = delete;

  void flush() const
  {
    DASH_ASSERT_RETURNS(
      dart_flush(_gptr),
      DART_OK
    );
  }

}; // class GlobAsyncRef

template<typename T>
std::ostream & operator<<(
  std::ostream & os,
  const GlobAsyncRef<T> & gar) {
  os << "dash::GlobAsyncRef(" << gar._gptr << ")";
  return os;
}

}  // namespace dash

#endif // DASH__GLOB_ASYNC_REF_H__