Skip to content

Refactor some utilities for X4 #94

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
saki7 merged 1 commit into from
Sep 24, 2026
Merged

Refactor some utilities for X4 #94

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion CMakeLists.txt
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10,7 +10,7 @@ project(iris VERSION 0.0.1 LANGUAGES CXX)

get_directory_property(IRIS_PARENT_DIRECTORY PARENT_DIRECTORY)

if(DEFINED IRIS_ROOT AND NOT "${IRIS_ROOT}" PATH_EQUAL "${CMAKE_CURRENT_LIST_DIR}")
if(TARGET Iris::Iris)
message(FATAL_ERROR "Cannot include Iris more than once")
endif()

Expand Down
1 change: 1 addition & 0 deletions include/iris/alloy/traits.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -7,6 +7,7 @@

#include <iris/alloy/detail/deduce.hpp>

#include <iris/type_list.hpp>
#include <iris/bits/specialization_of.hpp>

#include <functional>
Expand Down
4 changes: 2 additions & 2 deletions include/iris/rvariant/detail/recursive_traits.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -7,7 +7,7 @@

// IWYU pragma: private, include <iris/rvariant.hpp>

#include <iris/rvariant/detail/rvariant_fwd.hpp>
#include <iris/rvariant/rvariant_fwd.hpp>

