aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/common/CMakeLists.txt1
-rw-r--r--src/common/expected.h986
-rw-r--r--src/core/hle/result.h1
-rw-r--r--src/core/hle/service/sockets/bsd.cpp28
-rw-r--r--src/core/hle/service/sockets/bsd.h6
-rw-r--r--src/core/hle/service/sockets/sfdnsres.cpp34
-rw-r--r--src/core/hle/service/ssl/ssl.cpp41
-rw-r--r--src/core/internal_network/network.cpp8
-rw-r--r--src/core/internal_network/network.h4
9 files changed, 60 insertions, 1049 deletions
diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt
index 786effa6bd..7bb4c3aa4a 100644
--- a/src/common/CMakeLists.txt
+++ b/src/common/CMakeLists.txt
@@ -50,7 +50,6 @@ add_library(
elf.h
error.cpp
error.h
- expected.h
fiber.cpp
fiber.h
fixed_point.h
diff --git a/src/common/expected.h b/src/common/expected.h
deleted file mode 100644
index 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 Common
diff --git a/src/core/hle/result.h b/src/core/hle/result.h
index 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.cpp
index 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.h
index 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.cpp
index 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(HLERequestConte
return {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.cpp
index 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.cpp
index 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.h
index 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
generated by cgit v1.2.3 (git 2.39.1) at 2026-11-04 03:27:11 +0000