VERY experimental Nintendo Switch 2 emulator
C++
[hle/bsd] do not use rust-result wannabe Expected in functions (#4075)
lizzied8a8169eb209
diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txtindex 786effa6bd..7bb4c3aa4a 100644--- a/src/common/CMakeLists.txt+++ b/src/common/CMakeLists.txt@@ -50,7 +50,6 @@ add_library(elf.herror.cpperror.h- expected.hfiber.cppfiber.hfixed_point.hdiff --git a/src/common/expected.h b/src/common/expected.hdeleted file mode 100644index 5fccfbcbdd..0000000000--- a/src/common/expected.h+++ /dev/null@@ -1,986 +0,0 @@-// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project-// SPDX-License-Identifier: GPL-2.0-or-later--// This is based on the proposed implementation of std::expected (P0323)-// https://github.com/TartanLlama/expected/blob/master/include/tl/expected.hpp--#pragma once--#include <type_traits>-#include <utility>--namespace Common {--template <typename T, typename E>-class Expected;--template <typename E>-class Unexpected {-public:- Unexpected() = delete;-- constexpr explicit Unexpected(const E& e) : m_val{e} {}-- constexpr explicit Unexpected(E&& e) : m_val{std::move(e)} {}-- constexpr E& value() & {- return m_val;- }-- constexpr const E& value() const& {- return m_val;- }-- constexpr E&& value() && {- return std::move(m_val);- }-- constexpr const E&& value() const&& {- return std::move(m_val);- }--private:- E m_val;-};--template <typename E>-constexpr auto operator<=>(const Unexpected<E>& lhs, const Unexpected<E>& rhs) {- return lhs.value() <=> rhs.value();-}--struct unexpect_t {- constexpr explicit unexpect_t() = default;-};--namespace detail {--struct no_init_t {- constexpr explicit no_init_t() = default;-};--/**- * This specialization is for when T is not trivially destructible,- * so the destructor must be called on destruction of `expected'- * Additionally, this requires E to be trivially destructible- */-template <typename T, typename E, bool = std::is_trivially_destructible_v<T>>- requires std::is_trivially_destructible_v<E>-struct expected_storage_base {- constexpr expected_storage_base() : m_val{T{}}, m_has_val{true} {}-- constexpr expected_storage_base(no_init_t) : m_has_val{false} {}-- template <typename... Args, std::enable_if_t<std::is_constructible_v<T, Args&&...>>* = nullptr>- constexpr expected_storage_base(std::in_place_t, Args&&... args)- : m_val{std::forward<Args>(args)...}, m_has_val{true} {}-- template <typename U, typename... Args,- std::enable_if_t<std::is_constructible_v<T, std::initializer_list<U>&, Args&&...>>* =- nullptr>- constexpr expected_storage_base(std::in_place_t, std::initializer_list<U> il, Args&&... args)- : m_val{il, std::forward<Args>(args)...}, m_has_val{true} {}-- template <typename... Args, std::enable_if_t<std::is_constructible_v<E, Args&&...>>* = nullptr>- constexpr explicit expected_storage_base(unexpect_t, Args&&... args)- : m_unexpect{std::forward<Args>(args)...}, m_has_val{false} {}-- template <typename U, typename... Args,- std::enable_if_t<std::is_constructible_v<E, std::initializer_list<U>&, Args&&...>>* =- nullptr>- constexpr explicit expected_storage_base(unexpect_t, std::initializer_list<U> il,- Args&&... args)- : m_unexpect{il, std::forward<Args>(args)...}, m_has_val{false} {}-- ~expected_storage_base() {- if (m_has_val) {- m_val.~T();- }- }-- union {- T m_val;- Unexpected<E> m_unexpect;- };-- bool m_has_val;-};--/**- * This specialization is for when T is trivially destructible,- * so the destructor of `expected` can be trivial- * Additionally, this requires E to be trivially destructible- */-template <typename T, typename E>- requires std::is_trivially_destructible_v<E>-struct expected_storage_base<T, E, true> {- constexpr expected_storage_base() : m_val{T{}}, m_has_val{true} {}-- constexpr expected_storage_base(no_init_t) : m_has_val{false} {}-- template <typename... Args, std::enable_if_t<std::is_constructible_v<T, Args&&...>>* = nullptr>- constexpr expected_storage_base(std::in_place_t, Args&&... args)- : m_val{std::forward<Args>(args)...}, m_has_val{true} {}-- template <typename U, typename... Args,- std::enable_if_t<std::is_constructible_v<T, std::initializer_list<U>&, Args&&...>>* =- nullptr>- constexpr expected_storage_base(std::in_place_t, std::initializer_list<U> il, Args&&... args)- : m_val{il, std::forward<Args>(args)...}, m_has_val{true} {}-- template <typename... Args, std::enable_if_t<std::is_constructible_v<E, Args&&...>>* = nullptr>- constexpr explicit expected_storage_base(unexpect_t, Args&&... args)- : m_unexpect{std::forward<Args>(args)...}, m_has_val{false} {}-- template <typename U, typename... Args,- std::enable_if_t<std::is_constructible_v<E, std::initializer_list<U>&, Args&&...>>* =- nullptr>- constexpr explicit expected_storage_base(unexpect_t, std::initializer_list<U> il,- Args&&... args)- : m_unexpect{il, std::forward<Args>(args)...}, m_has_val{false} {}-- ~expected_storage_base() = default;-- union {- T m_val;- Unexpected<E> m_unexpect;- };-- bool m_has_val;-};--template <typename T, typename E>-struct expected_operations_base : expected_storage_base<T, E> {- using expected_storage_base<T, E>::expected_storage_base;-- template <typename... Args>- void construct(Args&&... args) noexcept {- new (std::addressof(this->m_val)) T{std::forward<Args>(args)...};- this->m_has_val = true;- }-- template <typename Rhs>- void construct_with(Rhs&& rhs) noexcept {- new (std::addressof(this->m_val)) T{std::forward<Rhs>(rhs).get()};- this->m_has_val = true;- }-- template <typename... Args>- void construct_error(Args&&... args) noexcept {- new (std::addressof(this->m_unexpect)) Unexpected<E>{std::forward<Args>(args)...};- this->m_has_val = false;- }-- void assign(const expected_operations_base& rhs) noexcept {- if (!this->m_has_val && rhs.m_has_val) {- geterr().~Unexpected<E>();- construct(rhs.get());- } else {- assign_common(rhs);- }- }-- void assign(expected_operations_base&& rhs) noexcept {- if (!this->m_has_val && rhs.m_has_val) {- geterr().~Unexpected<E>();- construct(std::move(rhs).get());- } else {- assign_common(rhs);- }- }-- template <typename Rhs>- void assign_common(Rhs&& rhs) {- if (this->m_has_val) {- if (rhs.m_has_val) {- get() = std::forward<Rhs>(rhs).get();- } else {- destroy_val();- construct_error(std::forward<Rhs>(rhs).geterr());- }- } else {- if (!rhs.m_has_val) {- geterr() = std::forward<Rhs>(rhs).geterr();- }- }- }-- bool has_value() const {- return this->m_has_val;- }-- constexpr T& get() & {- return this->m_val;- }-- constexpr const T& get() const& {- return this->m_val;- }-- constexpr T&& get() && {- return std::move(this->m_val);- }-- constexpr const T&& get() const&& {- return std::move(this->m_val);- }-- constexpr Unexpected<E>& geterr() & {- return this->m_unexpect;- }-- constexpr const Unexpected<E>& geterr() const& {- return this->m_unexpect;- }-- constexpr Unexpected<E>&& geterr() && {- return std::move(this->m_unexpect);- }-- constexpr const Unexpected<E>&& geterr() const&& {- return std::move(this->m_unexpect);- }-- constexpr void destroy_val() {- get().~T();- }-};--/**- * This manages conditionally having a trivial copy constructor- * This specialization is for when T is trivially copy constructible- * Additionally, this requires E to be trivially copy constructible- */-template <typename T, typename E, bool = std::is_trivially_copy_constructible_v<T>>- requires std::is_trivially_copy_constructible_v<E>-struct expected_copy_base : expected_operations_base<T, E> {- using expected_operations_base<T, E>::expected_operations_base;-};--/**- * This specialization is for when T is not trivially copy constructible- * Additionally, this requires E to be trivially copy constructible- */-template <typename T, typename E>- requires std::is_trivially_copy_constructible_v<E>-struct expected_copy_base<T, E, false> : expected_operations_base<T, E> {- using expected_operations_base<T, E>::expected_operations_base;-- expected_copy_base() = default;-- expected_copy_base(const expected_copy_base& rhs)- : expected_operations_base<T, E>{no_init_t{}} {- if (rhs.has_value()) {- this->construct_with(rhs);- } else {- this->construct_error(rhs.geterr());- }- }-- expected_copy_base(expected_copy_base&&) = default;-- expected_copy_base& operator=(const expected_copy_base&) = default;-- expected_copy_base& operator=(expected_copy_base&&) = default;-};--/**- * This manages conditionally having a trivial move constructor- * This specialization is for when T is trivially move constructible- * Additionally, this requires E to be trivially move constructible- */-template <typename T, typename E, bool = std::is_trivially_move_constructible_v<T>>- requires std::is_trivially_move_constructible_v<E>-struct expected_move_base : expected_copy_base<T, E> {- using expected_copy_base<T, E>::expected_copy_base;-};--/**- * This specialization is for when T is not trivially move constructible- * Additionally, this requires E to be trivially move constructible- */-template <typename T, typename E>- requires std::is_trivially_move_constructible_v<E>-struct expected_move_base<T, E, false> : expected_copy_base<T, E> {- using expected_copy_base<T, E>::expected_copy_base;-- expected_move_base() = default;-- expected_move_base(const expected_move_base&) = default;-- expected_move_base(expected_move_base&& rhs) noexcept(std::is_nothrow_move_constructible_v<T>)- : expected_copy_base<T, E>{no_init_t{}} {- if (rhs.has_value()) {- this->construct_with(std::move(rhs));- } else {- this->construct_error(std::move(rhs.geterr()));- }- }-- expected_move_base& operator=(const expected_move_base&) = default;-- expected_move_base& operator=(expected_move_base&&) = default;-};--/**- * This manages conditionally having a trivial copy assignment operator- * This specialization is for when T is trivially copy assignable- * Additionally, this requires E to be trivially copy assignable- */-template <typename T, typename E,- bool = std::conjunction_v<std::is_trivially_copy_assignable<T>,- std::is_trivially_copy_constructible<T>,- std::is_trivially_destructible<T>>>- requires std::conjunction_v<std::is_trivially_copy_assignable<E>,- std::is_trivially_copy_constructible<E>,- std::is_trivially_destructible<E>>-struct expected_copy_assign_base : expected_move_base<T, E> {- using expected_move_base<T, E>::expected_move_base;-};--/**- * This specialization is for when T is not trivially copy assignable- * Additionally, this requires E to be trivially copy assignable- */-template <typename T, typename E>- requires std::conjunction_v<std::is_trivially_copy_assignable<E>,- std::is_trivially_copy_constructible<E>,- std::is_trivially_destructible<E>>-struct expected_copy_assign_base<T, E, false> : expected_move_base<T, E> {- using expected_move_base<T, E>::expected_move_base;-- expected_copy_assign_base() = default;-- expected_copy_assign_base(const expected_copy_assign_base&) = default;-- expected_copy_assign_base(expected_copy_assign_base&&) = default;-- expected_copy_assign_base& operator=(const expected_copy_assign_base& rhs) {- this->assign(rhs);- return *this;- }-- expected_copy_assign_base& operator=(expected_copy_assign_base&&) = default;-};--/**- * This manages conditionally having a trivial move assignment operator- * This specialization is for when T is trivially move assignable- * Additionally, this requires E to be trivially move assignable- */-template <typename T, typename E,- bool = std::conjunction_v<std::is_trivially_move_assignable<T>,- std::is_trivially_move_constructible<T>,- std::is_trivially_destructible<T>>>- requires std::conjunction_v<std::is_trivially_move_assignable<E>,- std::is_trivially_move_constructible<E>,- std::is_trivially_destructible<E>>-struct expected_move_assign_base : expected_copy_assign_base<T, E> {- using expected_copy_assign_base<T, E>::expected_copy_assign_base;-};--/**- * This specialization is for when T is not trivially move assignable- * Additionally, this requires E to be trivially move assignable- */-template <typename T, typename E>- requires std::conjunction_v<std::is_trivially_move_assignable<E>,- std::is_trivially_move_constructible<E>,- std::is_trivially_destructible<E>>-struct expected_move_assign_base<T, E, false> : expected_copy_assign_base<T, E> {- using expected_copy_assign_base<T, E>::expected_copy_assign_base;-- expected_move_assign_base() = default;-- expected_move_assign_base(const expected_move_assign_base&) = default;-- expected_move_assign_base(expected_move_assign_base&&) = default;-- expected_move_assign_base& operator=(const expected_move_assign_base&) = default;-- expected_move_assign_base& operator=(expected_move_assign_base&& rhs) noexcept(- std::conjunction_v<std::is_nothrow_move_constructible<T>,- std::is_nothrow_move_assignable<T>>) {- this->assign(std::move(rhs));- return *this;- }-};--/**- * expected_delete_ctor_base will conditionally delete copy and move constructors- * depending on whether T is copy/move constructible- * Additionally, this requires E to be copy/move constructible- */-template <typename T, typename E, bool EnableCopy = std::is_copy_constructible_v<T>,- bool EnableMove = std::is_move_constructible_v<T>>- requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>>-struct expected_delete_ctor_base {- expected_delete_ctor_base() = default;- expected_delete_ctor_base(const expected_delete_ctor_base&) = default;- expected_delete_ctor_base(expected_delete_ctor_base&&) noexcept = default;- expected_delete_ctor_base& operator=(const expected_delete_ctor_base&) = default;- expected_delete_ctor_base& operator=(expected_delete_ctor_base&&) noexcept = default;-};--template <typename T, typename E>- requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>>-struct expected_delete_ctor_base<T, E, true, false> {- expected_delete_ctor_base() = default;- expected_delete_ctor_base(const expected_delete_ctor_base&) = default;- expected_delete_ctor_base(expected_delete_ctor_base&&) noexcept = delete;- expected_delete_ctor_base& operator=(const expected_delete_ctor_base&) = default;- expected_delete_ctor_base& operator=(expected_delete_ctor_base&&) noexcept = default;-};--template <typename T, typename E>- requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>>-struct expected_delete_ctor_base<T, E, false, true> {- expected_delete_ctor_base() = default;- expected_delete_ctor_base(const expected_delete_ctor_base&) = delete;- expected_delete_ctor_base(expected_delete_ctor_base&&) noexcept = default;- expected_delete_ctor_base& operator=(const expected_delete_ctor_base&) = default;- expected_delete_ctor_base& operator=(expected_delete_ctor_base&&) noexcept = default;-};--template <typename T, typename E>- requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>>-struct expected_delete_ctor_base<T, E, false, false> {- expected_delete_ctor_base() = default;- expected_delete_ctor_base(const expected_delete_ctor_base&) = delete;- expected_delete_ctor_base(expected_delete_ctor_base&&) noexcept = delete;- expected_delete_ctor_base& operator=(const expected_delete_ctor_base&) = default;- expected_delete_ctor_base& operator=(expected_delete_ctor_base&&) noexcept = default;-};--/**- * expected_delete_assign_base will conditionally delete copy and move assignment operators- * depending on whether T is copy/move constructible + assignable- * Additionally, this requires E to be copy/move constructible + assignable- */-template <- typename T, typename E,- bool EnableCopy = std::conjunction_v<std::is_copy_constructible<T>, std::is_copy_assignable<T>>,- bool EnableMove = std::conjunction_v<std::is_move_constructible<T>, std::is_move_assignable<T>>>- requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>,- std::is_copy_assignable<E>, std::is_move_assignable<E>>-struct expected_delete_assign_base {- expected_delete_assign_base() = default;- expected_delete_assign_base(const expected_delete_assign_base&) = default;- expected_delete_assign_base(expected_delete_assign_base&&) noexcept = default;- expected_delete_assign_base& operator=(const expected_delete_assign_base&) = default;- expected_delete_assign_base& operator=(expected_delete_assign_base&&) noexcept = default;-};--template <typename T, typename E>- requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>,- std::is_copy_assignable<E>, std::is_move_assignable<E>>-struct expected_delete_assign_base<T, E, true, false> {- expected_delete_assign_base() = default;- expected_delete_assign_base(const expected_delete_assign_base&) = default;- expected_delete_assign_base(expected_delete_assign_base&&) noexcept = default;- expected_delete_assign_base& operator=(const expected_delete_assign_base&) = default;- expected_delete_assign_base& operator=(expected_delete_assign_base&&) noexcept = delete;-};--template <typename T, typename E>- requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>,- std::is_copy_assignable<E>, std::is_move_assignable<E>>-struct expected_delete_assign_base<T, E, false, true> {- expected_delete_assign_base() = default;- expected_delete_assign_base(const expected_delete_assign_base&) = default;- expected_delete_assign_base(expected_delete_assign_base&&) noexcept = default;- expected_delete_assign_base& operator=(const expected_delete_assign_base&) = delete;- expected_delete_assign_base& operator=(expected_delete_assign_base&&) noexcept = default;-};--template <typename T, typename E>- requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>,- std::is_copy_assignable<E>, std::is_move_assignable<E>>-struct expected_delete_assign_base<T, E, false, false> {- expected_delete_assign_base() = default;- expected_delete_assign_base(const expected_delete_assign_base&) = default;- expected_delete_assign_base(expected_delete_assign_base&&) noexcept = default;- expected_delete_assign_base& operator=(const expected_delete_assign_base&) = delete;- expected_delete_assign_base& operator=(expected_delete_assign_base&&) noexcept = delete;-};--/**- * This is needed to be able to construct the expected_default_ctor_base which follows,- * while still conditionally deleting the default constructor.- */-struct default_constructor_tag {- constexpr explicit default_constructor_tag() = default;-};--/**- * expected_default_ctor_base will ensure that expected- * has a deleted default constructor if T is not default constructible- * This specialization is for when T is default constructible- */-template <typename T, typename E, bool Enable = std::is_default_constructible_v<T>>-struct expected_default_ctor_base {- constexpr expected_default_ctor_base() noexcept = default;- constexpr expected_default_ctor_base(expected_default_ctor_base const&) noexcept = default;- constexpr expected_default_ctor_base(expected_default_ctor_base&&) noexcept = default;- expected_default_ctor_base& operator=(expected_default_ctor_base const&) noexcept = default;- expected_default_ctor_base& operator=(expected_default_ctor_base&&) noexcept = default;-- constexpr explicit expected_default_ctor_base(default_constructor_tag) {}-};--template <typename T, typename E>-struct expected_default_ctor_base<T, E, false> {- constexpr expected_default_ctor_base() noexcept = delete;- constexpr expected_default_ctor_base(expected_default_ctor_base const&) noexcept = default;- constexpr expected_default_ctor_base(expected_default_ctor_base&&) noexcept = default;- expected_default_ctor_base& operator=(expected_default_ctor_base const&) noexcept = default;- expected_default_ctor_base& operator=(expected_default_ctor_base&&) noexcept = default;-- constexpr explicit expected_default_ctor_base(default_constructor_tag) {}-};--template <typename T, typename E, typename U>-using expected_enable_forward_value =- std::enable_if_t<std::is_constructible_v<T, U&&> &&- !std::is_same_v<std::remove_cvref_t<U>, std::in_place_t> &&- !std::is_same_v<Expected<T, E>, std::remove_cvref_t<U>> &&- !std::is_same_v<Unexpected<E>, std::remove_cvref_t<U>>>;--template <typename T, typename E, typename U, typename G, typename UR, typename GR>-using expected_enable_from_other = std::enable_if_t<- std::is_constructible_v<T, UR> && std::is_constructible_v<E, GR> &&- !std::is_constructible_v<T, Expected<U, G>&> && !std::is_constructible_v<T, Expected<U, G>&&> &&- !std::is_constructible_v<T, const Expected<U, G>&> &&- !std::is_constructible_v<T, const Expected<U, G>&&> &&- !std::is_convertible_v<Expected<U, G>&, T> && !std::is_convertible_v<Expected<U, G>&&, T> &&- !std::is_convertible_v<const Expected<U, G>&, T> &&- !std::is_convertible_v<const Expected<U, G>&&, T>>;--} // namespace detail--template <typename T, typename E>-class Expected : private detail::expected_move_assign_base<T, E>,- private detail::expected_delete_ctor_base<T, E>,- private detail::expected_delete_assign_base<T, E>,- private detail::expected_default_ctor_base<T, E> {-public:- using value_type = T;- using error_type = E;- using unexpected_type = Unexpected<E>;-- constexpr Expected() = default;- constexpr Expected(const Expected&) = default;- constexpr Expected(Expected&&) = default;- Expected& operator=(const Expected&) = default;- Expected& operator=(Expected&&) = default;-- template <typename... Args, std::enable_if_t<std::is_constructible_v<T, Args&&...>>* = nullptr>- constexpr Expected(std::in_place_t, Args&&... args)- : impl_base{std::in_place, std::forward<Args>(args)...},- ctor_base{detail::default_constructor_tag{}} {}-- template <typename U, typename... Args,- std::enable_if_t<std::is_constructible_v<T, std::initializer_list<U>&, Args&&...>>* =- nullptr>- constexpr Expected(std::in_place_t, std::initializer_list<U> il, Args&&... args)- : impl_base{std::in_place, il, std::forward<Args>(args)...},- ctor_base{detail::default_constructor_tag{}} {}-- template <typename G = E, std::enable_if_t<std::is_constructible_v<E, const G&>>* = nullptr,- std::enable_if_t<!std::is_convertible_v<const G&, E>>* = nullptr>- constexpr explicit Expected(const Unexpected<G>& e)- : impl_base{unexpect_t{}, e.value()}, ctor_base{detail::default_constructor_tag{}} {}-- template <typename G = E, std::enable_if_t<std::is_constructible_v<E, const G&>>* = nullptr,- std::enable_if_t<std::is_convertible_v<const G&, E>>* = nullptr>- constexpr Expected(Unexpected<G> const& e)- : impl_base{unexpect_t{}, e.value()}, ctor_base{detail::default_constructor_tag{}} {}-- template <typename G = E, std::enable_if_t<std::is_constructible_v<E, G&&>>* = nullptr,- std::enable_if_t<!std::is_convertible_v<G&&, E>>* = nullptr>- constexpr explicit Expected(Unexpected<G>&& e) noexcept(std::is_nothrow_constructible_v<E, G&&>)- : impl_base{unexpect_t{}, std::move(e.value())}, ctor_base{- detail::default_constructor_tag{}} {}-- template <typename G = E, std::enable_if_t<std::is_constructible_v<E, G&&>>* = nullptr,- std::enable_if_t<std::is_convertible_v<G&&, E>>* = nullptr>- constexpr Expected(Unexpected<G>&& e) noexcept(std::is_nothrow_constructible_v<E, G&&>)- : impl_base{unexpect_t{}, std::move(e.value())}, ctor_base{- detail::default_constructor_tag{}} {}-- template <typename... Args, std::enable_if_t<std::is_constructible_v<E, Args&&...>>* = nullptr>- constexpr explicit Expected(unexpect_t, Args&&... args)- : impl_base{unexpect_t{}, std::forward<Args>(args)...},- ctor_base{detail::default_constructor_tag{}} {}-- template <typename U, typename... Args,- std::enable_if_t<std::is_constructible_v<E, std::initializer_list<U>&, Args&&...>>* =- nullptr>- constexpr explicit Expected(unexpect_t, std::initializer_list<U> il, Args&&... args)- : impl_base{unexpect_t{}, il, std::forward<Args>(args)...},- ctor_base{detail::default_constructor_tag{}} {}-- template <typename U, typename G,- std::enable_if_t<!(std::is_convertible_v<U const&, T> &&- std::is_convertible_v<G const&, E>)>* = nullptr,- detail::expected_enable_from_other<T, E, U, G, const U&, const G&>* = nullptr>- constexpr explicit Expected(const Expected<U, G>& rhs)- : ctor_base{detail::default_constructor_tag{}} {- if (rhs.has_value()) {- this->construct(*rhs);- } else {- this->construct_error(rhs.error());- }- }-- template <typename U, typename G,- std::enable_if_t<(std::is_convertible_v<U const&, T> &&- std::is_convertible_v<G const&, E>)>* = nullptr,- detail::expected_enable_from_other<T, E, U, G, const U&, const G&>* = nullptr>- constexpr Expected(const Expected<U, G>& rhs) : ctor_base{detail::default_constructor_tag{}} {- if (rhs.has_value()) {- this->construct(*rhs);- } else {- this->construct_error(rhs.error());- }- }-- template <typename U, typename G,- std::enable_if_t<!(std::is_convertible_v<U&&, T> && std::is_convertible_v<G&&, E>)>* =- nullptr,- detail::expected_enable_from_other<T, E, U, G, U&&, G&&>* = nullptr>- constexpr explicit Expected(Expected<U, G>&& rhs)- : ctor_base{detail::default_constructor_tag{}} {- if (rhs.has_value()) {- this->construct(std::move(*rhs));- } else {- this->construct_error(std::move(rhs.error()));- }- }-- template <typename U, typename G,- std::enable_if_t<(std::is_convertible_v<U&&, T> && std::is_convertible_v<G&&, E>)>* =- nullptr,- detail::expected_enable_from_other<T, E, U, G, U&&, G&&>* = nullptr>- constexpr Expected(Expected<U, G>&& rhs) : ctor_base{detail::default_constructor_tag{}} {- if (rhs.has_value()) {- this->construct(std::move(*rhs));- } else {- this->construct_error(std::move(rhs.error()));- }- }-- template <typename U = T, std::enable_if_t<!std::is_convertible_v<U&&, T>>* = nullptr,- detail::expected_enable_forward_value<T, E, U>* = nullptr>- constexpr explicit Expected(U&& v) : Expected{std::in_place, std::forward<U>(v)} {}-- template <typename U = T, std::enable_if_t<std::is_convertible_v<U&&, T>>* = nullptr,- detail::expected_enable_forward_value<T, E, U>* = nullptr>- constexpr Expected(U&& v) : Expected{std::in_place, std::forward<U>(v)} {}-- template <typename U = T, typename G = T,- std::enable_if_t<std::is_nothrow_constructible_v<T, U&&>>* = nullptr,- std::enable_if_t<(- !std::is_same_v<Expected<T, E>, std::remove_cvref_t<U>> &&- !std::conjunction_v<std::is_scalar<T>, std::is_same<T, std::remove_cvref_t<U>>> &&- std::is_constructible_v<T, U> && std::is_assignable_v<G&, U> &&- std::is_nothrow_move_constructible_v<E>)>* = nullptr>- Expected& operator=(U&& v) {- if (has_value()) {- val() = std::forward<U>(v);- } else {- err().~Unexpected<E>();- new (valptr()) T{std::forward<U>(v)};- this->m_has_val = true;- }-- return *this;- }-- template <typename U = T, typename G = T,- std::enable_if_t<!std::is_nothrow_constructible_v<T, U&&>>* = nullptr,- std::enable_if_t<(- !std::is_same_v<Expected<T, E>, std::remove_cvref_t<U>> &&- !std::conjunction_v<std::is_scalar<T>, std::is_same<T, std::remove_cvref_t<U>>> &&- std::is_constructible_v<T, U> && std::is_assignable_v<G&, U> &&- std::is_nothrow_move_constructible_v<E>)>* = nullptr>- Expected& operator=(U&& v) {- if (has_value()) {- val() = std::forward<U>(v);- } else {- auto tmp = std::move(err());- err().~Unexpected<E>();- new (valptr()) T{std::forward<U>(v)};- this->m_has_val = true;- }-- return *this;- }-- template <typename G = E, std::enable_if_t<std::is_nothrow_copy_constructible_v<G> &&- std::is_assignable_v<G&, G>>* = nullptr>- Expected& operator=(const Unexpected<G>& rhs) {- if (!has_value()) {- err() = rhs;- } else {- this->destroy_val();- new (errptr()) Unexpected<E>{rhs};- this->m_has_val = false;- }-- return *this;- }-- template <typename G = E, std::enable_if_t<std::is_nothrow_move_constructible_v<G> &&- std::is_move_assignable_v<G>>* = nullptr>- Expected& operator=(Unexpected<G>&& rhs) noexcept {- if (!has_value()) {- err() = std::move(rhs);- } else {- this->destroy_val();- new (errptr()) Unexpected<E>{std::move(rhs)};- this->m_has_val = false;- }-- return *this;- }-- template <typename... Args,- std::enable_if_t<std::is_nothrow_constructible_v<T, Args&&...>>* = nullptr>- void emplace(Args&&... args) {- if (has_value()) {- val() = T{std::forward<Args>(args)...};- } else {- err().~Unexpected<E>();- new (valptr()) T{std::forward<Args>(args)...};- this->m_has_val = true;- }- }-- template <typename... Args,- std::enable_if_t<!std::is_nothrow_constructible_v<T, Args&&...>>* = nullptr>- void emplace(Args&&... args) {- if (has_value()) {- val() = T{std::forward<Args>(args)...};- } else {- auto tmp = std::move(err());- err().~Unexpected<E>();- new (valptr()) T{std::forward<Args>(args)...};- this->m_has_val = true;- }- }-- template <typename U, typename... Args,- std::enable_if_t<std::is_nothrow_constructible_v<T, std::initializer_list<U>&,- Args&&...>>* = nullptr>- void emplace(std::initializer_list<U> il, Args&&... args) {- if (has_value()) {- T t{il, std::forward<Args>(args)...};- val() = std::move(t);- } else {- err().~Unexpected<E>();- new (valptr()) T{il, std::forward<Args>(args)...};- this->m_has_val = true;- }- }-- template <typename U, typename... Args,- std::enable_if_t<!std::is_nothrow_constructible_v<T, std::initializer_list<U>&,- Args&&...>>* = nullptr>- void emplace(std::initializer_list<U> il, Args&&... args) {- if (has_value()) {- T t{il, std::forward<Args>(args)...};- val() = std::move(t);- } else {- auto tmp = std::move(err());- err().~Unexpected<E>();- new (valptr()) T{il, std::forward<Args>(args)...};- this->m_has_val = true;- }- }-- constexpr T* operator->() {- return valptr();- }-- constexpr const T* operator->() const {- return valptr();- }-- template <typename U = T>- constexpr U& operator*() & {- return val();- }-- template <typename U = T>- constexpr const U& operator*() const& {- return val();- }-- template <typename U = T>- constexpr U&& operator*() && {- return std::move(val());- }-- template <typename U = T>- constexpr const U&& operator*() const&& {- return std::move(val());- }-- constexpr bool has_value() const noexcept {- return this->m_has_val;- }-- constexpr explicit operator bool() const noexcept {- return this->m_has_val;- }-- template <typename U = T>- constexpr U& value() & {- return val();- }-- template <typename U = T>- constexpr const U& value() const& {- return val();- }-- template <typename U = T>- constexpr U&& value() && {- return std::move(val());- }-- template <typename U = T>- constexpr const U&& value() const&& {- return std::move(val());- }-- constexpr E& error() & {- return err().value();- }-- constexpr const E& error() const& {- return err().value();- }-- constexpr E&& error() && {- return std::move(err().value());- }-- constexpr const E&& error() const&& {- return std::move(err().value());- }-- template <typename U>- constexpr T value_or(U&& v) const& {- static_assert(std::is_copy_constructible_v<T> && std::is_convertible_v<U&&, T>,- "T must be copy-constructible and convertible from U&&");- return bool(*this) ? **this : static_cast<T>(std::forward<U>(v));- }-- template <typename U>- constexpr T value_or(U&& v) && {- static_assert(std::is_move_constructible_v<T> && std::is_convertible_v<U&&, T>,- "T must be move-constructible and convertible from U&&");- return bool(*this) ? std::move(**this) : static_cast<T>(std::forward<U>(v));- }--private:- static_assert(!std::is_reference_v<T>, "T must not be a reference");- static_assert(!std::is_same_v<T, std::remove_cv_t<std::in_place_t>>,- "T must not be std::in_place_t");- static_assert(!std::is_same_v<T, std::remove_cv_t<unexpect_t>>, "T must not be unexpect_t");- static_assert(!std::is_same_v<T, std::remove_cv_t<Unexpected<E>>>,- "T must not be Unexpected<E>");- static_assert(!std::is_reference_v<E>, "E must not be a reference");-- T* valptr() {- return std::addressof(this->m_val);- }-- const T* valptr() const {- return std::addressof(this->m_val);- }-- Unexpected<E>* errptr() {- return std::addressof(this->m_unexpect);- }-- const Unexpected<E>* errptr() const {- return std::addressof(this->m_unexpect);- }-- template <typename U = T>- constexpr U& val() {- return this->m_val;- }-- template <typename U = T>- constexpr const U& val() const {- return this->m_val;- }-- constexpr Unexpected<E>& err() {- return this->m_unexpect;- }-- constexpr const Unexpected<E>& err() const {- return this->m_unexpect;- }-- using impl_base = detail::expected_move_assign_base<T, E>;- using ctor_base = detail::expected_default_ctor_base<T, E>;-};--template <typename T, typename E, typename U, typename F>-constexpr bool operator==(const Expected<T, E>& lhs, const Expected<U, F>& rhs) {- return (lhs.has_value() != rhs.has_value())- ? false- : (!lhs.has_value() ? lhs.error() == rhs.error() : *lhs == *rhs);-}--template <typename T, typename E, typename U, typename F>-constexpr bool operator!=(const Expected<T, E>& lhs, const Expected<U, F>& rhs) {- return !operator==(lhs, rhs);-}--template <typename T, typename E, typename U>-constexpr bool operator==(const Expected<T, E>& x, const U& v) {- return x.has_value() ? *x == v : false;-}--template <typename T, typename E, typename U>-constexpr bool operator==(const U& v, const Expected<T, E>& x) {- return x.has_value() ? *x == v : false;-}--template <typename T, typename E, typename U>-constexpr bool operator!=(const Expected<T, E>& x, const U& v) {- return !operator==(x, v);-}--template <typename T, typename E, typename U>-constexpr bool operator!=(const U& v, const Expected<T, E>& x) {- return !operator==(v, x);-}--template <typename T, typename E>-constexpr bool operator==(const Expected<T, E>& x, const Unexpected<E>& e) {- return x.has_value() ? false : x.error() == e.value();-}--template <typename T, typename E>-constexpr bool operator==(const Unexpected<E>& e, const Expected<T, E>& x) {- return x.has_value() ? false : x.error() == e.value();-}--template <typename T, typename E>-constexpr bool operator!=(const Expected<T, E>& x, const Unexpected<E>& e) {- return !operator==(x, e);-}--template <typename T, typename E>-constexpr bool operator!=(const Unexpected<E>& e, const Expected<T, E>& x) {- return !operator==(e, x);-}--} // namespace Commondiff --git a/src/core/hle/result.h b/src/core/hle/result.hindex 06ebb22be3..cfad30b992 100644--- a/src/core/hle/result.h+++ b/src/core/hle/result.h@@ -10,7 +10,6 @@#include "common/bit_field.h"#include "common/common_funcs.h"#include "common/common_types.h"-#include "common/expected.h"// All the constants in this file come from <https://switchbrew.org/wiki/Error_codes>diff --git a/src/core/hle/service/sockets/bsd.cpp b/src/core/hle/service/sockets/bsd.cppindex 6053cdd7f2..b8078bfd99 100644--- a/src/core/hle/service/sockets/bsd.cpp+++ b/src/core/hle/service/sockets/bsd.cpp@@ -24,9 +24,6 @@#include "network/network.h"#include <common/settings.h>-using Common::Expected;-using Common::Unexpected;-namespace Service::Sockets {namespace {@@ -464,13 +461,22 @@ void BSD::DuplicateSocket(HLERequestContext& ctx) {IPC::RequestParser rp{ctx};auto input = rp.PopRaw<InputParameters>();- Expected<s32, Errno> res = DuplicateSocketImpl(input.fd);IPC::ResponseBuilder rb{ctx, 4};rb.Push(ResultSuccess);- rb.PushRaw(OutputParameters{- .ret = res.value_or(0),- .bsd_errno = res ? Errno::SUCCESS : res.error(),- });++ auto const res_v = DuplicateSocketImpl(input.fd);+ if (auto* res = std::get_if<s32>(&res_v)) {+ rb.PushRaw(OutputParameters{+ .ret = *res,+ .bsd_errno = Errno::SUCCESS,+ });+ } else {+ auto* err = std::get_if<Errno>(&res_v);+ rb.PushRaw(OutputParameters{+ .ret = 0,+ .bsd_errno = *err,+ });+ }}void BSD::EventFd(HLERequestContext& ctx) {@@ -977,15 +983,15 @@ Errno BSD::CloseImpl(s32 fd) {return bsd_errno;}-Expected<s32, Errno> BSD::DuplicateSocketImpl(s32 fd) {+std::variant<s32, Errno> BSD::DuplicateSocketImpl(s32 fd) {if (!IsFileDescriptorValid(fd)) {- return Unexpected(Errno::BADF);+ return Errno::BADF;}const s32 new_fd = FindFreeFileDescriptorHandle();if (new_fd < 0) {LOG_ERROR(Service, "No more file descriptors available");- return Unexpected(Errno::MFILE);+ return Errno::MFILE;}file_descriptors[new_fd] = FileDescriptor{diff --git a/src/core/hle/service/sockets/bsd.h b/src/core/hle/service/sockets/bsd.hindex 32b5bdc3cf..15e4a33592 100644--- a/src/core/hle/service/sockets/bsd.h+++ b/src/core/hle/service/sockets/bsd.h@@ -1,4 +1,4 @@-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project// SPDX-License-Identifier: GPL-3.0-or-later// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project// SPDX-License-Identifier: GPL-2.0-or-later@@ -8,9 +8,9 @@#include <memory>#include <span>#include <vector>+#include <variant>#include "common/common_types.h"-#include "common/expected.h"#include "common/socket_types.h"#include "core/hle/service/service.h"#include "core/hle/service/sockets/sockets.h"@@ -35,7 +35,7 @@ public:// These methods are called from SSL; the first two are also called from// this class for the corresponding IPC methods.// On the real device, the SSL service makes IPC calls to this service.- Common::Expected<s32, Errno> DuplicateSocketImpl(s32 fd);+ std::variant<s32, Errno> DuplicateSocketImpl(s32 fd);Errno CloseImpl(s32 fd);std::optional<std::shared_ptr<Network::SocketBase>> GetSocket(s32 fd);diff --git a/src/core/hle/service/sockets/sfdnsres.cpp b/src/core/hle/service/sockets/sfdnsres.cppindex 13b3754c42..9e71be3547 100644--- a/src/core/hle/service/sockets/sfdnsres.cpp+++ b/src/core/hle/service/sockets/sfdnsres.cpp@@ -208,16 +208,15 @@ static std::pair<u32, GetAddrInfoError> GetHostByNameRequestImpl(HLERequestContereturn {0, GetAddrInfoError::AGAIN};}- auto res = Network::GetAddressInfo(host, /*service*/ std::nullopt);- if (!res.has_value()) {- return {0, Translate(res.error())};+ auto res_v = Network::GetAddressInfo(host, /*service*/ std::nullopt);+ if (auto* res = std::get_if<std::vector<Network::AddrInfo>>(&res_v)) {+ const std::vector<u8> data = SerializeAddrInfoAsHostEnt(*res, host);+ const u32 data_size = u32(data.size());+ ctx.WriteBuffer(data, 0);+ return {data_size, GetAddrInfoError::SUCCESS};}-- const std::vector<u8> data = SerializeAddrInfoAsHostEnt(res.value(), host);- const u32 data_size = static_cast<u32>(data.size());- ctx.WriteBuffer(data, 0);-- return {data_size, GetAddrInfoError::SUCCESS};+ auto* err = std::get_if<Network::GetAddrInfoError>(&res_v);+ return {0, Translate(*err)};}void SFDNSRES::GetHostByNameRequest(HLERequestContext& ctx) {@@ -333,16 +332,15 @@ static std::pair<u32, GetAddrInfoError> GetAddrInfoRequestImpl(HLERequestContext// Serialized hints are also passed in a buffer, but are ignored for now.- auto res = Network::GetAddressInfo(host, service);- if (!res.has_value()) {- return {0, Translate(res.error())};+ auto res_v = Network::GetAddressInfo(host, service);+ if (auto* res = std::get_if<std::vector<Network::AddrInfo>>(&res_v)) {+ const std::vector<u8> data = SerializeAddrInfo(*res, host);+ const u32 data_size = u32(data.size());+ ctx.WriteBuffer(data, 0);+ return {data_size, GetAddrInfoError::SUCCESS};}-- const std::vector<u8> data = SerializeAddrInfo(res.value(), host);- const u32 data_size = static_cast<u32>(data.size());- ctx.WriteBuffer(data, 0);-- return {data_size, GetAddrInfoError::SUCCESS};+ auto* err = std::get_if<Network::GetAddrInfoError>(&res_v);+ return {0, Translate(*err)};}void SFDNSRES::GetAddrInfoRequest(HLERequestContext& ctx) {diff --git a/src/core/hle/service/ssl/ssl.cpp b/src/core/hle/service/ssl/ssl.cppindex b66c686b2a..766673c653 100644--- a/src/core/hle/service/ssl/ssl.cpp+++ b/src/core/hle/service/ssl/ssl.cpp@@ -160,29 +160,26 @@ private:auto bsd = system.ServiceManager().GetService<Service::Sockets::BSD>("bsd:u");ASSERT_OR_EXECUTE(bsd, { return ResultInternalError; });- auto res = bsd->DuplicateSocketImpl(fd);- if (!res.has_value()) {- LOG_ERROR(Service_SSL, "Failed to duplicate socket with fd {}", fd);- return ResultInvalidSocket;- }-- const s32 duplicated_fd = *res;-- if (do_not_close_socket) {- *out_fd = duplicated_fd;- } else {- *out_fd = -1;- fd_to_close = duplicated_fd;- }-- std::optional<std::shared_ptr<Network::SocketBase>> sock = bsd->GetSocket(duplicated_fd);- if (!sock.has_value()) {- LOG_ERROR(Service_SSL, "invalid socket fd {} after duplication", duplicated_fd);- return ResultInvalidSocket;+ auto const res_v = bsd->DuplicateSocketImpl(fd);+ if (auto *res = std::get_if<s32>(&res_v)) {+ const s32 duplicated_fd = *res;+ if (do_not_close_socket) {+ *out_fd = duplicated_fd;+ } else {+ *out_fd = -1;+ fd_to_close = duplicated_fd;+ }+ std::optional<std::shared_ptr<Network::SocketBase>> sock = bsd->GetSocket(duplicated_fd);+ if (!sock.has_value()) {+ LOG_ERROR(Service_SSL, "invalid socket fd {} after duplication", duplicated_fd);+ return ResultInvalidSocket;+ }+ socket = std::move(*sock);+ backend->SetSocket(socket);+ return ResultSuccess;}- socket = std::move(*sock);- backend->SetSocket(socket);- return ResultSuccess;+ LOG_ERROR(Service_SSL, "Failed to duplicate socket with fd {}", fd);+ return ResultInvalidSocket;}Result SetHostNameImpl(const std::string& hostname) {diff --git a/src/core/internal_network/network.cpp b/src/core/internal_network/network.cppindex c95d7ca2da..077a2e042e 100644--- a/src/core/internal_network/network.cpp+++ b/src/core/internal_network/network.cpp@@ -28,7 +28,6 @@#include "common/assert.h"#include "common/common_types.h"-#include "common/expected.h"#include "common/logging.h"#include "common/settings.h"#include "core/internal_network/network.h"@@ -733,15 +732,14 @@ u32 IPv4AddressToInteger(IPv4Address ip_addr) {static_cast<u32>(ip_addr[2]) << 8 | static_cast<u32>(ip_addr[3]);}-Common::Expected<std::vector<AddrInfo>, GetAddrInfoError> GetAddressInfo(+std::variant<std::vector<AddrInfo>, GetAddrInfoError> GetAddressInfo(const std::string& host, const std::optional<std::string>& service) {addrinfo hints{};hints.ai_family = AF_INET; // Switch only supports IPv4.addrinfo* addrinfo;- s32 gai_err = getaddrinfo(host.c_str(), service.has_value() ? service->c_str() : nullptr,- &hints, &addrinfo);+ s32 gai_err = getaddrinfo(host.c_str(), service.has_value() ? service->c_str() : nullptr, &hints, &addrinfo);if (gai_err != 0) {- return Common::Unexpected(TranslateGetAddrInfoErrorFromNative(gai_err));+ return TranslateGetAddrInfoErrorFromNative(gai_err);}std::vector<AddrInfo> ret;for (auto* current = addrinfo; current; current = current->ai_next) {diff --git a/src/core/internal_network/network.h b/src/core/internal_network/network.hindex ce259c0e66..2c9ae523c5 100644--- a/src/core/internal_network/network.h+++ b/src/core/internal_network/network.h@@ -9,6 +9,7 @@#include <array>#include <optional>#include <vector>+#include <variant>#include "common/common_funcs.h"#include "common/common_types.h"@@ -124,7 +125,6 @@ std::string IPv4AddressToString(IPv4Address ip_addr);u32 IPv4AddressToInteger(IPv4Address ip_addr);// named to avoid name collision with Windows macro-Common::Expected<std::vector<AddrInfo>, GetAddrInfoError> GetAddressInfo(- const std::string& host, const std::optional<std::string>& service);+std::variant<std::vector<AddrInfo>, GetAddrInfoError> GetAddressInfo(const std::string& host, const std::optional<std::string>& service);} // namespace Network