namespace iris::detail {

Expand Down Expand Up @@ -45,7 +45,7 @@ struct select_maybe_wrapped : select_maybe_wrapped_impl<false, 0, U, Ts...>
{
// Precondition: either T or recursive_wrapper<T> occurs at least once in Ts...
static_assert(sizeof...(Ts) > 0);
static_assert(!detail::is_recursive_wrapper_like_v<U>);
static_assert(!is_recursive_wrapper_v<U>);
};

template<class U, class... Ts>
Expand Down
2 changes: 1 addition & 1 deletion include/iris/rvariant/detail/variant_storage.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -7,7 +7,7 @@

// IWYU pragma: private, include <iris/rvariant.hpp>

#include <iris/rvariant/detail/rvariant_fwd.hpp>
#include <iris/rvariant/rvariant_fwd.hpp>

#include <iris/type_list.hpp>
#include <iris/bits/specialization_of.hpp>
Expand Down
2 changes: 1 addition & 1 deletion include/iris/rvariant/detail/visit.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -7,10 +7,10 @@

// IWYU pragma: private, include <iris/rvariant.hpp>

#include <iris/rvariant/detail/rvariant_fwd.hpp>
#include <iris/rvariant/detail/seq.hpp>
#include <iris/rvariant/detail/variant_storage.hpp>
#include <iris/rvariant/variant_helper.hpp>
#include <iris/rvariant/rvariant_fwd.hpp>

#include <iris/type_list.hpp>
#include <iris/type_traits.hpp>
Expand Down
72 changes: 36 additions & 36 deletions include/iris/rvariant/rvariant.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -5,12 +5,12 @@

#include <iris/config.hpp> // IWYU pragma: keep

#include <iris/rvariant/detail/rvariant_fwd.hpp>
#include <iris/rvariant/detail/variant_storage.hpp>
#include <iris/rvariant/detail/visit.hpp>
#include <iris/rvariant/detail/recursive_traits.hpp>
#include <iris/rvariant/variant_helper.hpp> // IWYU pragma: export
#include <iris/rvariant/subset.hpp>
#include <iris/rvariant/rvariant_fwd.hpp>

#include <iris/hash/FNV_hash.hpp>

Expand Down Expand Up @@ -41,7 +41,7 @@ struct check_recursive_wrapper_duplicate_impl : std::true_type {};
template<class T, class U>
requires
(!std::same_as<T, U>) &&
(is_recursive_wrapper_like_v<T> || is_recursive_wrapper_like_v<U>) &&
(is_recursive_wrapper_v<T> || is_recursive_wrapper_v<U>) &&
std::same_as<unwrap_recursive_t<T>, unwrap_recursive_t<U>>
struct check_recursive_wrapper_duplicate_impl<T, U>
: std::false_type
Expand All @@ -66,7 +66,7 @@ template<class T, class List>
struct non_wrapped_exactly_once : exactly_once<T, List>
{
static_assert(
!detail::is_recursive_wrapper_like_v<T>,
!is_recursive_wrapper_v<T>,
"Constructing a `recursive_wrapper` alternative with its full type as the tag is "
"prohibited to avoid confusion; just specify `T` instead."
);
Expand Down Expand Up @@ -167,9 +167,9 @@ struct rvariant_base
IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_BEGIN
// Primary constructor called from derived class
template<std::size_t I, class... Args>
requires std::is_constructible_v<pack_indexing_t<I, Ts...>, Args...>
requires std::is_constructible_v<IRIS_PACK_INDEXING(I, Ts...), Args...>
constexpr explicit rvariant_base(std::in_place_index_t<I>, Args&&... args)
noexcept(std::is_nothrow_constructible_v<pack_indexing_t<I, Ts...>, Args...>)
noexcept(std::is_nothrow_constructible_v<IRIS_PACK_INDEXING(I, Ts...), Args...>)
: storage_(std::in_place_index<I>, std::forward<Args>(args)...)
, index_{static_cast<variant_index_t<sizeof...(Ts)>>(I)}
{}
Expand Down Expand Up @@ -291,7 +291,7 @@ IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_END
{
if constexpr (need_destructor_call) {
// ReSharper disable once CppTypeAliasNeverUsed
using T = pack_indexing_t<I, Ts...>;
using T = IRIS_PACK_INDEXING(I, Ts...);
auto&& alt = raw_get<I>(storage_);
alt.~T();
}
Expand Down Expand Up @@ -330,7 +330,7 @@ IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_END
assert(index_ == I);
if constexpr (I != std::variant_npos) {
// ReSharper disable once CppTypeAliasNeverUsed
using T = pack_indexing_t<I, Ts...>;
using T = IRIS_PACK_INDEXING(I, Ts...);
auto&& alt = raw_get<I>(storage_);
alt.~T();
index_ = variant_npos<sizeof...(Ts)>;
Expand All @@ -340,7 +340,7 @@ IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_END
IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_BEGIN
template<std::size_t I, class... Args>
constexpr void construct_on_valueless(Args&&... args)
noexcept(std::is_nothrow_constructible_v<pack_indexing_t<I, Ts...>, Args...>)
noexcept(std::is_nothrow_constructible_v<IRIS_PACK_INDEXING(I, Ts...), Args...>)
{
static_assert(I != std::variant_npos);
assert(index_ == variant_npos<sizeof...(Ts)>);
Expand All @@ -350,7 +350,7 @@ IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_BEGIN

template<std::size_t I, class... Args>
constexpr void reset_construct(Args&&... args)
noexcept(std::is_nothrow_constructible_v<pack_indexing_t<I, Ts...>, Args...>)
noexcept(std::is_nothrow_constructible_v<IRIS_PACK_INDEXING(I, Ts...), Args...>)
{
static_assert(I != std::variant_npos);
visit_reset();
Expand All @@ -360,11 +360,11 @@ IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_BEGIN

template<std::size_t i, std::size_t j, class... Args>
constexpr void reset_construct(Args&&... args)
noexcept(std::is_nothrow_constructible_v<pack_indexing_t<j, Ts...>, Args...>)
noexcept(std::is_nothrow_constructible_v<IRIS_PACK_INDEXING(j, Ts...), Args...>)
{
if constexpr (i != std::variant_npos) {
destroy<i>();
if constexpr (!std::is_nothrow_constructible_v<pack_indexing_t<j, Ts...>, Args...>) {
if constexpr (!std::is_nothrow_constructible_v<IRIS_PACK_INDEXING(j, Ts...), Args...>) {
index_ = variant_npos<sizeof...(Ts)>;
}
}
Expand All @@ -377,7 +377,7 @@ IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_BEGIN
constexpr void reset_construct_never_valueless(Args&&... args) noexcept
{
static_assert(I != std::variant_npos);
static_assert(std::is_nothrow_constructible_v<pack_indexing_t<I, Ts...>, Args...>);
static_assert(std::is_nothrow_constructible_v<IRIS_PACK_INDEXING(I, Ts...), Args...>);
static_assert(std::is_nothrow_constructible_v<storage_type, std::in_place_index_t<I>, Args...>);
visit_destroy();
std::construct_at(&storage_, std::in_place_index<I>, std::forward<Args>(args)...);
Expand Down Expand Up @@ -406,13 +406,13 @@ IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_END

IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_BEGIN
template<std::size_t I, class... Args>
requires std::is_constructible_v<pack_indexing_t<I, Ts...>, Args...>
requires std::is_constructible_v<IRIS_PACK_INDEXING(I, Ts...), Args...>
constexpr variant_alternative_t<I, rvariant<Ts...>>&
emplace_impl(Args&&... args)
noexcept(std::is_nothrow_constructible_v<pack_indexing_t<I, Ts...>, Args...>) IRIS_LIFETIMEBOUND
noexcept(std::is_nothrow_constructible_v<IRIS_PACK_INDEXING(I, Ts...), Args...>) IRIS_LIFETIMEBOUND
{
static_assert(I < sizeof...(Ts));
using T = pack_indexing_t<I, Ts...>;
using T = IRIS_PACK_INDEXING(I, Ts...);

#ifndef NDEBUG
// Self-emplace on non-valueless instance ALWAYS leads to UB.
Expand Down Expand Up @@ -470,7 +470,7 @@ IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_BEGIN
} else if constexpr (std::is_same_v<T_old_i, T>) { // NOT type-changing
if constexpr (
(sizeof(T) <= detail::never_valueless_trivial_size_limit && std::is_trivially_move_assignable_v<T>) ||
detail::is_recursive_wrapper_like_v<T>
is_recursive_wrapper_v<T>
) {
T tmp{std::forward<Args>(args)...}; // may throw
static_assert(noexcept(t_old_i = std::move(tmp)));
Expand All @@ -493,7 +493,7 @@ IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_BEGIN
} else { // type-changing
if constexpr (
(sizeof(T) <= detail::never_valueless_trivial_size_limit && std::is_trivially_move_constructible_v<T>) ||
detail::is_recursive_wrapper_like_v<T>
is_recursive_wrapper_v<T>
) {
T tmp{std::forward<Args>(args)...}; // may throw
t_old_i.~T_old_i();
Expand Down Expand Up @@ -610,8 +610,8 @@ class rvariant : private detail::rvariant_base_t<Ts...>
using base_type::index;

// Default constructor
constexpr rvariant() noexcept(std::is_nothrow_default_constructible_v<pack_indexing_t<0, Ts...>>)
requires std::is_default_constructible_v<pack_indexing_t<0, Ts...>>
constexpr rvariant() noexcept(std::is_nothrow_default_constructible_v<IRIS_PACK_INDEXING(0, Ts...)>)
requires std::is_default_constructible_v<IRIS_PACK_INDEXING(0, Ts...)>
: base_type(std::in_place_index<0>) // value-initialized
{}

Expand Down Expand Up @@ -840,19 +840,19 @@ IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_END
template<std::size_t I, class... Args>
requires
(I < sizeof...(Ts)) &&
std::is_constructible_v<pack_indexing_t<I, Ts...>, Args...>
std::is_constructible_v<IRIS_PACK_INDEXING(I, Ts...), Args...>
constexpr explicit rvariant(std::in_place_index_t<I>, Args&&... args) // NOLINT
noexcept(std::is_nothrow_constructible_v<pack_indexing_t<I, Ts...>, Args...>)
noexcept(std::is_nothrow_constructible_v<IRIS_PACK_INDEXING(I, Ts...), Args...>)
: base_type(std::in_place_index<I>, std::forward<Args>(args)...)
{}

// in_place_index<I>, il, args...
template<std::size_t I, class U, class... Args>
requires
(I < sizeof...(Ts)) &&
std::is_constructible_v<pack_indexing_t<I, Ts...>, std::initializer_list<U>&, Args...>
std::is_constructible_v<IRIS_PACK_INDEXING(I, Ts...), std::initializer_list<U>&, Args...>
constexpr explicit rvariant(std::in_place_index_t<I>, std::initializer_list<U> il, Args&&... args) // NOLINT
noexcept(std::is_nothrow_constructible_v<pack_indexing_t<I, Ts...>, std::initializer_list<U>&, Args...>)
noexcept(std::is_nothrow_constructible_v<IRIS_PACK_INDEXING(I, Ts...), std::initializer_list<U>&, Args...>)
: base_type(std::in_place_index<I>, il, std::forward<Args>(args)...)
{}

Expand All @@ -879,20 +879,20 @@ IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_END
}

template<std::size_t I, class... Args>
requires std::is_constructible_v<pack_indexing_t<I, Ts...>, Args...>
requires std::is_constructible_v<IRIS_PACK_INDEXING(I, Ts...), Args...>
constexpr variant_alternative_t<I, rvariant>&
emplace(Args&&... args)
noexcept(std::is_nothrow_constructible_v<pack_indexing_t<I, Ts...>, Args...>) IRIS_LIFETIMEBOUND
noexcept(std::is_nothrow_constructible_v<IRIS_PACK_INDEXING(I, Ts...), Args...>) IRIS_LIFETIMEBOUND
{
static_assert(I < sizeof...(Ts));
return base_type::template emplace_impl<I>(std::forward<Args>(args)...);
}

template<std::size_t I, class U, class... Args>
requires std::is_constructible_v<pack_indexing_t<I, Ts...>, std::initializer_list<U>&, Args...>
requires std::is_constructible_v<IRIS_PACK_INDEXING(I, Ts...), std::initializer_list<U>&, Args...>
constexpr variant_alternative_t<I, rvariant>&
emplace(std::initializer_list<U> il, Args&&... args)
noexcept(std::is_nothrow_constructible_v<pack_indexing_t<I, Ts...>, std::initializer_list<U>&, Args...>) IRIS_LIFETIMEBOUND
noexcept(std::is_nothrow_constructible_v<IRIS_PACK_INDEXING(I, Ts...), std::initializer_list<U>&, Args...>) IRIS_LIFETIMEBOUND
{
static_assert(I < sizeof...(Ts));
return base_type::template emplace_impl<I>(il, std::forward<Args>(args)...);
Expand Down Expand Up @@ -1193,7 +1193,7 @@ IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_END
// -------------------------------------------------

template<class T, class... Ts>
requires detail::is_recursive_wrapper_like_v<T>
requires is_recursive_wrapper_v<T>
[[nodiscard]] constexpr bool holds_alternative(rvariant<Ts...> const& v) noexcept = delete;

template<class T, class... Ts>
Expand Down Expand Up @@ -1294,19 +1294,19 @@ get(rvariant<Ts...> const&& v IRIS_LIFETIMEBOUND)
}

template<class T, class... Ts>
requires detail::is_recursive_wrapper_like_v<T>
requires is_recursive_wrapper_v<T>
constexpr T& get(rvariant<Ts...>&) = delete;

template<class T, class... Ts>
requires detail::is_recursive_wrapper_like_v<T>
requires is_recursive_wrapper_v<T>
constexpr T&& get(rvariant<Ts...>&&) = delete;

template<class T, class... Ts>
requires detail::is_recursive_wrapper_like_v<T>
requires is_recursive_wrapper_v<T>
constexpr T const& get(rvariant<Ts...> const&) = delete;

template<class T, class... Ts>
requires detail::is_recursive_wrapper_like_v<T>
requires is_recursive_wrapper_v<T>
constexpr T const&& get(rvariant<Ts...> const&&) = delete;

// -------------------------------------------------
Expand Down Expand Up @@ -1375,19 +1375,19 @@ unsafe_get(rvariant<Ts...> const&& v IRIS_LIFETIMEBOUND) noexcept
}

template<class T, class... Ts>
requires detail::is_recursive_wrapper_like_v<T>
requires is_recursive_wrapper_v<T>
constexpr T& unsafe_get(rvariant<Ts...>&) = delete;

template<class T, class... Ts>
requires detail::is_recursive_wrapper_like_v<T>
requires is_recursive_wrapper_v<T>
constexpr T&& unsafe_get(rvariant<Ts...>&&) = delete;

template<class T, class... Ts>
requires detail::is_recursive_wrapper_like_v<T>
requires is_recursive_wrapper_v<T>
constexpr T const& unsafe_get(rvariant<Ts...> const&) = delete;

template<class T, class... Ts>
requires detail::is_recursive_wrapper_like_v<T>
requires is_recursive_wrapper_v<T>
constexpr T const&& unsafe_get(rvariant<Ts...> const&&) = delete;

// ---------------------------------------------
Expand Down
14 changes: 10 additions & 4 deletions ...ude/iris/rvariant/detail/rvariant_fwd.hpp → include/iris/rvariant/rvariant_fwd.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,12 +1,10 @@
#ifndef IRIS_ZZ_RVARIANT_DETAIL_RVARIANT_FWD_HPP
#define IRIS_ZZ_RVARIANT_DETAIL_RVARIANT_FWD_HPP
#ifndef IRIS_ZZ_RVARIANT_RVARIANT_FWD_HPP
#define IRIS_ZZ_RVARIANT_RVARIANT_FWD_HPP

// SPDX-License-Identifier: MIT

#include <iris/config.hpp> // IWYU pragma: keep

#include <cstddef> // IWYU pragma: keep

namespace iris {

template<class... Ts>
Expand All @@ -18,6 +16,14 @@ class recursive_wrapper;
template<class T, class Allocator>
class recursive_wrapper_alloca;

template<class T>
inline constexpr bool is_recursive_wrapper_v = false;

template<class T>
inline constexpr bool is_recursive_wrapper_v<recursive_wrapper<T>> = true;

template<class T, class Allocator>
inline constexpr bool is_recursive_wrapper_v<recursive_wrapper_alloca<T, Allocator>> = true;

namespace detail {

Expand Down
2 changes: 1 addition & 1 deletion include/iris/rvariant/subset.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -5,8 +5,8 @@

#include <iris/config.hpp> // IWYU pragma: keep

#include <iris/rvariant/detail/rvariant_fwd.hpp>
#include <iris/rvariant/variant_helper.hpp>
#include <iris/rvariant/rvariant_fwd.hpp>
#include <iris/type_list.hpp>

#include <iris/bits/specialization_of.hpp>
Expand Down
18 changes: 6 additions & 12 deletions include/iris/rvariant/variant_helper.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -11,13 +11,12 @@

#include <iris/config.hpp> // IWYU pragma: keep

#include <iris/rvariant/detail/rvariant_fwd.hpp>
#include <iris/rvariant/rvariant_fwd.hpp>
#include <iris/type_list.hpp>
#include <iris/bits/specialization_of.hpp>

#include <utility>
#include <type_traits>
#include <cstddef>

#include <cstddef> // IWYU pragma: keep

namespace iris {

Expand Down Expand Up @@ -72,11 +71,6 @@ struct variant_size<rvariant<Ts...>> : std::integral_constant<std::size_t, sizeo

namespace detail {

template<class T>
constexpr bool is_recursive_wrapper_like_v =
is_ttp_specialization_of_v<T, recursive_wrapper> ||
is_ttp_specialization_of_v<T, recursive_wrapper_alloca>;

template<class T>
struct unwrap_recursive_impl
{
Expand Down Expand Up @@ -119,10 +113,10 @@ struct unwrap_recursive_fn
[[nodiscard]] IRIS_FORCEINLINE static constexpr auto&&
operator()(T&& o IRIS_LIFETIMEBOUND) noexcept
{
if constexpr (is_recursive_wrapper_like_v<std::remove_cvref_t<T>>) {
return *std::forward<T>(o);
if constexpr (is_recursive_wrapper_v<std::remove_cvref_t<T>>) {
return *static_cast<T&&>(o);
} else {
return std::forward<T>(o);
return static_cast<T&&>(o);
}
}
};
Expand Down
Loading
Loading