Future.h

#pragma once
 
#include "Impl/AsyncSystemSchedulers.h"
#include "Impl/CatchFunction.h"
#include "Impl/ContinuationFutureType.h"
#include "Impl/WithTracing.h"
#include "SharedFuture.h"
#include "ThreadPool.h"
 
#include <CesiumUtility/Tracing.h>
 
#include <variant>
 
namespace CesiumAsync {
 
namespace CesiumImpl {
 
template <typename R> struct ParameterizedTaskUnwrapper;
struct TaskUnwrapper;
 
} // namespace CesiumImpl
 
template <typename T> class Future final {
public:
  Future(Future<T>&& rhs) noexcept
      : _pSchedulers(std::move(rhs._pSchedulers)),
        _task(std::move(rhs._task)) {}
 
  Future<T>& operator=(Future<T>&& rhs) noexcept {
    this->_pSchedulers = std::move(rhs._pSchedulers);
    this->_task = std::move(rhs._task);
    return *this;
  }
 
  Future(const Future<T>& rhs) = delete;
  Future<T>& operator=(const Future<T>& rhs) = delete;
 
  template <typename Func>
  CesiumImpl::ContinuationFutureType_t<Func, T>
  thenInWorkerThread(Func&& f) && {
    return std::move(*this).thenWithScheduler(
        this->_pSchedulers->workerThread.immediate,
        "waiting for worker thread",
        std::forward<Func>(f));
  }
 
  template <typename Func>
  CesiumImpl::ContinuationFutureType_t<Func, T> thenInMainThread(Func&& f) && {
    return std::move(*this).thenWithScheduler(
        this->_pSchedulers->mainThread.immediate,
        "waiting for main thread",
        std::forward<Func>(f));
  }
 
  template <typename Func>
  CesiumImpl::ContinuationFutureType_t<Func, T> thenImmediately(Func&& f) && {
    return CesiumImpl::ContinuationFutureType_t<Func, T>(
        this->_pSchedulers,
        _task.then(
            async::inline_scheduler(),
            CesiumImpl::WithTracing<T>::end(nullptr, std::forward<Func>(f))));
  }
 
  template <typename Func>
  CesiumImpl::ContinuationFutureType_t<Func, T>
  thenInThreadPool(const ThreadPool& threadPool, Func&& f) && {
    return std::move(*this).thenWithScheduler(
        threadPool._pScheduler->immediate,
        "waiting for thread pool thread",
        std::forward<Func>(f));
  }
 
  template <typename Func> Future<T> catchInMainThread(Func&& f) && {
    return std::move(*this).catchWithScheduler(
        this->_pSchedulers->mainThread.immediate,
        std::forward<Func>(f));
  }
 
  template <typename Func> Future<T> catchImmediately(Func&& f) && {
    return std::move(*this).catchWithScheduler(
        async::inline_scheduler(),
        std::forward<Func>(f));
  }
 
  template <typename... TPassThrough>
  Future<std::tuple<TPassThrough..., T>>
  thenPassThrough(TPassThrough&&... values) && {
    return std::move(*this).thenImmediately(
        [values = std::tuple(std::forward<TPassThrough>(values)...)](
            T&& result) mutable {
          return std::tuple_cat(
              std::move(values),
              std::make_tuple(std::move(result)));
        });
  }
 
  T wait() { return this->_task.get(); }
 
  T waitInMainThread() {
    return this->_pSchedulers->mainThread.dispatchUntilTaskCompletes(
        std::move(this->_task));
  }
 
  bool isReady() const { return this->_task.ready(); }
 
  SharedFuture<T> share() && {
    return SharedFuture<T>(this->_pSchedulers, this->_task.share());
  }
 
private:
  Future(
      const std::shared_ptr<CesiumImpl::AsyncSystemSchedulers>& pSchedulers,
      async::task<T>&& task) noexcept
      : _pSchedulers(pSchedulers), _task(std::move(task)) {}
 
  template <typename Func, typename Scheduler>
  CesiumImpl::ContinuationFutureType_t<Func, T> thenWithScheduler(
      Scheduler& scheduler,
      const char* tracingName,
      Func&& f) && {
    // It would be nice if tracingName were a template parameter instead of a
    // function parameter, but that triggers a bug in VS2017. It was previously
    // a bug in VS2019, too, but has been fixed there:
    // https://developercommunity.visualstudio.com/t/internal-compiler-error-when-compiling-a-template-1/534210
#if CESIUM_TRACING_ENABLED
    // When tracing is enabled, we measure the time between scheduling and
    // dispatching of the work.
    auto task = this->_task.then(
        async::inline_scheduler(),
        CesiumImpl::WithTracing<T>::begin(tracingName, std::forward<Func>(f)));
#else
    auto& task = this->_task;
#endif
 
    return CesiumImpl::ContinuationFutureType_t<Func, T>(
        this->_pSchedulers,
        task.then(
            scheduler,
            CesiumImpl::WithTracing<T>::end(
                tracingName,
                std::forward<Func>(f))));
  }
 
  template <typename Func, typename Scheduler>
  CesiumImpl::ContinuationFutureType_t<Func, std::exception>
  catchWithScheduler(Scheduler& scheduler, Func&& f) && {
    return CesiumImpl::ContinuationFutureType_t<Func, std::exception>(
        this->_pSchedulers,
        this->_task.then(
            async::inline_scheduler(),
            CesiumImpl::CatchFunction<Func, T, Scheduler>{
                scheduler,
                std::forward<Func>(f)}));
  }
 
  std::shared_ptr<CesiumImpl::AsyncSystemSchedulers> _pSchedulers;
  async::task<T> _task;
 
  friend class AsyncSystem;
 
  template <typename R> friend struct CesiumImpl::ParameterizedTaskUnwrapper;
 
  friend struct CesiumImpl::TaskUnwrapper;
 
  template <typename R> friend class Future;
  template <typename R> friend class SharedFuture;
  template <typename R> friend class Promise;
};
 
} // namespace CesiumAsync