async_results.h

Go to the documentation of this file.

// Copyright 2018 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef SHAKA_EMBEDDED_ASYNC_RESULTS_H_
#define SHAKA_EMBEDDED_ASYNC_RESULTS_H_

#include <chrono>
#include <future>
#include <type_traits>

#include "error.h"
#include "variant.h"

namespace shaka {

template <typename T>
class AsyncResults final {
 public:
  using result_type = typename std::conditional<std::is_same<T, void>::value,
                                                monostate, T>::type;
  using variant_type = variant<result_type, Error>;

  AsyncResults() {}

  AsyncResults(std::shared_future<variant_type> future) : future_(future) {}

  ~AsyncResults() {
    if (future_.valid())
      future_.wait();
  }

  // \cond Doxygen_Skip
  AsyncResults(AsyncResults&&) = default;
  AsyncResults& operator=(AsyncResults&&) = default;
  AsyncResults(const AsyncResults&) = delete;
  AsyncResults& operator=(const AsyncResults&) = delete;
  // \endcond


  bool valid() const {
    return future_.valid();
  }

  void wait() {
    future_.wait();
  }

  template <typename Rep, typename Period>
  std::future_status wait_for(
      const std::chrono::duration<Rep, Period>& timeout_duration) const {
    return future_.wait_for(timeout_duration);
  }

  template <typename Clock, typename Duration>
  std::future_status wait_until(
      std::chrono::time_point<Clock, Duration>& timeout_time) const {
    return future_.wait_until(timeout_time);
  }


  bool has_error() const {
    return holds_alternative<Error>(future_.get());
  }

  template <typename U = T, typename = typename std::enable_if<
                                !std::is_same<U, void>::value>::type>
  const U& results() const {
    return get<T>(future_.get());
  }

  const Error& error() const {
    return get<Error>(future_.get());
  }

 private:
  std::shared_future<variant_type> future_;
};

}  // namespace shaka

#endif  // SHAKA_EMBEDDED_ASYNC_RESULTS_H_