//
BOOST_OUTCOME_REQUIRES(trait::type_can_be_used_in_basic_result && (std::is_void
::value || std::is_default_constructible
::value)) //
class basic_outcome;
namespace detail
{
// May be reused by basic_outcome subclasses to save load on the compiler
template struct outcome_predicates
{
using result = result_predicates;
// Predicate for the implicit constructors to be available
static constexpr bool implicit_constructors_enabled = //
result::implicit_constructors_enabled //
&& !detail::is_implicitly_constructible //
&& !detail::is_implicitly_constructible //
&& !detail::is_implicitly_constructible //
&& !detail::is_implicitly_constructible;
// Predicate for the value converting constructor to be available.
template
static constexpr bool enable_value_converting_constructor = //
implicit_constructors_enabled //
&&result::template enable_value_converting_constructor //
&& !detail::is_implicitly_constructible; // deliberately less tolerant of ambiguity than result's edition
// Predicate for the error converting constructor to be available.
template
static constexpr bool enable_error_converting_constructor = //
implicit_constructors_enabled //
&&result::template enable_error_converting_constructor //
&& !detail::is_implicitly_constructible; // deliberately less tolerant of ambiguity than result's edition
// Predicate for the error condition converting constructor to be available.
template
static constexpr bool enable_error_condition_converting_constructor = result::template enable_error_condition_converting_constructor //
&& !detail::is_implicitly_constructible;
// Predicate for the exception converting constructor to be available.
template
static constexpr bool enable_exception_converting_constructor = //
implicit_constructors_enabled //
&& !is_in_place_type_t>::value // not in place construction
&& !detail::is_implicitly_constructible && !detail::is_implicitly_constructible && detail::is_implicitly_constructible;
// Predicate for the error + exception converting constructor to be available.
template
static constexpr bool enable_error_exception_converting_constructor = //
implicit_constructors_enabled //
&& !is_in_place_type_t>::value // not in place construction
&& !detail::is_implicitly_constructible && detail::is_implicitly_constructible //
&& !detail::is_implicitly_constructible && detail::is_implicitly_constructible;
// Predicate for the converting copy constructor from a compatible outcome to be available.
template
static constexpr bool enable_compatible_conversion = //
(std::is_void::value || detail::is_explicitly_constructible::value_type>) // if our value types are constructible
&&(std::is_void::value || detail::is_explicitly_constructible::error_type>) // if our error types are constructible
&&(std::is_void::value || detail::is_explicitly_constructible::exception_type>) // if our exception types are constructible
;
// Predicate for the converting constructor from a make_error_code() of the input to be available.
template
static constexpr bool enable_make_error_code_compatible_conversion = //
trait::is_error_code_available>::value // if error type has an error code
&& !enable_compatible_conversion // and the normal compatible conversion is not available
&& (std::is_void::value || detail::is_explicitly_constructible::value_type>) // and if our value types are constructible
&&detail::is_explicitly_constructible::type> // and our error type is constructible from a make_error_code()
&& (std::is_void::value || detail::is_explicitly_constructible::exception_type>); // and our exception types are constructible
// Predicate for the implicit converting inplace constructor from a compatible input to be available.
struct disable_inplace_value_error_exception_constructor;
template
using choose_inplace_value_error_exception_constructor = std::conditional_t< //
((static_cast(std::is_constructible::value) + static_cast(std::is_constructible::value) + static_cast(std::is_constructible::value)) > 1), //
disable_inplace_value_error_exception_constructor, //
std::conditional_t< //
std::is_constructible::value, //
value_type, //
std::conditional_t< //
std::is_constructible::value, //
error_type, //
std::conditional_t< //
std::is_constructible::value, //
exception_type, //
disable_inplace_value_error_exception_constructor>>>>;
template
static constexpr bool enable_inplace_value_error_exception_constructor = //
implicit_constructors_enabled && !std::is_same, disable_inplace_value_error_exception_constructor>::value;
};
// Select whether to use basic_outcome_failure_observers or not
template
using select_basic_outcome_failure_observers = //
std::conditional_t::value && trait::is_exception_ptr_available::value, basic_outcome_failure_observers, Base>;
template constexpr inline const V &extract_exception_from_failure(const failure_type &v) { return v.exception(); }
template constexpr inline V &&extract_exception_from_failure(failure_type &&v) { return static_cast &&>(v).exception(); }
template constexpr inline const U &extract_exception_from_failure(const failure_type &v) { return v.error(); }
template constexpr inline U &&extract_exception_from_failure(failure_type &&v) { return static_cast &&>(v).error(); }
template struct is_basic_outcome
{
static constexpr bool value = false;
};
template struct is_basic_outcome>
{
static constexpr bool value = true;
};
} // namespace detail
/*! AWAITING HUGO JSON CONVERSION TOOL
type alias template is_basic_outcome. Potential doc page: `is_basic_outcome`
*/
template using is_basic_outcome = detail::is_basic_outcome>;
/*! AWAITING HUGO JSON CONVERSION TOOL
SIGNATURE NOT RECOGNISED
*/
template static constexpr bool is_basic_outcome_v = detail::is_basic_outcome>::value;
namespace hooks
{
/*! AWAITING HUGO JSON CONVERSION TOOL
SIGNATURE NOT RECOGNISED
*/
template constexpr inline void hook_outcome_construction(T * /*unused*/, U &&... /*unused*/) noexcept {}
/*! AWAITING HUGO JSON CONVERSION TOOL
SIGNATURE NOT RECOGNISED
*/
template constexpr inline void hook_outcome_copy_construction(T * /*unused*/, U && /*unused*/) noexcept {}
/*! AWAITING HUGO JSON CONVERSION TOOL
SIGNATURE NOT RECOGNISED
*/
template constexpr inline void hook_outcome_move_construction(T * /*unused*/, U && /*unused*/) noexcept {}
/*! AWAITING HUGO JSON CONVERSION TOOL
SIGNATURE NOT RECOGNISED
*/
template constexpr inline void hook_outcome_in_place_construction(T * /*unused*/, in_place_type_t /*unused*/, Args &&... /*unused*/) noexcept {}
/*! AWAITING HUGO JSON CONVERSION TOOL
SIGNATURE NOT RECOGNISED
*/
template constexpr inline void override_outcome_exception(basic_outcome *o, U &&v) noexcept;
} // namespace hooks
/*! AWAITING HUGO JSON CONVERSION TOOL
type definition template basic_outcome. Potential doc page: `basic_outcome`
*/
template //
BOOST_OUTCOME_REQUIRES(trait::type_can_be_used_in_basic_result && (std::is_void
::value || std::is_default_constructible
::value)) //
class BOOST_OUTCOME_NODISCARD basic_outcome
#if defined(BOOST_OUTCOME_DOXYGEN_IS_IN_THE_HOUSE) || defined(BOOST_OUTCOME_STANDARDESE_IS_IN_THE_HOUSE)
: public detail::basic_outcome_failure_observers, R, S, P, NoValuePolicy>,
public detail::basic_outcome_exception_observers, R, S, P, NoValuePolicy>,
public detail::basic_result_final
#else
: public detail::select_basic_outcome_failure_observers, R, S, P, NoValuePolicy>, R, S, P, NoValuePolicy>
#endif
{
static_assert(trait::type_can_be_used_in_basic_result, "The exception_type cannot be used");
static_assert(std::is_void
::value || std::is_default_constructible
::value, "exception_type must be void or default constructible");
using base = detail::select_basic_outcome_failure_observers, R, S, P, NoValuePolicy>, R, S, P, NoValuePolicy>;
friend struct policy::base;
template //
BOOST_OUTCOME_REQUIRES(trait::type_can_be_used_in_basic_result && (std::is_void::value || std::is_default_constructible::value)) //
friend class basic_outcome;
template friend constexpr inline void hooks::override_outcome_exception(basic_outcome *o, X &&v) noexcept; // NOLINT
struct implicit_constructors_disabled_tag
{
};
struct value_converting_constructor_tag
{
};
struct error_converting_constructor_tag
{
};
struct error_condition_converting_constructor_tag
{
};
struct exception_converting_constructor_tag
{
};
struct error_exception_converting_constructor_tag
{
};
struct explicit_valueorerror_converting_constructor_tag
{
};
struct explicit_compatible_copy_conversion_tag
{
};
struct explicit_compatible_move_conversion_tag
{
};
struct explicit_make_error_code_compatible_copy_conversion_tag
{
};
struct explicit_make_error_code_compatible_move_conversion_tag
{
};
struct error_failure_tag
{
};
struct exception_failure_tag
{
};
struct disable_in_place_value_type
{
};
struct disable_in_place_error_type
{
};
struct disable_in_place_exception_type
{
};
public:
using value_type = R;
using error_type = S;
using exception_type = P;
template using rebind = basic_outcome;
protected:
// Requirement predicates for outcome.
struct predicate
{
using base = detail::outcome_predicates;
// Predicate for any constructors to be available at all
static constexpr bool constructors_enabled = (!std::is_same, std::decay_t>::value || (std::is_void::value && std::is_void::value)) //
&& (!std::is_same, std::decay_t>::value || (std::is_void::value && std::is_void::value)) //
&& (!std::is_same, std::decay_t>::value || (std::is_void::value && std::is_void::value)) //
;
// Predicate for implicit constructors to be available at all
static constexpr bool implicit_constructors_enabled = constructors_enabled && base::implicit_constructors_enabled;
// Predicate for the value converting constructor to be available.
template
static constexpr bool enable_value_converting_constructor = //
constructors_enabled //
&& !std::is_same, basic_outcome>::value // not my type
&& base::template enable_value_converting_constructor;
// Predicate for the error converting constructor to be available.
template
static constexpr bool enable_error_converting_constructor = //
constructors_enabled //
&& !std::is_same, basic_outcome>::value // not my type
&& base::template enable_error_converting_constructor;
// Predicate for the error condition converting constructor to be available.
template
static constexpr bool enable_error_condition_converting_constructor = //
constructors_enabled //
&& !std::is_same, basic_outcome>::value // not my type
&& base::template enable_error_condition_converting_constructor;
// Predicate for the exception converting constructor to be available.
template
static constexpr bool enable_exception_converting_constructor = //
constructors_enabled //
&& !std::is_same, basic_outcome>::value // not my type
&& base::template enable_exception_converting_constructor;
// Predicate for the error + exception converting constructor to be available.
template
static constexpr bool enable_error_exception_converting_constructor = //
constructors_enabled //
&& !std::is_same, basic_outcome>::value // not my type
&& base::template enable_error_exception_converting_constructor;
// Predicate for the converting constructor from a compatible input to be available.
template
static constexpr bool enable_compatible_conversion = //
constructors_enabled //
&& !std::is_same, basic_outcome>::value // not my type
&& base::template enable_compatible_conversion;
// Predicate for the converting constructor from a make_error_code() of the input to be available.
template
static constexpr bool enable_make_error_code_compatible_conversion = //
constructors_enabled //
&& !std::is_same, basic_outcome>::value // not my type
&& base::template enable_make_error_code_compatible_conversion;
// Predicate for the inplace construction of value to be available.
template
static constexpr bool enable_inplace_value_constructor = //
constructors_enabled //
&& (std::is_void::value //
|| std::is_constructible::value);
// Predicate for the inplace construction of error to be available.
template
static constexpr bool enable_inplace_error_constructor = //
constructors_enabled //
&& (std::is_void::value //
|| std::is_constructible::value);
// Predicate for the inplace construction of exception to be available.
template
static constexpr bool enable_inplace_exception_constructor = //
constructors_enabled //
&& (std::is_void::value //
|| std::is_constructible::value);
// Predicate for the implicit converting inplace constructor to be available.
template
static constexpr bool enable_inplace_value_error_exception_constructor = //
constructors_enabled //
&&base::template enable_inplace_value_error_exception_constructor;
template using choose_inplace_value_error_exception_constructor = typename base::template choose_inplace_value_error_exception_constructor;
};
public:
using value_type_if_enabled = std::conditional_t::value || std::is_same::value, disable_in_place_value_type, value_type>;
using error_type_if_enabled = std::conditional_t::value || std::is_same::value, disable_in_place_error_type, error_type>;
using exception_type_if_enabled = std::conditional_t::value || std::is_same::value, disable_in_place_exception_type, exception_type>;
protected:
detail::devoid _ptr;
public:
/*! AWAITING HUGO JSON CONVERSION TOOL
SIGNATURE NOT RECOGNISED
*/
BOOST_OUTCOME_TEMPLATE(class Arg, class... Args)
BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED((!predicate::constructors_enabled && sizeof...(Args) >= 0)))
basic_outcome(Arg && /*unused*/, Args &&... /*unused*/) = delete; // NOLINT basic_outcome<> with any of the same type is NOT SUPPORTED, see docs!
/*! AWAITING HUGO JSON CONVERSION TOOL
SIGNATURE NOT RECOGNISED
*/
BOOST_OUTCOME_TEMPLATE(class T)
BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED((predicate::constructors_enabled && !predicate::implicit_constructors_enabled //
&& (detail::is_implicitly_constructible || detail::is_implicitly_constructible || detail::is_implicitly_constructible) )))
basic_outcome(T && /*unused*/, implicit_constructors_disabled_tag /*unused*/ = implicit_constructors_disabled_tag()) = delete; // NOLINT Implicit constructors disabled, use explicit in_place_type, success() or failure(). see docs!
/*! AWAITING HUGO JSON CONVERSION TOOL
SIGNATURE NOT RECOGNISED
*/
BOOST_OUTCOME_TEMPLATE(class T)
BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED(predicate::template enable_value_converting_constructor))
constexpr basic_outcome(T &&t, value_converting_constructor_tag /*unused*/ = value_converting_constructor_tag()) noexcept(std::is_nothrow_constructible::value) // NOLINT
: base{in_place_type, static_cast(t)}
, _ptr()
{
using namespace hooks;
hook_outcome_construction(this, static_cast(t));
}
/*! AWAITING HUGO JSON CONVERSION TOOL
SIGNATURE NOT RECOGNISED
*/
BOOST_OUTCOME_TEMPLATE(class T)
BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED(predicate::template enable_error_converting_constructor))
constexpr basic_outcome(T &&t, error_converting_constructor_tag /*unused*/ = error_converting_constructor_tag()) noexcept(std::is_nothrow_constructible::value) // NOLINT
: base{in_place_type, static_cast(t)}
, _ptr()
{
using namespace hooks;
hook_outcome_construction(this, static_cast(t));
}
/*! AWAITING HUGO JSON CONVERSION TOOL
SIGNATURE NOT RECOGNISED
*/
BOOST_OUTCOME_TEMPLATE(class ErrorCondEnum)
BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TEXPR(error_type(make_error_code(ErrorCondEnum()))), //
BOOST_OUTCOME_TPRED(predicate::template enable_error_condition_converting_constructor))
constexpr basic_outcome(ErrorCondEnum &&t, error_condition_converting_constructor_tag /*unused*/ = error_condition_converting_constructor_tag()) noexcept(noexcept(error_type(make_error_code(static_cast(t))))) // NOLINT
: base{in_place_type, make_error_code(t)}
{
using namespace hooks;
hook_outcome_construction(this, static_cast(t));
}
/*! AWAITING HUGO JSON CONVERSION TOOL
SIGNATURE NOT RECOGNISED
*/
BOOST_OUTCOME_TEMPLATE(class T)
BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED(predicate::template enable_exception_converting_constructor))
constexpr basic_outcome(T &&t, exception_converting_constructor_tag /*unused*/ = exception_converting_constructor_tag()) noexcept(std::is_nothrow_constructible::value) // NOLINT
: base()
, _ptr(static_cast(t))
{
using namespace hooks;
this->_state._status |= detail::status_have_exception;
hook_outcome_construction(this, static_cast(t));
}
/*! AWAITING HUGO JSON CONVERSION TOOL
SIGNATURE NOT RECOGNISED
*/
BOOST_OUTCOME_TEMPLATE(class T, class U)
BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED(predicate::template enable_error_exception_converting_constructor))
constexpr basic_outcome(T &&a, U &&b, error_exception_converting_constructor_tag /*unused*/ = error_exception_converting_constructor_tag()) noexcept(std::is_nothrow_constructible::value &&std::is_nothrow_constructible::value) // NOLINT
: base{in_place_type, static_cast(a)}
, _ptr(static_cast(b))
{
using namespace hooks;
this->_state._status |= detail::status_have_exception;
hook_outcome_construction(this, static_cast(a), static_cast(b));
}
/*! AWAITING HUGO JSON CONVERSION TOOL
SIGNATURE NOT RECOGNISED
*/
BOOST_OUTCOME_TEMPLATE(class T)
BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED(convert::value_or_error>::enable_result_inputs || !is_basic_result_v), //
BOOST_OUTCOME_TPRED(convert::value_or_error>::enable_outcome_inputs || !is_basic_outcome_v), //
BOOST_OUTCOME_TEXPR(convert::value_or_error>{}(std::declval())))
constexpr explicit basic_outcome(T &&o, explicit_valueorerror_converting_constructor_tag /*unused*/ = explicit_valueorerror_converting_constructor_tag()) // NOLINT
: basic_outcome{convert::value_or_error>{}(static_cast(o))}
{
}
/*! AWAITING HUGO JSON CONVERSION TOOL
SIGNATURE NOT RECOGNISED
*/
BOOST_OUTCOME_TEMPLATE(class T, class U, class V, class W)
BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED(predicate::template enable_compatible_conversion))
constexpr explicit basic_outcome(const basic_outcome &o,
explicit_compatible_copy_conversion_tag /*unused*/ = explicit_compatible_copy_conversion_tag()) noexcept(std::is_nothrow_constructible::value &&std::is_nothrow_constructible::value &&std::is_nothrow_constructible::value)
: base{typename base::compatible_conversion_tag(), o}
, _ptr(o._ptr)
{
using namespace hooks;
hook_outcome_copy_construction(this, o);
}
/*! AWAITING HUGO JSON CONVERSION TOOL
SIGNATURE NOT RECOGNISED
*/
BOOST_OUTCOME_TEMPLATE(class T, class U, class V, class W)
BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED(predicate::template enable_compatible_conversion))
constexpr explicit basic_outcome(basic_outcome &&o,
explicit_compatible_move_conversion_tag /*unused*/ = explicit_compatible_move_conversion_tag()) noexcept(std::is_nothrow_constructible::value &&std::is_nothrow_constructible::value &&std::is_nothrow_constructible::value)
: base{typename base::compatible_conversion_tag(), static_cast &&>(o)}
, _ptr(static_cast::exception_type &&>(o._ptr))
{
using namespace hooks;
hook_outcome_move_construction(this, static_cast &&>(o));
}
/*! AWAITING HUGO JSON CONVERSION TOOL
SIGNATURE NOT RECOGNISED
*/
BOOST_OUTCOME_TEMPLATE(class T, class U, class V)
BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED(detail::result_predicates::template enable_compatible_conversion))
constexpr explicit basic_outcome(const basic_result &o,
explicit_compatible_copy_conversion_tag /*unused*/ = explicit_compatible_copy_conversion_tag()) noexcept(std::is_nothrow_constructible::value &&std::is_nothrow_constructible::value &&std::is_nothrow_constructible::value)
: base{typename base::compatible_conversion_tag(), o}
, _ptr()
{
using namespace hooks;
hook_outcome_copy_construction(this, o);
}
/*! AWAITING HUGO JSON CONVERSION TOOL
SIGNATURE NOT RECOGNISED
*/
BOOST_OUTCOME_TEMPLATE(class T, class U, class V)
BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED(detail::result_predicates::template enable_compatible_conversion))
constexpr explicit basic_outcome(basic_result &&o,
explicit_compatible_move_conversion_tag /*unused*/ = explicit_compatible_move_conversion_tag()) noexcept(std::is_nothrow_constructible::value &&std::is_nothrow_constructible::value &&std::is_nothrow_constructible::value)
: base{typename base::compatible_conversion_tag(), static_cast &&>(o)}
, _ptr()
{
using namespace hooks;
hook_outcome_move_construction(this, static_cast &&>(o));
}
/*! AWAITING HUGO JSON CONVERSION TOOL
SIGNATURE NOT RECOGNISED
*/
BOOST_OUTCOME_TEMPLATE(class T, class U, class V)
BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED(detail::result_predicates::template enable_make_error_code_compatible_conversion))
constexpr explicit basic_outcome(const basic_result &o, explicit_make_error_code_compatible_copy_conversion_tag /*unused*/ = explicit_make_error_code_compatible_copy_conversion_tag()) noexcept(std::is_nothrow_constructible::value &&noexcept(make_error_code(std::declval())) &&
std::is_nothrow_constructible::value)
: base{typename base::make_error_code_compatible_conversion_tag(), o}
, _ptr()
{
using namespace hooks;
hook_outcome_copy_construction(this, o);
}
/*! AWAITING HUGO JSON CONVERSION TOOL
SIGNATURE NOT RECOGNISED
*/
BOOST_OUTCOME_TEMPLATE(class T, class U, class V)
BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED(detail::result_predicates::template enable_make_error_code_compatible_conversion))
constexpr explicit basic_outcome(basic_result &&o, explicit_make_error_code_compatible_move_conversion_tag /*unused*/ = explicit_make_error_code_compatible_move_conversion_tag()) noexcept(std::is_nothrow_constructible::value &&noexcept(make_error_code(std::declval())) &&
std::is_nothrow_constructible::value)
: base{typename base::make_error_code_compatible_conversion_tag(), static_cast &&>(o)}
, _ptr()
{
using namespace hooks;
hook_outcome_move_construction(this, static_cast &&>(o));
}
/*! AWAITING HUGO JSON CONVERSION TOOL
SIGNATURE NOT RECOGNISED
*/
BOOST_OUTCOME_TEMPLATE(class... Args)
BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED(predicate::template enable_inplace_value_constructor))
constexpr explicit basic_outcome(in_place_type_t _, Args &&... args) noexcept(std::is_nothrow_constructible::value)
: base{_, static_cast(args)...}
, _ptr()
{
using namespace hooks;
hook_outcome_in_place_construction(this, in_place_type, static_cast(args)...);
}
/*! AWAITING HUGO JSON CONVERSION TOOL
SIGNATURE NOT RECOGNISED
*/
BOOST_OUTCOME_TEMPLATE(class U, class... Args)
BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED(predicate::template enable_inplace_value_constructor, Args...>))
constexpr explicit basic_outcome(in_place_type_t _, std::initializer_list il, Args &&... args) noexcept(std::is_nothrow_constructible, Args...>::value)
: base{_, il, static_cast(args)...}
, _ptr()
{
using namespace hooks;
hook_outcome_in_place_construction(this, in_place_type, il, static_cast(args)...);
}
/*! AWAITING HUGO JSON CONVERSION TOOL
SIGNATURE NOT RECOGNISED
*/
BOOST_OUTCOME_TEMPLATE(class... Args)
BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED(predicate::template enable_inplace_error_constructor))
constexpr explicit basic_outcome(in_place_type_t _, Args &&... args) noexcept(std::is_nothrow_constructible::value)
: base{_, static_cast(args)...}
, _ptr()
{
using namespace hooks;
hook_outcome_in_place_construction(this, in_place_type, static_cast(args)...);
}
/*! AWAITING HUGO JSON CONVERSION TOOL
SIGNATURE NOT RECOGNISED
*/
BOOST_OUTCOME_TEMPLATE(class U, class... Args)
BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED(predicate::template enable_inplace_error_constructor