BOOST_OUTCOME_V2_NAMESPACE_EXPORT_BEGIN
template <class R, class S, class NoValuePolicy> //
-#if !defined(__GNUC__) || __GNUC__ >= 8 // GCC's constraints implementation is buggy
+#if !defined(__GNUC__) || __GNUC__ >= 10 // GCC's constraints implementation is buggy
BOOST_OUTCOME_REQUIRES(trait::type_can_be_used_in_basic_result<R> &&trait::type_can_be_used_in_basic_result<S> && (std::is_void<S>::value || std::is_default_constructible<S>::value)) //
#endif
class basic_result;
// These are reused by basic_outcome to save load on the compiler
template <class value_type, class error_type> struct result_predicates
{
- // Predicate for the implicit constructors to be available
+ // Predicate for the implicit constructors to be available. Weakened to allow result<int, C enum>.
static constexpr bool implicit_constructors_enabled = //
!(trait::is_error_type<std::decay_t<value_type>>::value && trait::is_error_type<std::decay_t<error_type>>::value) // both value and error types are not whitelisted error types
&& ((!detail::is_implicitly_constructible<value_type, error_type> && !detail::is_implicitly_constructible<error_type, value_type>) // if value and error types cannot be constructed into one another
&& trait::is_error_type_enum<error_type, std::decay_t<ErrorCondEnum>>::value // is an error condition enum
/*&& !detail::is_implicitly_constructible<value_type, ErrorCondEnum> && !detail::is_implicitly_constructible<error_type, ErrorCondEnum>*/; // not constructible via any other means
- // Predicate for the converting copy constructor from a compatible input to be available.
+ // Predicate for the converting constructor from a compatible input to be available.
template <class T, class U, class V>
static constexpr bool enable_compatible_conversion = //
(std::is_void<T>::value || detail::is_explicitly_constructible<value_type, typename basic_result<T, U, V>::value_type>) // if our value types are constructible
&&(std::is_void<U>::value || detail::is_explicitly_constructible<error_type, typename basic_result<T, U, V>::error_type>) // if our error types are constructible
;
+ // Predicate for the converting constructor from a make_error_code() of the input to be available.
+ template <class T, class U, class V>
+ static constexpr bool enable_make_error_code_compatible_conversion = //
+ trait::is_error_code_available<std::decay_t<error_type>>::value // if error type has an error code
+ && !enable_compatible_conversion<T, U, V> // and the normal compatible conversion is not available
+ && (std::is_void<T>::value || detail::is_explicitly_constructible<value_type, typename basic_result<T, U, V>::value_type>) // and if our value types are constructible
+ &&detail::is_explicitly_constructible<error_type, typename trait::is_error_code_available<U>::type>; // and our error type is constructible from a make_error_code()
+
+ // Predicate for the converting constructor from a make_exception_ptr() of the input to be available.
+ template <class T, class U, class V>
+ static constexpr bool enable_make_exception_ptr_compatible_conversion = //
+ trait::is_exception_ptr_available<std::decay_t<error_type>>::value // if error type has an exception ptr
+ && !enable_compatible_conversion<T, U, V> // and the normal compatible conversion is not available
+ && (std::is_void<T>::value || detail::is_explicitly_constructible<value_type, typename basic_result<T, U, V>::value_type>) // and if our value types are constructible
+ &&detail::is_explicitly_constructible<error_type, typename trait::is_exception_ptr_available<U>::type>; // and our error type is constructible from a make_exception_ptr()
+
// Predicate for the implicit converting inplace constructor from a compatible input to be available.
struct disable_inplace_value_error_constructor;
template <class... Args>
type definition template <class R, class S, class NoValuePolicy> basic_result. Potential doc page: `basic_result<T, E, NoValuePolicy>`
*/
template <class R, class S, class NoValuePolicy> //
-#if !defined(__GNUC__) || __GNUC__ >= 8 // GCC's constraints implementation is buggy
+#if !defined(__GNUC__) || __GNUC__ >= 10 // GCC's constraints implementation is buggy
BOOST_OUTCOME_REQUIRES(trait::type_can_be_used_in_basic_result<R> &&trait::type_can_be_used_in_basic_result<S> && (std::is_void<S>::value || std::is_default_constructible<S>::value)) //
#endif
class BOOST_OUTCOME_NODISCARD basic_result : public detail::basic_result_final<R, S, NoValuePolicy>
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 explicit_make_exception_ptr_compatible_copy_conversion_tag
+ {
+ };
+ struct explicit_make_exception_ptr_compatible_move_conversion_tag
+ {
+ };
public:
using value_type = R;
&& !std::is_same<std::decay_t<ErrorCondEnum>, basic_result>::value // not my type
&& base::template enable_error_condition_converting_constructor<ErrorCondEnum>;
- // Predicate for the converting copy constructor from a compatible input to be available.
+ // Predicate for the converting constructor from a compatible input to be available.
template <class T, class U, class V>
static constexpr bool enable_compatible_conversion = //
constructors_enabled //
&& !std::is_same<basic_result<T, U, V>, basic_result>::value // not my type
&& base::template enable_compatible_conversion<T, U, V>;
+ // Predicate for the converting constructor from a make_error_code() of the input to be available.
+ template <class T, class U, class V>
+ static constexpr bool enable_make_error_code_compatible_conversion = //
+ constructors_enabled //
+ && !std::is_same<basic_result<T, U, V>, basic_result>::value // not my type
+ && base::template enable_make_error_code_compatible_conversion<T, U, V>;
+
+ // Predicate for the converting constructor from a make_exception_ptr() of the input to be available.
+ template <class T, class U, class V>
+ static constexpr bool enable_make_exception_ptr_compatible_conversion = //
+ constructors_enabled //
+ && !std::is_same<basic_result<T, U, V>, basic_result>::value // not my type
+ && base::template enable_make_exception_ptr_compatible_conversion<T, U, V>;
+
// Predicate for the inplace construction of value to be available.
template <class... Args>
static constexpr bool enable_inplace_value_constructor = //
BOOST_OUTCOME_TEMPLATE(class T)
BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED(predicate::template enable_value_converting_constructor<T>))
constexpr basic_result(T &&t, value_converting_constructor_tag /*unused*/ = value_converting_constructor_tag()) noexcept(std::is_nothrow_constructible<value_type, T>::value) // NOLINT
- : base{in_place_type<typename base::value_type>, static_cast<T &&>(t)}
+ : base{in_place_type<typename base::value_type>, static_cast<T &&>(t)}
{
using namespace hooks;
hook_result_construction(this, static_cast<T &&>(t));
BOOST_OUTCOME_TEMPLATE(class T)
BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED(predicate::template enable_error_converting_constructor<T>))
constexpr basic_result(T &&t, error_converting_constructor_tag /*unused*/ = error_converting_constructor_tag()) noexcept(std::is_nothrow_constructible<error_type, T>::value) // NOLINT
- : base{in_place_type<typename base::error_type>, static_cast<T &&>(t)}
+ : base{in_place_type<typename base::error_type>, static_cast<T &&>(t)}
{
using namespace hooks;
hook_result_construction(this, static_cast<T &&>(t));
BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TEXPR(error_type(make_error_code(ErrorCondEnum()))), //
BOOST_OUTCOME_TPRED(predicate::template enable_error_condition_converting_constructor<ErrorCondEnum>))
constexpr basic_result(ErrorCondEnum &&t, error_condition_converting_constructor_tag /*unused*/ = error_condition_converting_constructor_tag()) noexcept(noexcept(error_type(make_error_code(static_cast<ErrorCondEnum &&>(t))))) // NOLINT
- : base{in_place_type<typename base::error_type>, make_error_code(t)}
+ : base{in_place_type<typename base::error_type>, make_error_code(t)}
{
using namespace hooks;
hook_result_construction(this, static_cast<ErrorCondEnum &&>(t));
BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED(convert::value_or_error<basic_result, std::decay_t<T>>::enable_result_inputs || !is_basic_result_v<T>), //
BOOST_OUTCOME_TEXPR(convert::value_or_error<basic_result, std::decay_t<T>>{}(std::declval<T>())))
constexpr explicit basic_result(T &&o, explicit_valueorerror_converting_constructor_tag /*unused*/ = explicit_valueorerror_converting_constructor_tag()) // NOLINT
- : basic_result{convert::value_or_error<basic_result, std::decay_t<T>>{}(static_cast<T &&>(o))}
+ : basic_result{convert::value_or_error<basic_result, std::decay_t<T>>{}(static_cast<T &&>(o))}
{
}
/*! AWAITING HUGO JSON CONVERSION TOOL
*/
BOOST_OUTCOME_TEMPLATE(class T, class U, class V)
BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED(predicate::template enable_compatible_conversion<T, U, V>))
- constexpr explicit basic_result(const basic_result<T, U, V> &o) noexcept(std::is_nothrow_constructible<value_type, T>::value &&std::is_nothrow_constructible<error_type, U>::value)
+ constexpr explicit basic_result(const basic_result<T, U, V> &o, explicit_compatible_copy_conversion_tag /*unused*/ = explicit_compatible_copy_conversion_tag()) noexcept(std::is_nothrow_constructible<value_type, T>::value &&std::is_nothrow_constructible<error_type, U>::value)
: base{typename base::compatible_conversion_tag(), o}
{
using namespace hooks;
*/
BOOST_OUTCOME_TEMPLATE(class T, class U, class V)
BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED(predicate::template enable_compatible_conversion<T, U, V>))
- constexpr explicit basic_result(basic_result<T, U, V> &&o) noexcept(std::is_nothrow_constructible<value_type, T>::value &&std::is_nothrow_constructible<error_type, U>::value)
+ constexpr explicit basic_result(basic_result<T, U, V> &&o, explicit_compatible_move_conversion_tag /*unused*/ = explicit_compatible_move_conversion_tag()) noexcept(std::is_nothrow_constructible<value_type, T>::value &&std::is_nothrow_constructible<error_type, U>::value)
: base{typename base::compatible_conversion_tag(), static_cast<basic_result<T, U, V> &&>(o)}
{
using namespace hooks;
hook_result_move_construction(this, static_cast<basic_result<T, U, V> &&>(o));
}
+ /*! AWAITING HUGO JSON CONVERSION TOOL
+SIGNATURE NOT RECOGNISED
+*/
+ BOOST_OUTCOME_TEMPLATE(class T, class U, class V)
+ BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED(predicate::template enable_make_error_code_compatible_conversion<T, U, V>))
+ constexpr explicit basic_result(const basic_result<T, U, V> &o, explicit_make_error_code_compatible_copy_conversion_tag /*unused*/ = explicit_make_error_code_compatible_copy_conversion_tag()) noexcept(std::is_nothrow_constructible<value_type, T>::value &&noexcept(make_error_code(std::declval<U>())))
+ : base{typename base::make_error_code_compatible_conversion_tag(), o}
+ {
+ using namespace hooks;
+ hook_result_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(predicate::template enable_make_error_code_compatible_conversion<T, U, V>))
+ constexpr explicit basic_result(basic_result<T, U, V> &&o, explicit_make_error_code_compatible_move_conversion_tag /*unused*/ = explicit_make_error_code_compatible_move_conversion_tag()) noexcept(std::is_nothrow_constructible<value_type, T>::value &&noexcept(make_error_code(std::declval<U>())))
+ : base{typename base::make_error_code_compatible_conversion_tag(), static_cast<basic_result<T, U, V> &&>(o)}
+ {
+ using namespace hooks;
+ hook_result_move_construction(this, static_cast<basic_result<T, U, V> &&>(o));
+ }
+ /*! AWAITING HUGO JSON CONVERSION TOOL
+SIGNATURE NOT RECOGNISED
+*/
+ BOOST_OUTCOME_TEMPLATE(class T, class U, class V)
+ BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED(predicate::template enable_make_exception_ptr_compatible_conversion<T, U, V>))
+ constexpr explicit basic_result(const basic_result<T, U, V> &o, explicit_make_exception_ptr_compatible_copy_conversion_tag /*unused*/ = explicit_make_exception_ptr_compatible_copy_conversion_tag()) noexcept(std::is_nothrow_constructible<value_type, T>::value &&noexcept(make_exception_ptr(std::declval<U>())))
+ : base{typename base::make_exception_ptr_compatible_conversion_tag(), o}
+ {
+ using namespace hooks;
+ hook_result_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(predicate::template enable_make_exception_ptr_compatible_conversion<T, U, V>))
+ constexpr explicit basic_result(basic_result<T, U, V> &&o, explicit_make_exception_ptr_compatible_move_conversion_tag /*unused*/ = explicit_make_exception_ptr_compatible_move_conversion_tag()) noexcept(std::is_nothrow_constructible<value_type, T>::value &&noexcept(make_exception_ptr(std::declval<U>())))
+ : base{typename base::make_exception_ptr_compatible_conversion_tag(), static_cast<basic_result<T, U, V> &&>(o)}
+ {
+ using namespace hooks;
+ hook_result_move_construction(this, static_cast<basic_result<T, U, V> &&>(o));
+ }
/*! AWAITING HUGO JSON CONVERSION TOOL
SIGNATURE NOT RECOGNISED
SIGNATURE NOT RECOGNISED
*/
constexpr basic_result(const success_type<void> &o) noexcept(std::is_nothrow_default_constructible<value_type>::value) // NOLINT
- : base{in_place_type<value_type_if_enabled>}
+ : base{in_place_type<value_type_if_enabled>}
{
using namespace hooks;
hook_result_copy_construction(this, o);
BOOST_OUTCOME_TEMPLATE(class T)
BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED(predicate::template enable_compatible_conversion<T, void, void>))
constexpr basic_result(const success_type<T> &o) noexcept(std::is_nothrow_constructible<value_type, T>::value) // NOLINT
- : base{in_place_type<value_type_if_enabled>, detail::extract_value_from_success<value_type>(o)}
+ : base{in_place_type<value_type_if_enabled>, detail::extract_value_from_success<value_type>(o)}
{
using namespace hooks;
hook_result_copy_construction(this, o);
BOOST_OUTCOME_TEMPLATE(class T)
BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED(!std::is_void<T>::value && predicate::template enable_compatible_conversion<T, void, void>))
constexpr basic_result(success_type<T> &&o) noexcept(std::is_nothrow_constructible<value_type, T>::value) // NOLINT
- : base{in_place_type<value_type_if_enabled>, detail::extract_value_from_success<value_type>(static_cast<success_type<T> &&>(o))}
+ : base{in_place_type<value_type_if_enabled>, detail::extract_value_from_success<value_type>(static_cast<success_type<T> &&>(o))}
{
using namespace hooks;
hook_result_move_construction(this, static_cast<success_type<T> &&>(o));
*/
BOOST_OUTCOME_TEMPLATE(class T)
BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED(predicate::template enable_compatible_conversion<void, T, void>))
- constexpr basic_result(const failure_type<T> &o) noexcept(std::is_nothrow_constructible<error_type, T>::value) // NOLINT
- : base{in_place_type<error_type_if_enabled>, detail::extract_error_from_failure<error_type>(o)}
+ constexpr basic_result(const failure_type<T> &o, explicit_compatible_copy_conversion_tag /*unused*/ = explicit_compatible_copy_conversion_tag()) noexcept(std::is_nothrow_constructible<error_type, T>::value) // NOLINT
+ : base{in_place_type<error_type_if_enabled>, detail::extract_error_from_failure<error_type>(o)}
{
using namespace hooks;
hook_result_copy_construction(this, o);
*/
BOOST_OUTCOME_TEMPLATE(class T)
BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED(predicate::template enable_compatible_conversion<void, T, void>))
- constexpr basic_result(failure_type<T> &&o) noexcept(std::is_nothrow_constructible<error_type, T>::value) // NOLINT
- : base{in_place_type<error_type_if_enabled>, detail::extract_error_from_failure<error_type>(static_cast<failure_type<T> &&>(o))}
+ constexpr basic_result(failure_type<T> &&o, explicit_compatible_move_conversion_tag /*unused*/ = explicit_compatible_move_conversion_tag()) noexcept(std::is_nothrow_constructible<error_type, T>::value) // NOLINT
+ : base{in_place_type<error_type_if_enabled>, detail::extract_error_from_failure<error_type>(static_cast<failure_type<T> &&>(o))}
+ {
+ using namespace hooks;
+ hook_result_move_construction(this, static_cast<failure_type<T> &&>(o));
+ }
+ /*! AWAITING HUGO JSON CONVERSION TOOL
+SIGNATURE NOT RECOGNISED
+*/
+ BOOST_OUTCOME_TEMPLATE(class T)
+ BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED(predicate::template enable_make_error_code_compatible_conversion<void, T, void>))
+ constexpr basic_result(const failure_type<T> &o, explicit_make_error_code_compatible_copy_conversion_tag /*unused*/ = explicit_make_error_code_compatible_copy_conversion_tag()) noexcept(noexcept(make_error_code(std::declval<T>()))) // NOLINT
+ : base{in_place_type<error_type_if_enabled>, make_error_code(detail::extract_error_from_failure<error_type>(o))}
+ {
+ using namespace hooks;
+ hook_result_copy_construction(this, o);
+ }
+ /*! AWAITING HUGO JSON CONVERSION TOOL
+SIGNATURE NOT RECOGNISED
+*/
+ BOOST_OUTCOME_TEMPLATE(class T)
+ BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED(predicate::template enable_make_error_code_compatible_conversion<void, T, void>))
+ constexpr basic_result(failure_type<T> &&o, explicit_make_error_code_compatible_move_conversion_tag /*unused*/ = explicit_make_error_code_compatible_move_conversion_tag()) noexcept(noexcept(make_error_code(std::declval<T>()))) // NOLINT
+ : base{in_place_type<error_type_if_enabled>, make_error_code(detail::extract_error_from_failure<error_type>(static_cast<failure_type<T> &&>(o)))}
+ {
+ using namespace hooks;
+ hook_result_move_construction(this, static_cast<failure_type<T> &&>(o));
+ }
+ /*! AWAITING HUGO JSON CONVERSION TOOL
+SIGNATURE NOT RECOGNISED
+*/
+ BOOST_OUTCOME_TEMPLATE(class T)
+ BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED(predicate::template enable_make_exception_ptr_compatible_conversion<void, T, void>))
+ constexpr basic_result(const failure_type<T> &o, explicit_make_exception_ptr_compatible_copy_conversion_tag /*unused*/ = explicit_make_exception_ptr_compatible_copy_conversion_tag()) noexcept(noexcept(make_exception_ptr(std::declval<T>()))) // NOLINT
+ : base{in_place_type<error_type_if_enabled>, make_exception_ptr(detail::extract_error_from_failure<error_type>(o))}
+ {
+ using namespace hooks;
+ hook_result_copy_construction(this, o);
+ }
+ /*! AWAITING HUGO JSON CONVERSION TOOL
+SIGNATURE NOT RECOGNISED
+*/
+ BOOST_OUTCOME_TEMPLATE(class T)
+ BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED(predicate::template enable_make_exception_ptr_compatible_conversion<void, T, void>))
+ constexpr basic_result(failure_type<T> &&o, explicit_make_exception_ptr_compatible_move_conversion_tag /*unused*/ = explicit_make_exception_ptr_compatible_move_conversion_tag()) noexcept(noexcept(make_exception_ptr(std::declval<T>()))) // NOLINT
+ : base{in_place_type<error_type_if_enabled>, make_exception_ptr(detail::extract_error_from_failure<error_type>(static_cast<failure_type<T> &&>(o)))}
{
using namespace hooks;
hook_result_move_construction(this, static_cast<failure_type<T> &&>(o));
SIGNATURE NOT RECOGNISED
*/
constexpr void swap(basic_result &o) noexcept((std::is_void<value_type>::value || detail::is_nothrow_swappable<value_type>::value) //
- &&(std::is_void<error_type>::value || detail::is_nothrow_swappable<error_type>::value))
+ && (std::is_void<error_type>::value || detail::is_nothrow_swappable<error_type>::value))
{
constexpr bool value_throws = !std::is_void<value_type>::value && !detail::is_nothrow_swappable<value_type>::value;
constexpr bool error_throws = !std::is_void<error_type>::value && !detail::is_nothrow_swappable<error_type>::value;
/*! AWAITING HUGO JSON CONVERSION TOOL
SIGNATURE NOT RECOGNISED
*/
- auto as_failure() const & { return failure(this->assume_error()); }
+ auto as_failure() const & {
+ return failure(this->assume_error()); }
/*! AWAITING HUGO JSON CONVERSION TOOL
SIGNATURE NOT RECOGNISED
*/
- auto as_failure() && { return failure(static_cast<basic_result &&>(*this).assume_error()); }
+ auto as_failure() && {
+ return failure(static_cast<basic_result &&>(*this).assume_error()); }
};
/*! AWAITING HUGO JSON CONVERSION TOOL
projects / platform / upstream / boost.git / blobdiff