future.h

Go to the documentation of this file.

// Copyright 2019 Age of Minds inc.

// 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
//
//     http://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 AOM_VARIADIC_FUTURE_INCLUDED_H
#define AOM_VARIADIC_FUTURE_INCLUDED_H


#include "var_future/config.h"
#include "var_future/impl/storage_decl.h"

#include <memory>
#include <string>

namespace aom {

template <typename Alloc, typename... Ts>
class Basic_promise;

template <typename Alloc, typename... Ts>
class Basic_future {
  static_assert(sizeof...(Ts) >= 1, "you probably meant Future<void>");

 public:
  using promise_type = Basic_promise<Alloc, Ts...>;

  using storage_type = detail::Future_storage<Alloc, Ts...>;

  using allocator_type = Alloc;

  using value_type = detail::future_value_type_t<Ts...>;
  using fullfill_type = detail::fullfill_type_t<Ts...>;
  using finish_type = detail::finish_type_t<Ts...>;

  Basic_future() = default;

  Basic_future(Basic_future&& rhs) = default;

  Basic_future& operator=(Basic_future&& rhs) = default;

  template <typename CbT>
  [[nodiscard]] auto then(CbT&& callback);

  template <typename QueueT, typename CbT>
  [[nodiscard]] auto then(QueueT& queue, CbT&& callback);

  template <typename CbT>
  [[nodiscard]] auto then_expect(CbT&& callback);

  template <typename QueueT, typename CbT>
  [[nodiscard]] auto then_expect(QueueT& queue, CbT&& callback);

  template <typename CbT>
  void finally(CbT&& callback);

  template <typename QueueT, typename CbT>
  void finally(QueueT& queue, CbT&& callback);

  value_type get();

  auto std_future();

  allocator_type& allocator();

  explicit Basic_future(detail::Storage_ptr<storage_type> s);

 private:
  detail::Storage_ptr<storage_type> storage_;
};

template <typename... Ts>
using Future = Basic_future<std::allocator<void>, Ts...>;

struct Unfullfilled_promise : public std::logic_error {
  Unfullfilled_promise() : std::logic_error("Unfullfilled_promise") {}
};

template <typename Alloc, typename... Ts>
class Basic_promise {
  static_assert(sizeof...(Ts) >= 1, "you probably meant Promise<void>");

 public:
  using future_type = Basic_future<Alloc, Ts...>;
  using storage_type = typename future_type::storage_type;

  using value_type = detail::future_value_type_t<Ts...>;

  using fullfill_type = detail::fullfill_type_t<Ts...>;
  using finish_type = detail::finish_type_t<Ts...>;
  using fail_type = detail::fail_type_t<Ts...>;

  Basic_promise(const Alloc& alloc = Alloc());
  Basic_promise(Basic_promise&&) = default;
  Basic_promise& operator=(Basic_promise&&) = default;
  ~Basic_promise();

  future_type get_future();

  template <typename... Us>
  void set_value(Us&&... values);

  template <typename... Us>
  void finish(Us&&... expecteds);

  void set_exception(fail_type error);

  operator bool() const;

 private:
  bool future_created_ = false;
  bool value_assigned_ = false;

  detail::Storage_ptr<storage_type> storage_;

  Basic_promise(const Basic_promise&) = delete;
  Basic_promise& operator=(const Basic_promise&) = delete;
};

template <typename... Ts>
using Promise = Basic_promise<std::allocator<void>, Ts...>;
template <typename... FutTs>
auto join(FutTs&&... futures);

// Convenience function that creates a promise for the result of the cb, pushes
// cb in q, and returns a future to that promise.

template <typename QueueT, typename CbT>
auto async(QueueT& q, CbT&& callback);

template <typename Alloc, typename... Ts>
Basic_future<Alloc, Ts...> flatten(Basic_future<Alloc, std::tuple<Ts...>>& rhs);

template <typename... Ts>
auto segmented(Ts&&... args);

inline std::string varfut_lib_version_string();
}  // namespace aom

#include "var_future/impl/async.h"
#include "var_future/impl/future.h"
#include "var_future/impl/join.h"
#include "var_future/impl/promise.h"
#include "var_future/impl/storage_impl.h"

#endif