SharedFuture.h

#pragma once
 
#include "Impl/AsyncSystemSchedulers.h"
#include "Impl/CatchFunction.h"
#include "Impl/ContinuationFutureType.h"
#include "Impl/WithTracing.h"
#include "ThreadPool.h"
 
#include <CesiumUtility/Tracing.h>
 
#include <type_traits>
#include <variant>
 
namespace CesiumAsync {
 
namespace CesiumImpl {
 
template <typename R> struct ParameterizedTaskUnwrapper;
struct TaskUnwrapper;
 
} // namespace CesiumImpl
 
template <typename T> class SharedFuture final {
public:
  template <typename Func>
  CesiumImpl::ContinuationFutureType_t<Func, T> thenInWorkerThread(Func&& f) {
    return 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 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::WithTracingShared<T>::end(
                nullptr,
                std::forward<Func>(f))));
  }
 
  template <typename Func>
  CesiumImpl::ContinuationFutureType_t<Func, T>
  thenInThreadPool(const ThreadPool& threadPool, Func&& f) {
    return this->thenWithScheduler(
        threadPool._pScheduler->immediate,
        "waiting for thread pool thread",
        std::forward<Func>(f));
  }
 
  template <typename Func> Future<T> catchInMainThread(Func&& f) {
    return this->catchWithScheduler(
        this->_pSchedulers->mainThread.immediate,
        std::forward<Func>(f));
  }
 
  template <typename Func> Future<T> catchImmediately(Func&& f) {
    return this->catchWithScheduler(
        async::inline_scheduler(),
        std::forward<Func>(f));
  }
 
  template <typename... TPassThrough>
  Future<std::tuple<TPassThrough..., T>>
  thenPassThrough(TPassThrough&&... values) {
    return this->thenImmediately(
        [values = std::tuple(std::forward<TPassThrough>(values)...)](
            const T& result) mutable {
          return std::tuple_cat(std::move(values), std::make_tuple(result));
        });
  }
 
  template <
      typename U = T,
      std::enable_if_t<std::is_same_v<U, T>, int> = 0,
      std::enable_if_t<!std::is_same_v<U, void>, int> = 0>
  const U& wait() const {
    return this->_task.get();
  }
 
  template <
      typename U = T,
      std::enable_if_t<std::is_same_v<U, T>, int> = 0,
      std::enable_if_t<std::is_same_v<U, void>, int> = 0>
  void wait() const {
    this->_task.get();
  }
 
  T waitInMainThread() {
    return this->_pSchedulers->mainThread.dispatchUntilTaskCompletes(
        std::move(this->_task));
  }
 
  bool isReady() const { return this->_task.ready(); }
 
private:
  SharedFuture(
      const std::shared_ptr<CesiumImpl::AsyncSystemSchedulers>& pSchedulers,
      async::shared_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::WithTracingShared<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::WithTracingShared<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, const async::shared_task<T>&>{
                    scheduler,
                    std::forward<Func>(f)}));
  }
 
  std::shared_ptr<CesiumImpl::AsyncSystemSchedulers> _pSchedulers;
  async::shared_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;
};
 
} // namespace CesiumAsync