Classes
| Class | |
|---|---|
| futures | Main library namespace. (namespace) |
| all_of_functor | Functor representing the overloads for the all_of function. (class) |
| always_deferred_opt | Future option to determine the future is always_deferred. (struct) |
| always_detached_opt | Future option to determine the future is always_detached. (struct) |
| any_of_functor | Functor representing the overloads for the any_of function. (class) |
| basic_future | A basic future type with custom features. (class) |
| binary_invoke_algorithm_functor | Binary algorithm overloads. (class) |
| broken_promise | The state owner got destroyed before the promise has been fulfilled. (class) |
| compare_three_way | Function object for performing comparisons. (struct) |
| continuable_opt | Future option to determine the future is continuable. (struct) |
| count_functor | Functor representing the overloads for the count function. (class) |
| count_if_functor | Functor representing the overloads for the count_if function. (class) |
| deferred_function_opt | Type of the deferred function. (struct) |
| equal_to | A C++17 functor equivalent to the C++20 std::ranges::equal_to. (struct) |
| error | Class for errors in the futures library. (class) |
| executor_opt | Future option to identify the executor to be used by a future. (struct) |
| find_functor | Functor representing the overloads for the find function. (class) |
| find_if_functor | Functor representing the overloads for the find_if function. (class) |
| find_if_not_functor | Functor representing the overloads for the find_if_not function. (class) |
| for_each_functor | Functor representing the overloads for the for_each function. (class) |
| future_already_retrieved | Attempted to retrieve a unique future twice. (class) |
| future_deferred | Invalid operation on deferred future. (class) |
| future_uninitialized | The future hasn't been initialized yet. (class) |
| greater | A C++17 functor equivalent to the C++20 std::ranges::greater. (struct) |
| greater_equal | A C++17 functor equivalent to the C++20 std::ranges::greater_equal. (struct) |
| halve_partitioner | A partitioner that always splits the problem in half. (class) |
| has_executor | Determine if a future type has an executor. (struct) |
| has_ready_notifier | Customization point to determine if a type has a ready notifier. (struct) |
| inline_executor | An executor that runs anything inline. (class) |
| is_always_deferred | Customization point to define a future as always deferred. (struct) |
| is_continuable | Customization point to define future as supporting continuations. (struct) |
| is_execution_policy | Determines whether T is a standard or implementation-defined execution policy type. (struct) |
| is_future_like | Customization point to determine if a type is a future type. (struct) |
| is_shared_future | Customization point to determine if a type is a shared future type. (struct) |
| less | A C++17 functor equivalent to the C++20 std::ranges::less. (struct) |
| less_equal | A C++17 functor equivalent to the C++20 std::ranges::less_equal. (struct) |
| new_thread_executor | An executor that runs anything in a new thread, like std::async does. (class) |
| no_state | There is no shared state we can access. (class) |
| none_of_functor | Functor representing the overloads for the none_of function. (class) |
| nostopstate_t | Empty struct to initialize a stop_source without a shared stop state. (struct) |
| not_equal_to | A C++17 functor equivalent to the C++20 std::ranges::not_equal_to. (struct) |
| packaged_task< R(Args...), Options > | A packaged task that sets a shared state when done. (class) |
| packaged_task_uninitialized | The packaged task hasn't been initialized yet. (class) |
| promise | A shared state that will later be acquired by a future type. (class) |
| promise_already_satisfied | Promise has already been fulfilled. (class) |
| promise_base | Common members to promises of all types. (class) |
| promise_uninitialized | The promised hasn't been initialized yet. (class) |
| reduce_functor | Functor representing the overloads for the reduce function. (class) |
| shared_opt | Future option to determine the future is shared. (struct) |
| stop_source | Object used to issue a stop request. (class) |
| stop_token | Token to check if a stop request has been made. (class) |
| stoppable_opt | Future option to determine the future is stoppable. (struct) |
| thread_partitioner | A partitioner that always splits the problem when moving to new threads. (class) |
| thread_pool | A thread pool with the specified number of threads. (class) |
| executor_type | A executor that sends tasks to the thread pool. (class) |
| unary_invoke_algorithm_functor | Overloads for unary invoke algorithms. (class) |
| value_cmp_algorithm_functor | Value-compare algorithm overloads. (class) |
| when_all_future | Proxy future class referring to a conjunction of futures from when_all. (class) |
| when_any_future | Future object referring to the result of a disjunction of futures. (class) |
| when_any_result | Result type for when_any_future objects. (struct) |
Updated on 2023-01-04