Outcome 2.2 library documentation

☰
  • Outcome 2.2 github repo
  • Acknowledgements
    • Prerequisites
    • Build and install
    • Review of Error Handling Frameworks
      • std exception throws
      • std error codes
      • std expected
      • Outcome (proposed std result)
      • LEAF
    • Motivation
      • Exceptions
      • errno
      • Error codes
      • std::error_code
      • Plugging a library into std::error_code
      • Plugging a library into boost::system::error_code
      • Narrow contracts
    • Future ABI stability guarantees
    • Tutorial
      • Essential
        • Before we begin
        • result<>
          • Inspecting result
          • TRY operations
          • TRY is greedy
          • TRY avoiding copy/move
        • outcome<>
          • Inspecting outcome
        • No-value policies
          • A custom no-value policy
          • Built-in policies
        • Coroutines
          • Coroutine TRY operation
          • Coroutine awaitables
          • Returning Outcome types from Coroutines
          • operator co_await as TRY operator
        • Conventions
      • Advanced
        • Custom payloads
          • The Filesystem TS
          • Upgrading the Filesystem TS
          • Auto-throwing filesystem_error
        • Result returning constructors
          • Two phase construction
          • A file handle
          • Phase 2 construction
          • Phase 3
          • construct
          • Alternatives
        • Hooking events
          • Keeping state
          • ADL bridging
          • Hook result
          • Custom exception ptr
          • Hook outcome
        • Interoperation
          • Incommensurate E types
          • value_or_error Concept
          • The HTTP library
          • The HTMLTidy library
          • The File I/O library
          • The Application
          • Mapping the HTTP library into the Application 1/2
          • Mapping the HTTP library into the Application 2/2
          • Mapping the File I/O library into the Application
          • Mapping the HTMLTidy library into the Application
          • In use
          • Conclusion
    • Recipes
      • ASIO/Networking TS : Boost < 1.70
      • ASIO/Networking TS: Boost >= 1.70
      • Extending OUTCOME_TRY
    • Experimental
      • The main advantages
      • Approximate map between error code designs
      • Major differences
      • status_result and status_outcome
      • Worked example: Custom domain
        • Define a custom code domain
        • The payload
        • The constructor
        • String refs
        • Redefining message()
        • Constexpr domain source
        • Implicit conversion
      • Tying it all together
      • Using Outcome from C code
        • Limitations
        • Example C++ function
        • Calling it from C
        • C Macro API Reference
    • API reference
      • Macros
        • Constrained template macros
        • Version macros
        • OUTCOME_CO_TRY(var, expr)
        • OUTCOME_CO_TRYV(expr)/OUTCOME_CO_TRY(expr)
        • OUTCOME_CO_TRYV2(spec, expr)
        • OUTCOME_CO_TRYV2_FAILURE_LIKELY(spec, expr)
        • OUTCOME_CO_TRYV_FAILURE_LIKELY(expr)/OUTCOME_CO_TRY_FAILURE_LIKELY(expr)
        • OUTCOME_CO_TRYX(expr)
        • OUTCOME_CO_TRYX_FAILURE_LIKELY(expr)
        • OUTCOME_CO_TRY_FAILURE_LIKELY(var, expr)
        • OUTCOME_DISABLE_EXECINFO
        • OUTCOME_ENABLE_LEGACY_SUPPORT_FOR
        • OUTCOME_NODISCARD
        • OUTCOME_REQUIRES(...)
        • OUTCOME_SYMBOL_VISIBLE
        • OUTCOME_THREAD_LOCAL
        • OUTCOME_THROW_EXCEPTION(expr)
        • OUTCOME_TRY(var, expr)
        • OUTCOME_TRYV(expr)/OUTCOME_TRY(expr)
        • OUTCOME_TRYV2(spec, expr)
        • OUTCOME_TRYV2_FAILURE_LIKELY(spec, expr)
        • OUTCOME_TRYV_FAILURE_LIKELY(expr)/OUTCOME_TRY_FAILURE_LIKELY(expr)
        • OUTCOME_TRYX(expr)
        • OUTCOME_TRYX_FAILURE_LIKELY(expr)
        • OUTCOME_TRY_FAILURE_LIKELY(var, expr)
        • OUTCOME_USE_STD_IN_PLACE_TYPE
        • OUTCOME_USE_STD_IS_NOTHROW_SWAPPABLE
      • Concepts
        • basic_outcome<T>
        • basic_result<T>
        • value_or_error<T>
        • value_or_none<T>
      • Converters
        • value_or_error<T, U>
      • Traits
        • is_basic_outcome<T>
        • is_basic_result<T>
        • is_error_code_available<T>
        • is_error_type<E>
        • is_error_type_enum<E, Enum>
        • is_exception_ptr_available<T>
        • is_failure_type<T>
        • is_move_bitcopying<T>
        • is_success_type<T>
        • type_can_be_used_in_basic_result<R>
      • Policies
        • base
          • static void _ub(Impl &&)
          • static bool _has_value(Impl &&) noexcept
          • static bool _has_error(Impl &&) noexcept
          • static bool _has_exception(Impl &&) noexcept
          • static bool _has_error_is_errno(Impl &&) noexcept
          • static auto &&_value(Impl &&) noexcept
          • static auto &&_error(Impl &&) noexcept
          • static auto &&_exception(Impl &&) noexcept
          • static void _set_has_value(Impl &&, bool) noexcept
          • static void _set_has_error(Impl &&, bool) noexcept
          • static void _set_has_exception(Impl &&, bool) noexcept
          • static void _set_has_exception(Impl &&, bool) noexcept
          • static void narrow_value_check(Impl &&) noexcept
          • static void narrow_error_check(Impl &&) noexcept
          • static void narrow_exception_check(Impl &&) noexcept
          • static void on_outcome_construction(T *, U &&) noexcept
          • static void on_outcome_construction(T *, U &&, V &&) noexcept
          • static void on_outcome_copy_construction(T *, U &&) noexcept
          • static void on_outcome_copy_construction(T *, U &&, V &&) noexcept
          • static void on_outcome_in_place_construction(T *, in_place_type_t<U>, Args &&...) noexcept
          • static void on_outcome_move_construction(T *, U &&) noexcept
          • static void on_outcome_move_construction(T *, U &&, V &&) noexcept
          • static void on_result_construction(T *, U &&) noexcept
          • static void on_result_copy_construction(T *, U &&) noexcept
          • static void on_result_in_place_construction(T *, in_place_type_t<U>, Args &&...) noexcept
          • static void on_result_move_construction(T *, U &&) noexcept
        • all_narrow
        • error_code_throw_as_system_error<T, EC, EP>
        • error_code_throw_as_system_error<T, EC, void>
        • exception_ptr_rethrow<T, EC, EP>
        • exception_ptr_rethrow<T, EC, void>
        • fail_to_compile_observers
        • terminate
        • throw_bad_result_access<EC>
      • Types
        • basic_outcome<T, EC, EP, NoValuePolicy>
          • basic_outcome() = delete
          • basic_outcome(basic_outcome &&)
          • basic_outcome(const basic_outcome &)
          • basic_outcome &operator=(basic_outcome &&)
          • basic_outcome &operator=(const basic_outcome &)
          • ~basic_outcome()
          • basic_outcome(Args...) = delete
          • basic_outcome(X &&) = delete
          • basic_outcome(R &&)
          • basic_outcome(S &&)
          • basic_outcome(ErrorCondEnum &&)
          • basic_outcome(P &&)
          • basic_outcome(S &&, P &&)
          • explicit basic_outcome(concepts::value_or_error<T, E> &&)
          • explicit basic_outcome(const basic_outcome<A, B, C, D> &)
          • explicit basic_outcome(basic_outcome<A, B, C, D> &&)
          • explicit basic_outcome(const basic_result<A, B, C> &)
          • explicit basic_outcome(basic_result<A, B, C> &&)
          • explicit basic_outcome(const basic_result<A, B, C> &)
          • explicit basic_outcome(basic_result<A, B, C> &&)
          • explicit basic_outcome(in_place_type_t<value_type_if_enabled>, Args ...)
          • explicit basic_outcome(in_place_type_t<value_type_if_enabled>, std::initializer_list<U>, Args ...)
          • explicit basic_outcome(in_place_type_t<error_type_if_enabled>, Args ...)
          • explicit basic_outcome(in_place_type_t<error_type_if_enabled>, std::initializer_list<U>, Args ...)
          • explicit basic_outcome(in_place_type_t<exception_type_if_enabled>, Args ...)
          • explicit basic_outcome(in_place_type_t<exception_type_if_enabled>, std::initializer_list<U>, Args ...)
          • basic_outcome(A1 &&, A2 &&, Args ...)
          • basic_outcome(const success_type<T> &)
          • basic_outcome(success_type<T> &&)
          • basic_outcome(const failure_type<EC> &)
          • basic_outcome(failure_type<EC> &&)
          • basic_outcome(const failure_type<EC> &)
          • basic_outcome(failure_type<EC> &&)
          • basic_outcome(const failure_type<EP> &)
          • basic_outcome(failure_type<EP> &&)
          • basic_outcome(const failure_type<EC, EP> &)
          • basic_outcome(failure_type<EC, EP> &&)
          • explicit operator bool() const noexcept
          • bool has_value() const noexcept
          • bool has_error() const noexcept
          • bool has_exception() const noexcept
          • bool has_failure() const noexcept
          • value_type &assume_value() & noexcept
          • const value_type &assume_value() const & noexcept
          • value_type &&assume_value() && noexcept
          • const value_type &&assume_value() const && noexcept
          • value_type &value() &
          • const value_type &value() const &
          • value_type &&value() &&
          • const value_type &&value() const &&
          • error_type &assume_error() & noexcept
          • const error_type &assume_error() const & noexcept
          • error_type &&assume_error() && noexcept
          • const error_type &&assume_error() const && noexcept
          • error_type &error() &
          • const error_type &error() const &
          • error_type &&error() &&
          • const error_type &&error() const &&
          • exception_type &assume_exception() & noexcept
          • const exception_type &assume_exception() const & noexcept
          • const exception_type &&assume_exception() const && noexcept
          • exception_type &&assume_exception() && noexcept
          • exception_type &exception() &
          • const exception_type &exception() const &
          • exception_type &&exception() &&
          • const exception_type &&exception() const &&
          • exception_type failure() const noexcept
          • bool operator==(const basic_result<A, B, C> &) const
          • bool operator==(const basic_outcome<A, B, C, D> &) const
          • bool operator==(const success_type<A> &) const
          • bool operator==(const failure_type<A, B> &) const
          • bool operator!=(const basic_result<A, B, C> &) const
          • bool operator!=(const basic_outcome<A, B, C, D> &) const
          • bool operator!=(const success_type<A> &) const
          • bool operator!=(const failure_type<A, B> &) const
          • void swap(basic_outcome &)
          • failure_type<error_type, exception_type> as_failure() const &
          • failure_type<error_type, exception_type> as_failure() &&
        • basic_result<T, E, NoValuePolicy>
          • basic_result() = delete
          • basic_result(basic_result &&)
          • basic_result(const basic_result &)
          • basic_result &operator=(basic_result &&)
          • basic_result &operator=(const basic_result &)
          • ~basic_result()
          • basic_result(Args...) = delete
          • basic_result(X &&) = delete
          • basic_result(R &&)
          • basic_result(S &&)
          • basic_result(ErrorCondEnum &&)
          • explicit basic_result(concepts::value_or_error<T, E> &&)
          • explicit basic_result(const basic_result<R, S, P> &)
          • explicit basic_result(basic_result<R, S, P> &&)
          • explicit basic_result(const basic_result<R, S, P> &)
          • explicit basic_result(basic_result<R, S, P> &&)
          • explicit basic_result(const basic_result<R, S, P> &)
          • explicit basic_result(basic_result<R, S, P> &&)
          • explicit basic_result(in_place_type_t<value_type_if_enabled>, Args ...)
          • explicit basic_result(in_place_type_t<value_type_if_enabled>, std::initializer_list<U>, Args ...)
          • explicit basic_result(in_place_type_t<error_type_if_enabled>, Args ...)
          • explicit basic_result(in_place_type_t<error_type_if_enabled>, std::initializer_list<U>, Args ...)
          • basic_result(A1 &&, A2 &&, Args ...)
          • basic_result(const success_type<T> &)
          • basic_result(success_type<T> &&)
          • basic_result(const failure_type<T> &)
          • basic_result(failure_type<T> &&)
          • basic_result(const failure_type<T> &)
          • basic_result(failure_type<T> &&)
          • basic_result(const failure_type<T> &)
          • basic_result(failure_type<T> &&)
          • explicit operator bool() const noexcept
          • bool has_value() const noexcept
          • bool has_error() const noexcept
          • bool has_exception() const noexcept
          • bool has_failure() const noexcept
          • bool has_lost_consistency() const noexcept
          • value_type &assume_value() & noexcept
          • const value_type &assume_value() const & noexcept
          • value_type &&assume_value() && noexcept
          • const value_type &&assume_value() const && noexcept
          • value_type &value() &
          • const value_type &value() const &
          • value_type &&value() &&
          • const value_type &&value() const &&
          • error_type &assume_error() & noexcept
          • const error_type &assume_error() const & noexcept
          • error_type &&assume_error() && noexcept
          • const error_type &&assume_error() const && noexcept
          • error_type &error() &
          • const error_type &error() const &
          • error_type &&error() &&
          • const error_type &&error() const &&
          • bool operator==(const basic_result<A, B, C> &) const
          • bool operator==(const success_type<A> &) const
          • bool operator==(const failure_type<A, void> &) const
          • bool operator!=(const basic_result<A, B, C> &) const
          • bool operator!=(const success_type<A> &) const
          • bool operator!=(const failure_type<A, void> &) const
          • void swap(basic_result &)
          • auto as_failure() const &
          • auto as_failure() &&
        • bad_outcome_access
        • bad_result_access_with<EC>
        • bad_result_access
        • eager<T, Executor = void>/atomic_eager<T, Executor = void>
        • failure_type<EC, EP = void>
        • generator<T, Executor = void>
        • in_place_type_t<T>
        • lazy<T, Executor = void>/atomic_lazy<T, Executor = void>
        • success_type<T>
      • Aliases
        • boost_checked<T, E = boost::system::error_code>
        • boost_outcome<T, EC = boost::system::error_code, EP = boost::exception_ptr, NoValuePolicy = policy::default_policy<T, EC, EP>>
        • boost_result<T, E = boost::system::error_code, NoValuePolicy = policy::default_policy<T, E, void>>
        • boost_unchecked<T, E = boost::system::error_code>
        • checked<T, E = varies>
        • default_policy<T, EC, EP>
        • outcome<T, EC = varies, EP = varies, NoValuePolicy = policy::default_policy<T, EC, EP>>
        • result<T, E = varies, NoValuePolicy = policy::default_policy<T, E, void>>
        • std_checked<T, E = std::error_code>
        • std_outcome<T, EC = std::error_code, EP = std::exception_ptr, NoValuePolicy = policy::default_policy<T, EC, EP>>
        • std_result<T, E = std::error_code, NoValuePolicy = policy::default_policy<T, E, void>>
        • std_unchecked<T, E = std::error_code>
        • unchecked<T, E = varies>
      • Functions
        • Hooks
          • uint16_t spare_storage(const basic_result|basic_outcome *) noexcept
          • void hook_outcome_construction(T *, U &&) noexcept
          • void hook_outcome_construction(T *, U &&, V &&) noexcept
          • void hook_outcome_copy_construction(T *, U &&) noexcept
          • void hook_outcome_copy_construction(T *, U &&, V &&) noexcept
          • void hook_outcome_in_place_construction(T *, in_place_type_t<U>, Args &&...) noexcept
          • void hook_outcome_move_construction(T *, U &&) noexcept
          • void hook_outcome_move_construction(T *, U &&, V &&) noexcept
          • void hook_result_construction(T *, U &&) noexcept
          • void hook_result_copy_construction(T *, U &&) noexcept
          • void hook_result_in_place_construction(T *, in_place_type_t<U>, Args &&...) noexcept
          • void hook_result_move_construction(T *, U &&) noexcept
          • void override_outcome_exception(basic_outcome<T, EC, EP, NoValuePolicy> *, U &&) noexcept
          • void set_spare_storage(basic_result|basic_outcome *, uint16_t) noexcept
        • Iostream
          • std::istream &operator>>(std::istream &, basic_outcome<T, EC, EP, NoValuePolicy> &)
          • std::istream &operator>>(std::istream &, basic_result<T, E, NoValuePolicy> &)
          • std::ostream &operator<<(std::ostream &, const basic_outcome<T, EC, EP, NoValuePolicy> &)
          • std::ostream &operator<<(std::ostream &, const basic_result<T, E, NoValuePolicy> &)
          • std::string print(const basic_outcome<T, EC, EP, NoValuePolicy> &)
          • std::string print(const basic_result<T, E, NoValuePolicy> &)
        • Policy
          • auto basic_outcome_failure_exception_from_error(const EC &)
          • decltype(auto) error_code(T &&)
          • decltype(auto) exception_ptr(T &&)
          • void outcome_throw_as_system_error_with_payload(BoostErrorCodeEnum &&)
          • void outcome_throw_as_system_error_with_payload(ErrorCodeEnum &&)
          • void outcome_throw_as_system_error_with_payload(const boost::system::error_code &)
          • void outcome_throw_as_system_error_with_payload(const std::error_code &)
        • auto failure(T &&, ...)
        • auto success(T &&, ...)
        • bool try_operation_has_value(X)
        • decltype(auto) try_operation_extract_value(X)
        • decltype(auto) try_operation_return_as(X)
        • std::error_code error_from_exception(std::exception_ptr &&ep = std::current_exception(), std::error_code not_matched = std::make_error_code(std::errc::resource_unavailable_try_again)) noexcept
        • void strong_swap(bool &all_good, T &a, T &b)
        • void try_throw_std_exception_from_error(std::error_code ec, const std::string &msg = std::string{})
    • Frequently asked questions
    • Videos
    • Changelog
      • Upgrade guide v2.1 => v2.2
      • v2.2 major changes
    • History
    Navigation :

    Improve this page