Future.h

#ifndef DASH__FUTURE_H__INCLUDED
#define DASH__FUTURE_H__INCLUDED

#include <cstddef>
#include <functional>
#include <sstream>
#include <iostream>
#include <utility>
#include <dash/Exception.h>
#include <dash/internal/Logging.h>


namespace dash {

template<typename ResultT>
class Future
{
public:
  typedef Future<ResultT>                self_t;

  typedef std::function<ResultT (void)>  get_func_t;

  typedef std::function<bool (ResultT*)> test_func_t;

  typedef std::function<void (void)>     destroy_func_t;

private:
  get_func_t     _get_func;
  test_func_t    _test_func;
  destroy_func_t _destroy_func;
  ResultT        _value{};
  bool           _ready{false};

public:
  // For ostream output
  template<typename ResultT_>
  friend std::ostream & operator<<(
      std::ostream & os,
      const Future<ResultT_> & future);

public:

  Future() noexcept(std::is_nothrow_constructible<ResultT>::value) = default;

  Future(ResultT  result) noexcept(std::is_nothrow_move_constructible<ResultT>::value)
  : _value(std::move(result)),
    _ready(true)
  { }

  Future(get_func_t get_func) noexcept
    : _get_func(std::move(get_func))
  {
  }

  Future(get_func_t get_func, test_func_t test_func) noexcept
    : _get_func(std::move(get_func))
    , _test_func(std::move(test_func))
  {
  }

  Future(
      get_func_t get_func, test_func_t test_func, destroy_func_t destroy_func) noexcept
    : _get_func(std::move(get_func))
    , _test_func(std::move(test_func))
    , _destroy_func(std::move(destroy_func))
  {
  }

  Future(const self_t& other) = delete;

  Future(self_t&& other) noexcept(
      std::is_nothrow_move_assignable<Future>::value)
  {
    *this = std::move(other);
  }

  ~Future() {
    if (_destroy_func) {
      _destroy_func();
    }
  }

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

  self_t& operator=(self_t&& other) noexcept(
      std::is_nothrow_move_assignable<ResultT>::value)
  {
    _get_func     = std::move(other._get_func);
    _test_func    = std::move(other._test_func);
    _destroy_func = std::move(other._destroy_func);
    _value        = std::move(other._value);
    _ready        = other._ready;
    return *this;
  }

  void wait()
  {
    DASH_LOG_TRACE_VAR("Future.wait()", _ready);
    if (_ready) {
      return;
    }
    if (!_get_func) {
      DASH_LOG_ERROR("Future.wait()", "No function");
      DASH_THROW(
        dash::exception::RuntimeError,
        "Future not initialized with function");
    }
    _value = _get_func();
    _ready = true;
    DASH_LOG_TRACE_VAR("Future.wait >", _ready);
  }

  bool test()
  {
    if (!_ready) {
      if (_test_func) {
        _ready = _test_func(&_value);
      } else if (_get_func) {
        _value = _get_func();
        _ready = true;
      } else {
        DASH_THROW(
          dash::exception::RuntimeError,
          "Future not initialized with function");
      }
    }
    return _ready;
  }

  ResultT get()
  {
    DASH_LOG_TRACE_VAR("Future.get()", _ready);
    wait();
    DASH_LOG_TRACE_VAR("Future.get >", _value);
    return _value;
  }


  bool valid() noexcept
  {
    return (_ready || _get_func != nullptr);
  }

}; // class Future


template<>
class Future<void>
{
public:
  typedef Future<void>               self_t;

  typedef std::function<void (void)> get_func_t;

  typedef std::function<bool (void)> test_func_t;

  typedef std::function<void (void)> destroy_func_t;

private:
  get_func_t     _get_func;
  test_func_t    _test_func;
  destroy_func_t _destroy_func;
  bool           _ready{false};

public:
  // For ostream output
  template<typename ResultT_>
  friend std::ostream & operator<<(
      std::ostream & os,
      const Future<ResultT_> & future);

public:
  Future()
// This commit fixes the issue:
// https://lists.llvm.org/pipermail/cfe-commits/Week-of-Mon-20161121/177858.html
#if defined(__clang__) && (__clang_major__ < 6)
  {}
#else
   noexcept = default;
#endif

  Future(get_func_t get_func) noexcept
    : _get_func(std::move(get_func))
  {
  }

  Future(get_func_t get_func, test_func_t test_func) noexcept
    : _get_func(std::move(get_func))
    , _test_func(std::move(test_func))
  {
  }

  Future(
    get_func_t      get_func,
    test_func_t     test_func,
    destroy_func_t  destroy_func) noexcept
  : _get_func(std::move(get_func)),
    _test_func(std::move(test_func)),
    _destroy_func(std::move(destroy_func))
  { }

  Future(const self_t& other) = delete;

  Future(self_t&& other) noexcept
  {
    *this = std::move(other);
  }

  ~Future() {
    if (_destroy_func) {
      _destroy_func();
    }
  }

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

  self_t& operator=(self_t&& other) noexcept
  {
    _get_func = std::move(other._get_func);
    _test_func = std::move(other._test_func);
    _destroy_func = std::move(other._destroy_func);
    _ready = other._ready;
    return *this;
  }

  void wait()
  {
    DASH_LOG_TRACE_VAR("Future.wait()", _ready);
    if (_ready) {
      return;
    }
    if (!_get_func) {
      DASH_LOG_ERROR("Future.wait()", "No function");
      DASH_THROW(
        dash::exception::RuntimeError,
        "Future not initialized with function");
    }
    _get_func();
    _ready = true;
    DASH_LOG_TRACE_VAR("Future.wait >", _ready);
  }

  bool test()
  {
    if (!_ready) {
      if (_test_func) {
        _ready = _test_func();
      } else if (_get_func) {
        _get_func();
        _ready = true;
      } else {
        DASH_THROW(
          dash::exception::RuntimeError,
          "Future not initialized with function");
      }
    }
    return _ready;
  }

  void get()
  {
    DASH_LOG_TRACE_VAR("Future.get()", _ready);
    wait();
    DASH_LOG_TRACE("Future.get >");
  }

  bool valid() noexcept
  {
    return (_get_func != nullptr);
  }

}; // class Future

template<typename ResultT>
std::ostream & operator<<(
  std::ostream & os,
  const Future<ResultT> & future)
{
  std::ostringstream ss;
  ss << "dash::Future<" << typeid(ResultT).name() << ">(";
  if (future._ready) {
    ss << future._value;
  } else {
    ss << "not ready";
  }
  ss << ")";
  return operator<<(os, ss.str());
}

}  // namespace dash

#endif // DASH__FUTURE_H__INCLUDED