Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-11-04 07:10:57 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/AK/Variant.h

524 lines
18 KiB
C
Raw Normal View History

AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
/*
* Copyright (c) 2021, Ali Mohammad Pur <mpfard@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/Array.h>
#include <AK/BitCast.h>
AK: Move "conditional xtor" pattern into a macro `Optional` and `Variant` both use essentially the same pattern of only declaring a copy constructor/move constructor/destructor and copy/move assignment operator if all of their template parameters have one. Let's move these into a macro to avoid code duplication and to give a name to the thing we are trying to accomplish.
2024-10-30 13:44:20 +01:00
#include <AK/Noncopyable.h>
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
#include <AK/StdLibExtras.h>
AK: Allow AK::Variant::visit to return a value This changes Variant::visit() to forward the value returned by the selected visitor invocation. By perfectly forwarding the returned value, this allows for the visitor to return by value or reference. Note that all provided visitors must return the same type - the compiler will otherwise fail with the message: "inconsistent deduction for auto return type".
2021-05-19 11:28:27 -04:00
#include <AK/TypeList.h>
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
namespace AK::Detail {
AK: Avoid the use of typeinfo in Variant typeid() and RTTI was a nice clutch to implement this, but let's move away from the horrible slowness and implement variants using type indices for faster variants.
2021-05-08 23:38:34 +04:30
template<typename T, typename IndexType, IndexType InitialIndex, typename... InTypes>
struct VariantIndexOf {
static_assert(DependentFalse<T, IndexType, InTypes...>, "Invalid VariantIndex instantiated");
};
template<typename T, typename IndexType, IndexType InitialIndex, typename InType, typename... RestOfInTypes>
struct VariantIndexOf<T, IndexType, InitialIndex, InType, RestOfInTypes...> {
consteval IndexType operator()()
{
if constexpr (IsSame<T, InType>)
return InitialIndex;
else
return VariantIndexOf<T, IndexType, InitialIndex + 1, RestOfInTypes...> {}();
}
};
template<typename T, typename IndexType, IndexType InitialIndex>
struct VariantIndexOf<T, IndexType, InitialIndex> {
consteval IndexType operator()() { return InitialIndex; }
};
template<typename T, typename IndexType, typename... Ts>
consteval IndexType index_of()
{
return VariantIndexOf<T, IndexType, 0, Ts...> {}();
}
template<typename IndexType, IndexType InitialIndex, typename... Ts>
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
struct Variant;
AK: Avoid the use of typeinfo in Variant typeid() and RTTI was a nice clutch to implement this, but let's move away from the horrible slowness and implement variants using type indices for faster variants.
2021-05-08 23:38:34 +04:30
template<typename IndexType, IndexType InitialIndex, typename F, typename... Ts>
struct Variant<IndexType, InitialIndex, F, Ts...> {
static constexpr auto current_index = VariantIndexOf<F, IndexType, InitialIndex, F, Ts...> {}();
AK: Make a bunch of Variant methods ALWAYS_INLINE
2021-06-09 20:30:07 +04:30
ALWAYS_INLINE static void delete_(IndexType id, void* data)
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
{
AK: Avoid the use of typeinfo in Variant typeid() and RTTI was a nice clutch to implement this, but let's move away from the horrible slowness and implement variants using type indices for faster variants.
2021-05-08 23:38:34 +04:30
if (id == current_index)
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
bit_cast<F*>(data)->~F();
else
AK: Avoid the use of typeinfo in Variant typeid() and RTTI was a nice clutch to implement this, but let's move away from the horrible slowness and implement variants using type indices for faster variants.
2021-05-08 23:38:34 +04:30
Variant<IndexType, InitialIndex + 1, Ts...>::delete_(id, data);
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
}
AK: Make a bunch of Variant methods ALWAYS_INLINE
2021-06-09 20:30:07 +04:30
ALWAYS_INLINE static void move_(IndexType old_id, void* old_data, void* new_data)
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
{
AK: Avoid the use of typeinfo in Variant typeid() and RTTI was a nice clutch to implement this, but let's move away from the horrible slowness and implement variants using type indices for faster variants.
2021-05-08 23:38:34 +04:30
if (old_id == current_index)
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
new (new_data) F(move(*bit_cast<F*>(old_data)));
else
AK: Avoid the use of typeinfo in Variant typeid() and RTTI was a nice clutch to implement this, but let's move away from the horrible slowness and implement variants using type indices for faster variants.
2021-05-08 23:38:34 +04:30
Variant<IndexType, InitialIndex + 1, Ts...>::move_(old_id, old_data, new_data);
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
ALWAYS_INLINE static void copy_(IndexType old_id, void const* old_data, void* new_data)
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
{
AK: Avoid the use of typeinfo in Variant typeid() and RTTI was a nice clutch to implement this, but let's move away from the horrible slowness and implement variants using type indices for faster variants.
2021-05-08 23:38:34 +04:30
if (old_id == current_index)
AK: Make a bunch of Variant methods ALWAYS_INLINE
2021-06-09 20:30:07 +04:30
new (new_data) F(*bit_cast<F const*>(old_data));
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
else
AK: Avoid the use of typeinfo in Variant typeid() and RTTI was a nice clutch to implement this, but let's move away from the horrible slowness and implement variants using type indices for faster variants.
2021-05-08 23:38:34 +04:30
Variant<IndexType, InitialIndex + 1, Ts...>::copy_(old_id, old_data, new_data);
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
}
};
AK: Avoid the use of typeinfo in Variant typeid() and RTTI was a nice clutch to implement this, but let's move away from the horrible slowness and implement variants using type indices for faster variants.
2021-05-08 23:38:34 +04:30
template<typename IndexType, IndexType InitialIndex>
struct Variant<IndexType, InitialIndex> {
AK: Make a bunch of Variant methods ALWAYS_INLINE
2021-06-09 20:30:07 +04:30
ALWAYS_INLINE static void delete_(IndexType, void*) { }
ALWAYS_INLINE static void move_(IndexType, void*, void*) { }
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
ALWAYS_INLINE static void copy_(IndexType, void const*, void*) { }
AK: Allow AK::Variant::visit to return a value This changes Variant::visit() to forward the value returned by the selected visitor invocation. By perfectly forwarding the returned value, this allows for the visitor to return by value or reference. Note that all provided visitors must return the same type - the compiler will otherwise fail with the message: "inconsistent deduction for auto return type".
2021-05-19 11:28:27 -04:00
};
template<typename IndexType, typename... Ts>
struct VisitImpl {
AK: Make Variant::visit() prefer overloads accepting T const& over T& This makes the following code behave as expected: Variant<int, String> x { some_string() }; x.visit( [](String const&) {}, // Expectation is for this to be called [](auto&) {});
2022-01-13 20:59:13 +03:30
template<typename RT, typename T, size_t I, typename Fn>
AK: Replace 'consteval' with 'constexpr' in some Variant helpers CLion and/or clangd didn't like the consteval and highlighted visit() as an error, just replace it with constexpr as it makes no difference here.
2022-02-01 03:11:59 +03:30
static constexpr bool has_explicitly_named_overload()
AK: Make Variant::visit() prefer overloads accepting T const& over T& This makes the following code behave as expected: Variant<int, String> x { some_string() }; x.visit( [](String const&) {}, // Expectation is for this to be called [](auto&) {});
2022-01-13 20:59:13 +03:30
{
// If we're not allowed to make a member function pointer and call it directly (without explicitly resolving it),
// we have a templated function on our hands (or a function overload set).
// in such cases, we don't have an explicitly named overload, and we would have to select it.
AK: Simplify Variant's explicit overload detection mechanism a bit This also allows us to remove the max-64-visitors restriction, and so removes that assertion.
2022-01-23 18:01:07 +03:30
return requires { (declval<Fn>().*(&Fn::operator()))(declval<T>()); };
AK: Make Variant::visit() prefer overloads accepting T const& over T& This makes the following code behave as expected: Variant<int, String> x { some_string() }; x.visit( [](String const&) {}, // Expectation is for this to be called [](auto&) {});
2022-01-13 20:59:13 +03:30
}
template<typename ReturnType, typename T, typename Visitor, auto... Is>
AK: Replace 'consteval' with 'constexpr' in some Variant helpers CLion and/or clangd didn't like the consteval and highlighted visit() as an error, just replace it with constexpr as it makes no difference here.
2022-02-01 03:11:59 +03:30
static constexpr bool should_invoke_const_overload(IndexSequence<Is...>)
AK: Make Variant::visit() prefer overloads accepting T const& over T& This makes the following code behave as expected: Variant<int, String> x { some_string() }; x.visit( [](String const&) {}, // Expectation is for this to be called [](auto&) {});
2022-01-13 20:59:13 +03:30
{
// Scan over all the different visitor functions, if none of them are suitable for calling with `T const&`, avoid calling that first.
AK: Simplify Variant's explicit overload detection mechanism a bit This also allows us to remove the max-64-visitors restriction, and so removes that assertion.
2022-01-23 18:01:07 +03:30
return ((has_explicitly_named_overload<ReturnType, T, Is, typename Visitor::Types::template Type<Is>>()) || ...);
AK: Make Variant::visit() prefer overloads accepting T const& over T& This makes the following code behave as expected: Variant<int, String> x { some_string() }; x.visit( [](String const&) {}, // Expectation is for this to be called [](auto&) {});
2022-01-13 20:59:13 +03:30
}
AK+Everywhere: Make Variant::visit() respect the Variant's constness ...and fix all the instances of visit() taking non-const arguments.
2022-01-13 17:31:00 +03:30
template<typename Self, typename Visitor, IndexType CurrentIndex = 0>
Everywhere: Run clang-format
2022-10-17 00:06:11 +02:00
ALWAYS_INLINE static constexpr decltype(auto) visit(Self& self, IndexType id, void const* data, Visitor&& visitor)
requires(CurrentIndex < sizeof...(Ts))
AK: Allow AK::Variant::visit to return a value This changes Variant::visit() to forward the value returned by the selected visitor invocation. By perfectly forwarding the returned value, this allows for the visitor to return by value or reference. Note that all provided visitors must return the same type - the compiler will otherwise fail with the message: "inconsistent deduction for auto return type".
2021-05-19 11:28:27 -04:00
{
using T = typename TypeList<Ts...>::template Type<CurrentIndex>;
AK: Make Variant::visit() prefer overloads accepting T const& over T& This makes the following code behave as expected: Variant<int, String> x { some_string() }; x.visit( [](String const&) {}, // Expectation is for this to be called [](auto&) {});
2022-01-13 20:59:13 +03:30
if (id == CurrentIndex) {
// Check if Visitor::operator() is an explicitly typed function (as opposed to a templated function)
// if so, try to call that with `T const&` first before copying the Variant's const-ness.
// This emulates normal C++ call semantics where templated functions are considered last, after all non-templated overloads
// are checked and found to be unusable.
using ReturnType = decltype(visitor(*bit_cast<T*>(data)));
if constexpr (should_invoke_const_overload<ReturnType, T, Visitor>(MakeIndexSequence<Visitor::Types::size>()))
return visitor(*bit_cast<AddConst<T>*>(data));
AK+Everywhere: Make Variant::visit() respect the Variant's constness ...and fix all the instances of visit() taking non-const arguments.
2022-01-13 17:31:00 +03:30
return visitor(*bit_cast<CopyConst<Self, T>*>(data));
AK: Make Variant::visit() prefer overloads accepting T const& over T& This makes the following code behave as expected: Variant<int, String> x { some_string() }; x.visit( [](String const&) {}, // Expectation is for this to be called [](auto&) {});
2022-01-13 20:59:13 +03:30
}
AK: Allow AK::Variant::visit to return a value This changes Variant::visit() to forward the value returned by the selected visitor invocation. By perfectly forwarding the returned value, this allows for the visitor to return by value or reference. Note that all provided visitors must return the same type - the compiler will otherwise fail with the message: "inconsistent deduction for auto return type".
2021-05-19 11:28:27 -04:00
if constexpr ((CurrentIndex + 1) < sizeof...(Ts))
AK+Everywhere: Make Variant::visit() respect the Variant's constness ...and fix all the instances of visit() taking non-const arguments.
2022-01-13 17:31:00 +03:30
return visit<Self, Visitor, CurrentIndex + 1>(self, id, data, forward<Visitor>(visitor));
AK: Allow AK::Variant::visit to return a value This changes Variant::visit() to forward the value returned by the selected visitor invocation. By perfectly forwarding the returned value, this allows for the visitor to return by value or reference. Note that all provided visitors must return the same type - the compiler will otherwise fail with the message: "inconsistent deduction for auto return type".
2021-05-19 11:28:27 -04:00
else
VERIFY_NOT_REACHED();
}
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
};
struct VariantNoClearTag {
explicit VariantNoClearTag() = default;
};
AK: Avoid the use of typeinfo in Variant typeid() and RTTI was a nice clutch to implement this, but let's move away from the horrible slowness and implement variants using type indices for faster variants.
2021-05-08 23:38:34 +04:30
struct VariantConstructTag {
explicit VariantConstructTag() = default;
};
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
template<typename T, typename Base>
struct VariantConstructors {
Everywhere: Make Lagom build with GCC 13 GCC 13 was released on 2023-04-26. This commit fixes Lagom build errors when using an updated host toolchain: - Adds a workaround for a bug in constraint handling, which made LibJS fail to compile: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109683 - Silences the new `-Wdangling-reference` diagnostic globally. It produces multiple false positives with no clear way to silence them without `#pragmas`. - Silences `-Wself-move` in `RefPtr` tests as GCC 13 adds this previously Clang-exclusive warning.
2023-05-01 16:59:46 +02:00
// The pointless `typename Base` constraints are a workaround for https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109683
Everywhere: Run clang-format
2022-10-17 00:06:11 +02:00
ALWAYS_INLINE VariantConstructors(T&& t)
Everywhere: Make Lagom build with GCC 13 GCC 13 was released on 2023-04-26. This commit fixes Lagom build errors when using an updated host toolchain: - Adds a workaround for a bug in constraint handling, which made LibJS fail to compile: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109683 - Silences the new `-Wdangling-reference` diagnostic globally. It produces multiple false positives with no clear way to silence them without `#pragmas`. - Silences `-Wself-move` in `RefPtr` tests as GCC 13 adds this previously Clang-exclusive warning.
2023-05-01 16:59:46 +02:00
requires(requires { T(move(t)); typename Base; })
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
{
AK: Fix Variant construction from lvalue references Fixes #7371 and appends its test cases.
2021-05-22 09:46:40 +04:30
internal_cast().clear_without_destruction();
internal_cast().set(move(t), VariantNoClearTag {});
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
}
Everywhere: Run clang-format
2022-10-17 00:06:11 +02:00
ALWAYS_INLINE VariantConstructors(T const& t)
Everywhere: Make Lagom build with GCC 13 GCC 13 was released on 2023-04-26. This commit fixes Lagom build errors when using an updated host toolchain: - Adds a workaround for a bug in constraint handling, which made LibJS fail to compile: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109683 - Silences the new `-Wdangling-reference` diagnostic globally. It produces multiple false positives with no clear way to silence them without `#pragmas`. - Silences `-Wself-move` in `RefPtr` tests as GCC 13 adds this previously Clang-exclusive warning.
2023-05-01 16:59:46 +02:00
requires(requires { T(t); typename Base; })
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
{
AK: Fix Variant construction from lvalue references Fixes #7371 and appends its test cases.
2021-05-22 09:46:40 +04:30
internal_cast().clear_without_destruction();
internal_cast().set(t, VariantNoClearTag {});
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
}
AK: Use default constructor/destructor instead of declaring an empty one Default implementations allow for more optimizations. See: https://pvs-studio.com/en/docs/warnings/v832/
2021-09-15 23:20:31 -07:00
ALWAYS_INLINE VariantConstructors() = default;
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
private:
AK: Make a bunch of Variant methods ALWAYS_INLINE
2021-06-09 20:30:07 +04:30
[[nodiscard]] ALWAYS_INLINE Base& internal_cast()
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
{
// Warning: Internal type shenanigans - VariantsConstrutors<T, Base> <- Base
// Not the other way around, so be _really_ careful not to cause issues.
AK: Use static_cast to cast to base type This is an issue on systems that don't have the empty base class optimisation (such as windows), and we normally don't need to care - however static_cast is technically the right thing to use, so let's use that instead. Co-Authored-By: Daniel Bertalan <dani@danielbertalan.dev>
2022-05-20 21:08:38 +04:30
return *static_cast<Base*>(this);
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
}
};
AK/Variant: Deduplicate the contained types This allows the construction of `Variant<int, int, int>`. While this might not seem useful, it is very useful for making variants that contain a series of member function pointers, which I plan to use in LibGL for glGenLists() and co.
2021-05-09 08:22:43 +04:30
// Type list deduplication
// Since this is a big template mess, each template is commented with how and why it works.
struct ParameterPackTag {
};
// Pack<Ts...> is just a way to pass around the type parameter pack Ts
template<typename... Ts>
struct ParameterPack : ParameterPackTag {
};
// Blank<T> is a unique replacement for T, if T is a duplicate type.
template<typename T>
struct Blank {
};
template<typename A, typename P>
inline constexpr bool IsTypeInPack = false;
// IsTypeInPack<T, Pack<Ts...>> will just return whether 'T' exists in 'Ts'.
template<typename T, typename... Ts>
inline constexpr bool IsTypeInPack<T, ParameterPack<Ts...>> = (IsSame<T, Ts> || ...);
// Replaces T with Blank<T> if it exists in Qs.
template<typename T, typename... Qs>
using BlankIfDuplicate = Conditional<(IsTypeInPack<T, Qs> || ...), Blank<T>, T>;
AK: Make IndexSequence use size_t This makes it possible to use MakeIndexSequqnce in functions like: template<typename T, size_t N> constexpr auto foo(T (&a)[N]) This means AK/StdLibExtraDetails.h must now include AK/Types.h for size_t, which means AK/Types.h can no longer include AK/StdLibExtras.h (which arguably it shouldn't do anyways), which requires rejiggering some things. (IMHO Types.h shouldn't use AK::Details metaprogramming at all. FlatPtr doesn't necessarily have to use Conditional<> and ssize_t could maybe be in its own header or something. But since it's tangential to this PR, going with the tried and true "lift things that cause the cycle up to the top" approach.)
2024-02-08 18:52:03 -05:00
template<size_t I, typename...>
AK/Variant: Deduplicate the contained types This allows the construction of `Variant<int, int, int>`. While this might not seem useful, it is very useful for making variants that contain a series of member function pointers, which I plan to use in LibGL for glGenLists() and co.
2021-05-09 08:22:43 +04:30
struct InheritFromUniqueEntries;
// InheritFromUniqueEntries will inherit from both Qs and Ts, but only scan entries going *forwards*
// that is to say, if it's scanning from index I in Qs, it won't scan for duplicates for entries before I
// as that has already been checked before.
// This makes sure that the search is linear in time (like the 'merge' step of merge sort).
AK: Make IndexSequence use size_t This makes it possible to use MakeIndexSequqnce in functions like: template<typename T, size_t N> constexpr auto foo(T (&a)[N]) This means AK/StdLibExtraDetails.h must now include AK/Types.h for size_t, which means AK/Types.h can no longer include AK/StdLibExtras.h (which arguably it shouldn't do anyways), which requires rejiggering some things. (IMHO Types.h shouldn't use AK::Details metaprogramming at all. FlatPtr doesn't necessarily have to use Conditional<> and ssize_t could maybe be in its own header or something. But since it's tangential to this PR, going with the tried and true "lift things that cause the cycle up to the top" approach.)
2024-02-08 18:52:03 -05:00
template<size_t I, typename... Ts, size_t... Js, typename... Qs>
AK/Variant: Deduplicate the contained types This allows the construction of `Variant<int, int, int>`. While this might not seem useful, it is very useful for making variants that contain a series of member function pointers, which I plan to use in LibGL for glGenLists() and co.
2021-05-09 08:22:43 +04:30
struct InheritFromUniqueEntries<I, ParameterPack<Ts...>, IndexSequence<Js...>, Qs...>
: public BlankIfDuplicate<Ts, Conditional<Js <= I, ParameterPack<>, Qs>...>... {
using BlankIfDuplicate<Ts, Conditional<Js <= I, ParameterPack<>, Qs>...>::BlankIfDuplicate...;
};
template<typename...>
struct InheritFromPacks;
// InheritFromPacks will attempt to 'merge' the pack 'Ps' with *itself*, but skip the duplicate entries
// (via InheritFromUniqueEntries).
AK: Make IndexSequence use size_t This makes it possible to use MakeIndexSequqnce in functions like: template<typename T, size_t N> constexpr auto foo(T (&a)[N]) This means AK/StdLibExtraDetails.h must now include AK/Types.h for size_t, which means AK/Types.h can no longer include AK/StdLibExtras.h (which arguably it shouldn't do anyways), which requires rejiggering some things. (IMHO Types.h shouldn't use AK::Details metaprogramming at all. FlatPtr doesn't necessarily have to use Conditional<> and ssize_t could maybe be in its own header or something. But since it's tangential to this PR, going with the tried and true "lift things that cause the cycle up to the top" approach.)
2024-02-08 18:52:03 -05:00
template<size_t... Is, typename... Ps>
AK/Variant: Deduplicate the contained types This allows the construction of `Variant<int, int, int>`. While this might not seem useful, it is very useful for making variants that contain a series of member function pointers, which I plan to use in LibGL for glGenLists() and co.
2021-05-09 08:22:43 +04:30
struct InheritFromPacks<IndexSequence<Is...>, Ps...>
: public InheritFromUniqueEntries<Is, Ps, IndexSequence<Is...>, Ps...>... {
using InheritFromUniqueEntries<Is, Ps, IndexSequence<Is...>, Ps...>::InheritFromUniqueEntries...;
};
Everywhere: Fix a bunch of typos
2021-05-17 17:48:55 +01:00
// Just a nice wrapper around InheritFromPacks, which will wrap any parameter packs in ParameterPack (unless it already is one).
AK/Variant: Deduplicate the contained types This allows the construction of `Variant<int, int, int>`. While this might not seem useful, it is very useful for making variants that contain a series of member function pointers, which I plan to use in LibGL for glGenLists() and co.
2021-05-09 08:22:43 +04:30
template<typename... Ps>
using MergeAndDeduplicatePacks = InheritFromPacks<MakeIndexSequence<sizeof...(Ps)>, Conditional<IsBaseOf<ParameterPackTag, Ps>, Ps, ParameterPack<Ps>>...>;
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
}
namespace AK {
struct Empty {
AK: Allow testing Empty instances for equality This also makes it possible to compare `Variant<Empty, Ts...>` objects if operator== exists for all Ts
2023-07-27 22:14:56 +12:00
constexpr bool operator==(Empty const&) const = default;
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
};
AK: Explictly disallow lvalue reference types within Variant This prevents an ICE with GCC trying to declare e.g. Variant<String&>. Using a concept is a bit overkill here, but clang otherwise trips over the friendship declaration to other Variant types: template<typename... NewTs> friend struct Variant; Without using a concept, clang believes this is re-declaring the Variant type with differing requirements ("error: requires clause differs in template redeclaration").
2022-10-14 14:05:46 -04:00
template<typename T>
Everywhere: Run clang-format The following command was used to clang-format these files: clang-format-16 -i $(find . \ -not \( -path "./\.*" -prune \) \ -not \( -path "./Base/*" -prune \) \ -not \( -path "./Build/*" -prune \) \ -not \( -path "./Toolchain/*" -prune \) \ -not \( -path "./Ports/*" -prune \) \ -type f -name "*.cpp" -o -name "*.h")
2023-07-07 22:44:33 -04:00
concept NotLvalueReference = !IsLvalueReference<T>;
AK: Explictly disallow lvalue reference types within Variant This prevents an ICE with GCC trying to declare e.g. Variant<String&>. Using a concept is a bit overkill here, but clang otherwise trips over the friendship declaration to other Variant types: template<typename... NewTs> friend struct Variant; Without using a concept, clang believes this is re-declaring the Variant type with differing requirements ("error: requires clause differs in template redeclaration").
2022-10-14 14:05:46 -04:00
template<NotLvalueReference... Ts>
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
struct Variant
AK/Variant: Deduplicate the contained types This allows the construction of `Variant<int, int, int>`. While this might not seem useful, it is very useful for making variants that contain a series of member function pointers, which I plan to use in LibGL for glGenLists() and co.
2021-05-09 08:22:43 +04:30
: public Detail::MergeAndDeduplicatePacks<Detail::VariantConstructors<Ts, Variant<Ts...>>...> {
AK: Make Variant's index type public This will allow the IPC system to use the exact required index type, saving transmission space, once it can send variants.
2022-11-09 16:57:26 +01:00
public:
AK: Specialize TypeList for Variant types This allows callers to use the following semantics: using MyVariant = Variant<Empty, int>; template<typename T> size_t size() { return TypeList<T>::size; } auto s = size<MyVariant>(); This will be needed for an upcoming IPC change, which will result in us knowing the Variant type, but not the underlying variadic types that the Variant holds.
2022-12-23 09:18:15 -05:00
using IndexType = Conditional<(sizeof...(Ts) < 255), u8, size_t>; // Note: size+1 reserved for internal value checks
AK: Make Variant's index type public This will allow the IPC system to use the exact required index type, saving transmission space, once it can send variants.
2022-11-09 16:57:26 +01:00
private:
AK: Avoid the use of typeinfo in Variant typeid() and RTTI was a nice clutch to implement this, but let's move away from the horrible slowness and implement variants using type indices for faster variants.
2021-05-08 23:38:34 +04:30
static constexpr IndexType invalid_index = sizeof...(Ts);
template<typename T>
static constexpr IndexType index_of() { return Detail::index_of<T, IndexType, Ts...>(); }
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
AK: Avoid the use of typeinfo in Variant typeid() and RTTI was a nice clutch to implement this, but let's move away from the horrible slowness and implement variants using type indices for faster variants.
2021-05-08 23:38:34 +04:30
public:
AK+LibWasm+LibJS: Disallow Variant.has() on types that aren't contained Checking for this (and get()'ing it) is always invalid, so let's just disallow it. This also finds two bugs where the code is checking for types that can never actually be in the variant (which was actually a refactor artifact).
2021-06-02 18:11:48 +04:30
template<typename T>
static constexpr bool can_contain()
{
return index_of<T>() != invalid_index;
}
AK: Remove Variant<Ts...>::operator Variant<NewTs...>() This is an interface to downcast(), which degrades errors into runtime errors, and allows seemingly-correct-but-not-quite constructs like the following to appear to compile, but fail at runtime: Variant<NonnullRefPtr<T>, U> foo = ...; Variant<RefPtr<T>, U> bar = foo; The expectation here is that `foo` is converted to a RefPtr<T> if it contains one, and remains a U otherwise, but in reality, the NonnullRefPtr<T> variant is simply dropped on the floor, and the resulting variant becomes invalid, failing the assertion in downcast(). This commit adds a Variant<Ts...>(Variant<NewTs...>) constructor that ensures that no alternative can be left out at compiletime, for the users that were using this interface for merely increasing the number of alternatives (for instance, LibSQL's Value class).
2021-12-25 02:12:54 +03:30
template<typename... NewTs>
Everywhere: Run clang-format
2022-10-17 00:06:11 +02:00
Variant(Variant<NewTs...>&& old)
requires((can_contain<NewTs>() && ...))
AK: Remove Variant<Ts...>::operator Variant<NewTs...>() This is an interface to downcast(), which degrades errors into runtime errors, and allows seemingly-correct-but-not-quite constructs like the following to appear to compile, but fail at runtime: Variant<NonnullRefPtr<T>, U> foo = ...; Variant<RefPtr<T>, U> bar = foo; The expectation here is that `foo` is converted to a RefPtr<T> if it contains one, and remains a U otherwise, but in reality, the NonnullRefPtr<T> variant is simply dropped on the floor, and the resulting variant becomes invalid, failing the assertion in downcast(). This commit adds a Variant<Ts...>(Variant<NewTs...>) constructor that ensures that no alternative can be left out at compiletime, for the users that were using this interface for merely increasing the number of alternatives (for instance, LibSQL's Value class).
2021-12-25 02:12:54 +03:30
: Variant(move(old).template downcast<Ts...>())
{
}
template<typename... NewTs>
Everywhere: Run clang-format
2022-10-17 00:06:11 +02:00
Variant(Variant<NewTs...> const& old)
requires((can_contain<NewTs>() && ...))
AK: Remove Variant<Ts...>::operator Variant<NewTs...>() This is an interface to downcast(), which degrades errors into runtime errors, and allows seemingly-correct-but-not-quite constructs like the following to appear to compile, but fail at runtime: Variant<NonnullRefPtr<T>, U> foo = ...; Variant<RefPtr<T>, U> bar = foo; The expectation here is that `foo` is converted to a RefPtr<T> if it contains one, and remains a U otherwise, but in reality, the NonnullRefPtr<T> variant is simply dropped on the floor, and the resulting variant becomes invalid, failing the assertion in downcast(). This commit adds a Variant<Ts...>(Variant<NewTs...>) constructor that ensures that no alternative can be left out at compiletime, for the users that were using this interface for merely increasing the number of alternatives (for instance, LibSQL's Value class).
2021-12-25 02:12:54 +03:30
: Variant(old.template downcast<Ts...>())
{
}
AK: Explictly disallow lvalue reference types within Variant This prevents an ICE with GCC trying to declare e.g. Variant<String&>. Using a concept is a bit overkill here, but clang otherwise trips over the friendship declaration to other Variant types: template<typename... NewTs> friend struct Variant; Without using a concept, clang believes this is re-declaring the Variant type with differing requirements ("error: requires clause differs in template redeclaration").
2022-10-14 14:05:46 -04:00
template<NotLvalueReference... NewTs>
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
friend struct Variant;
Everywhere: Run clang-format
2022-10-17 00:06:11 +02:00
Variant()
requires(!can_contain<Empty>())
= delete;
Variant()
requires(can_contain<Empty>())
AK: Introduce ability to default-initialize a Variant I noticed that Variant<Empty, …> is a somewhat common pattern while working on #10080, and this will simplify a few use-cases. :^)
2021-09-19 22:10:51 +02:00
: Variant(Empty())
{
}
AK+Everywhere: Delete Variant's default constructor This was exposed to the user by mistake, and even accumulated a bunch of users that didn't blow up out of sheer luck.
2021-08-13 17:31:39 +04:30
AK: Move "conditional xtor" pattern into a macro `Optional` and `Variant` both use essentially the same pattern of only declaring a copy constructor/move constructor/destructor and copy/move assignment operator if all of their template parameters have one. Let's move these into a macro to avoid code duplication and to give a name to the thing we are trying to accomplish.
2024-10-30 13:44:20 +01:00
AK_MAKE_CONDITIONALLY_COPYABLE(Variant, <Ts>&&...);
AK_MAKE_CONDITIONALLY_MOVABLE(Variant, <Ts>&&...);
AK_MAKE_CONDITIONALLY_DESTRUCTIBLE(Variant, <Ts>&&...);
AK: Use conditionally trivial special member functions This commit makes use of the conditionally trivial special member functions introduced in C++20. Basically, `Optional` and `Variant` inherits whether its wrapped type is trivially copy constructible, trivially copy assignable or trivially destructible. This lets the compiler optimize optimize a large number of their use cases. The constraints have been applied to `Optional`'s converting constructors too in order to make the API more explicit. This feature is not supported by Clang yet, so we use conditional compilation so that Lagom can be built on macOS. Once Clang has P0848R3 support, these can be removed.
2021-07-02 17:42:50 +02:00
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
ALWAYS_INLINE Variant(Variant const& old)
Everywhere: Run clang-format
2022-10-17 00:06:11 +02:00
requires(!(IsTriviallyCopyConstructible<Ts> && ...))
AK: Fix Variant's copy constructor trying to delegate to the wrong base This was forgotten in 4fdbac2.
2021-05-11 18:18:17 +04:30
: Detail::MergeAndDeduplicatePacks<Detail::VariantConstructors<Ts, Variant<Ts...>>...>()
AK: Fix Variant construction from lvalue references Fixes #7371 and appends its test cases.
2021-05-22 09:46:40 +04:30
, m_data {}
AK: Avoid the use of typeinfo in Variant typeid() and RTTI was a nice clutch to implement this, but let's move away from the horrible slowness and implement variants using type indices for faster variants.
2021-05-08 23:38:34 +04:30
, m_index(old.m_index)
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
{
AK: Avoid the use of typeinfo in Variant typeid() and RTTI was a nice clutch to implement this, but let's move away from the horrible slowness and implement variants using type indices for faster variants.
2021-05-08 23:38:34 +04:30
Helper::copy_(old.m_index, old.m_data, m_data);
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
}
// Note: A moved-from variant emulates the state of the object it contains
// so if a variant containing an int is moved from, it will still contain that int
// and if a variant with a nontrivial move ctor is moved from, it may or may not be valid
// but it will still contain the "moved-from" state of the object it previously contained.
AK: Make a bunch of Variant methods ALWAYS_INLINE
2021-06-09 20:30:07 +04:30
ALWAYS_INLINE Variant(Variant&& old)
Everywhere: Run clang-format
2022-10-17 00:06:11 +02:00
requires(!(IsTriviallyMoveConstructible<Ts> && ...))
AK/Variant: Deduplicate the contained types This allows the construction of `Variant<int, int, int>`. While this might not seem useful, it is very useful for making variants that contain a series of member function pointers, which I plan to use in LibGL for glGenLists() and co.
2021-05-09 08:22:43 +04:30
: Detail::MergeAndDeduplicatePacks<Detail::VariantConstructors<Ts, Variant<Ts...>>...>()
AK: Avoid the use of typeinfo in Variant typeid() and RTTI was a nice clutch to implement this, but let's move away from the horrible slowness and implement variants using type indices for faster variants.
2021-05-08 23:38:34 +04:30
, m_index(old.m_index)
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
{
AK: Avoid the use of typeinfo in Variant typeid() and RTTI was a nice clutch to implement this, but let's move away from the horrible slowness and implement variants using type indices for faster variants.
2021-05-08 23:38:34 +04:30
Helper::move_(old.m_index, old.m_data, m_data);
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
}
AK: Make a bunch of Variant methods ALWAYS_INLINE
2021-06-09 20:30:07 +04:30
ALWAYS_INLINE ~Variant()
Everywhere: Run clang-format
2022-10-17 00:06:11 +02:00
requires(!(IsTriviallyDestructible<Ts> && ...))
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
{
AK: Avoid the use of typeinfo in Variant typeid() and RTTI was a nice clutch to implement this, but let's move away from the horrible slowness and implement variants using type indices for faster variants.
2021-05-08 23:38:34 +04:30
Helper::delete_(m_index, m_data);
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
ALWAYS_INLINE Variant& operator=(Variant const& other)
Everywhere: Run clang-format
2022-10-17 00:06:11 +02:00
requires(!(IsTriviallyCopyConstructible<Ts> && ...) || !(IsTriviallyDestructible<Ts> && ...))
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
{
AK: Resolve clang-tidy warnings about unusual assignment operators Either not returning *this, or in the case of Variant, not checking for self assignment. In AK::Atomic, we can't return *this due to the wrapper semantics Atomic implements.
2021-10-31 14:52:26 -06:00
if (this != &other) {
if constexpr (!(IsTriviallyDestructible<Ts> && ...)) {
Helper::delete_(m_index, m_data);
}
m_index = other.m_index;
Helper::copy_(other.m_index, other.m_data, m_data);
AK: Destroy original value when assigning to Variant
2021-07-03 17:12:12 +02:00
}
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
return *this;
}
AK: Make a bunch of Variant methods ALWAYS_INLINE
2021-06-09 20:30:07 +04:30
ALWAYS_INLINE Variant& operator=(Variant&& other)
Everywhere: Run clang-format
2022-10-17 00:06:11 +02:00
requires(!(IsTriviallyMoveConstructible<Ts> && ...) || !(IsTriviallyDestructible<Ts> && ...))
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
{
AK: Resolve clang-tidy warnings about unusual assignment operators Either not returning *this, or in the case of Variant, not checking for self assignment. In AK::Atomic, we can't return *this due to the wrapper semantics Atomic implements.
2021-10-31 14:52:26 -06:00
if (this != &other) {
if constexpr (!(IsTriviallyDestructible<Ts> && ...)) {
Helper::delete_(m_index, m_data);
}
m_index = other.m_index;
Helper::move_(other.m_index, other.m_data, m_data);
AK: Destroy original value when assigning to Variant
2021-07-03 17:12:12 +02:00
}
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
return *this;
}
AK/Variant: Deduplicate the contained types This allows the construction of `Variant<int, int, int>`. While this might not seem useful, it is very useful for making variants that contain a series of member function pointers, which I plan to use in LibGL for glGenLists() and co.
2021-05-09 08:22:43 +04:30
using Detail::MergeAndDeduplicatePacks<Detail::VariantConstructors<Ts, Variant<Ts...>>...>::MergeAndDeduplicatePacks;
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
AK: Add and use the RemoveCVReference<T> type trait
2021-06-27 23:52:36 +04:30
template<typename T, typename StrippedT = RemoveCVReference<T>>
Everywhere: Run clang-format
2022-10-17 00:06:11 +02:00
void set(T&& t)
requires(can_contain<StrippedT>() && requires { StrippedT(forward<T>(t)); })
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
{
AK: Avoid the use of typeinfo in Variant typeid() and RTTI was a nice clutch to implement this, but let's move away from the horrible slowness and implement variants using type indices for faster variants.
2021-05-08 23:38:34 +04:30
constexpr auto new_index = index_of<StrippedT>();
Helper::delete_(m_index, m_data);
new (m_data) StrippedT(forward<T>(t));
m_index = new_index;
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
}
AK: Add and use the RemoveCVReference<T> type trait
2021-06-27 23:52:36 +04:30
template<typename T, typename StrippedT = RemoveCVReference<T>>
Everywhere: Run clang-format
2022-10-17 00:06:11 +02:00
void set(T&& t, Detail::VariantNoClearTag)
requires(can_contain<StrippedT>() && requires { StrippedT(forward<T>(t)); })
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
{
AK: Avoid the use of typeinfo in Variant typeid() and RTTI was a nice clutch to implement this, but let's move away from the horrible slowness and implement variants using type indices for faster variants.
2021-05-08 23:38:34 +04:30
constexpr auto new_index = index_of<StrippedT>();
new (m_data) StrippedT(forward<T>(t));
m_index = new_index;
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
}
template<typename T>
Everywhere: Run clang-format
2022-10-17 00:06:11 +02:00
T* get_pointer()
requires(can_contain<T>())
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
{
AK: Avoid the use of typeinfo in Variant typeid() and RTTI was a nice clutch to implement this, but let's move away from the horrible slowness and implement variants using type indices for faster variants.
2021-05-08 23:38:34 +04:30
if (index_of<T>() == m_index)
return bit_cast<T*>(&m_data);
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
return nullptr;
}
template<typename T>
Everywhere: Run clang-format
2022-10-17 00:06:11 +02:00
T& get()
requires(can_contain<T>())
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
{
AK: Avoid the use of typeinfo in Variant typeid() and RTTI was a nice clutch to implement this, but let's move away from the horrible slowness and implement variants using type indices for faster variants.
2021-05-08 23:38:34 +04:30
VERIFY(has<T>());
return *bit_cast<T*>(&m_data);
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
}
template<typename T>
Everywhere: Run clang-format
2022-10-17 00:06:11 +02:00
T const* get_pointer() const
requires(can_contain<T>())
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
{
AK: Avoid the use of typeinfo in Variant typeid() and RTTI was a nice clutch to implement this, but let's move away from the horrible slowness and implement variants using type indices for faster variants.
2021-05-08 23:38:34 +04:30
if (index_of<T>() == m_index)
Everywhere: Run clang-format
2022-10-17 00:06:11 +02:00
return bit_cast<T const*>(&m_data);
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
return nullptr;
}
template<typename T>
Everywhere: Run clang-format
2022-10-17 00:06:11 +02:00
T const& get() const
requires(can_contain<T>())
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
{
AK: Avoid the use of typeinfo in Variant typeid() and RTTI was a nice clutch to implement this, but let's move away from the horrible slowness and implement variants using type indices for faster variants.
2021-05-08 23:38:34 +04:30
VERIFY(has<T>());
Everywhere: Run clang-format
2022-10-17 00:06:11 +02:00
return *bit_cast<T const*>(&m_data);
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
}
template<typename T>
Everywhere: Run clang-format
2022-10-17 00:06:11 +02:00
[[nodiscard]] bool has() const
requires(can_contain<T>())
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
{
AK: Avoid the use of typeinfo in Variant typeid() and RTTI was a nice clutch to implement this, but let's move away from the horrible slowness and implement variants using type indices for faster variants.
2021-05-08 23:38:34 +04:30
return index_of<T>() == m_index;
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
}
AK+LibWeb: Implement Variant equality operator And make use of it for CSS StyleValues.
2023-02-07 21:10:15 +01:00
bool operator==(Variant const& other) const
{
return this->visit([&]<typename T>(T const& self) {
if (auto const* p = other.get_pointer<T>())
return static_cast<T const&>(self) == static_cast<T const&>(*p);
return false;
});
}
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
template<typename... Fs>
AK: Make a bunch of Variant methods ALWAYS_INLINE
2021-06-09 20:30:07 +04:30
ALWAYS_INLINE decltype(auto) visit(Fs&&... functions)
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
{
Visitor<Fs...> visitor { forward<Fs>(functions)... };
AK+Everywhere: Make Variant::visit() respect the Variant's constness ...and fix all the instances of visit() taking non-const arguments.
2022-01-13 17:31:00 +03:30
return VisitHelper::visit(*this, m_index, m_data, move(visitor));
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
}
template<typename... Fs>
AK: Make a bunch of Variant methods ALWAYS_INLINE
2021-06-09 20:30:07 +04:30
ALWAYS_INLINE decltype(auto) visit(Fs&&... functions) const
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
{
Visitor<Fs...> visitor { forward<Fs>(functions)... };
AK+Everywhere: Make Variant::visit() respect the Variant's constness ...and fix all the instances of visit() taking non-const arguments.
2022-01-13 17:31:00 +03:30
return VisitHelper::visit(*this, m_index, m_data, move(visitor));
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
}
template<typename... NewTs>
AK: Allow Variant::downcast<OtherVariantType>() We usually give type aliases to variants, so their variant types are not always available, so make it possible to downcast to another variant type.
2022-11-10 12:42:19 +03:30
decltype(auto) downcast() &&
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
{
AK: Allow Variant::downcast<OtherVariantType>() We usually give type aliases to variants, so their variant types are not always available, so make it possible to downcast to another variant type.
2022-11-10 12:42:19 +03:30
if constexpr (sizeof...(NewTs) == 1 && (IsSpecializationOf<NewTs, Variant> && ...)) {
return move(*this).template downcast_variant<NewTs...>();
} else {
Variant<NewTs...> instance { Variant<NewTs...>::invalid_index, Detail::VariantConstructTag {} };
visit([&](auto& value) {
if constexpr (Variant<NewTs...>::template can_contain<RemoveCVReference<decltype(value)>>())
instance.set(move(value), Detail::VariantNoClearTag {});
});
VERIFY(instance.m_index != instance.invalid_index);
return instance;
}
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
}
template<typename... NewTs>
AK: Allow Variant::downcast<OtherVariantType>() We usually give type aliases to variants, so their variant types are not always available, so make it possible to downcast to another variant type.
2022-11-10 12:42:19 +03:30
decltype(auto) downcast() const&
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
{
AK: Allow Variant::downcast<OtherVariantType>() We usually give type aliases to variants, so their variant types are not always available, so make it possible to downcast to another variant type.
2022-11-10 12:42:19 +03:30
if constexpr (sizeof...(NewTs) == 1 && (IsSpecializationOf<NewTs, Variant> && ...)) {
Everywhere: Remove usages of `template` keyword with no parameter list These were made invalid with P1787, and Clang (19) trunk started warning on them with https://github.com/llvm/llvm-project/pull/80801.
2024-06-04 22:19:15 +02:00
return (*this).downcast_variant(TypeWrapper<NewTs...> {});
AK: Allow Variant::downcast<OtherVariantType>() We usually give type aliases to variants, so their variant types are not always available, so make it possible to downcast to another variant type.
2022-11-10 12:42:19 +03:30
} else {
Variant<NewTs...> instance { Variant<NewTs...>::invalid_index, Detail::VariantConstructTag {} };
visit([&](auto const& value) {
if constexpr (Variant<NewTs...>::template can_contain<RemoveCVReference<decltype(value)>>())
instance.set(value, Detail::VariantNoClearTag {});
});
VERIFY(instance.m_index != instance.invalid_index);
return instance;
}
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
}
AK: Allow the user to access the variant index The average user has no need for this, but the Jakt compiler uses this to avoid going through the expensive ::visit() and ::get<>() APIs.
2022-12-09 20:16:08 +03:30
auto index() const { return m_index; }
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
private:
AK: Allow Variant::downcast<OtherVariantType>() We usually give type aliases to variants, so their variant types are not always available, so make it possible to downcast to another variant type.
2022-11-10 12:42:19 +03:30
template<typename... NewTs>
Variant<NewTs...> downcast_variant(TypeWrapper<Variant<NewTs...>>) &&
{
return move(*this).template downcast<NewTs...>();
}
template<typename... NewTs>
Variant<NewTs...> downcast_variant(TypeWrapper<Variant<NewTs...>>) const&
{
return (*this).template downcast<NewTs...>();
}
AK: Use the full name of 'integer_sequence_generate_array' in Variant.h c27abaabc449e20e8cffac245d1e2686f94e2ba6 moved this out of the global namespace, but did not qualify its users. While this seems to be fine (sometimes, somehow), let's qualify it to avoid random breakage.
2021-09-06 14:37:50 +04:30
static constexpr auto data_size = Detail::integer_sequence_generate_array<size_t>(0, IntegerSequence<size_t, sizeof(Ts)...>()).max();
static constexpr auto data_alignment = Detail::integer_sequence_generate_array<size_t>(0, IntegerSequence<size_t, alignof(Ts)...>()).max();
AK: Avoid the use of typeinfo in Variant typeid() and RTTI was a nice clutch to implement this, but let's move away from the horrible slowness and implement variants using type indices for faster variants.
2021-05-08 23:38:34 +04:30
using Helper = Detail::Variant<IndexType, 0, Ts...>;
AK: Allow AK::Variant::visit to return a value This changes Variant::visit() to forward the value returned by the selected visitor invocation. By perfectly forwarding the returned value, this allows for the visitor to return by value or reference. Note that all provided visitors must return the same type - the compiler will otherwise fail with the message: "inconsistent deduction for auto return type".
2021-05-19 11:28:27 -04:00
using VisitHelper = Detail::VisitImpl<IndexType, Ts...>;
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
AK: Fix Variant construction from lvalue references Fixes #7371 and appends its test cases.
2021-05-22 09:46:40 +04:30
template<typename T_, typename U_>
friend struct Detail::VariantConstructors;
AK: Avoid the use of typeinfo in Variant typeid() and RTTI was a nice clutch to implement this, but let's move away from the horrible slowness and implement variants using type indices for faster variants.
2021-05-08 23:38:34 +04:30
explicit Variant(IndexType index, Detail::VariantConstructTag)
: Detail::MergeAndDeduplicatePacks<Detail::VariantConstructors<Ts, Variant<Ts...>>...>()
, m_index(index)
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
{
}
AK: Make a bunch of Variant methods ALWAYS_INLINE
2021-06-09 20:30:07 +04:30
ALWAYS_INLINE void clear_without_destruction()
AK: Fix Variant construction from lvalue references Fixes #7371 and appends its test cases.
2021-05-22 09:46:40 +04:30
{
__builtin_memset(m_data, 0, data_size);
m_index = invalid_index;
}
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
template<typename... Fs>
AK: Add abstraction for forcing empty base optimization on Windows Without this annotation, the MSVC ABI is reluctant to apply EBO even in cases that are basically guaranteed on the Itanium ABI by modern compilers. This fixes an UBSAN issue with Variant on Windows.
2025-06-16 15:08:50 -06:00
struct AK_COMPACT_EMPTY_BASES Visitor : Fs... {
AK: Make Variant::visit() prefer overloads accepting T const& over T& This makes the following code behave as expected: Variant<int, String> x { some_string() }; x.visit( [](String const&) {}, // Expectation is for this to be called [](auto&) {});
2022-01-13 20:59:13 +03:30
using Types = TypeList<Fs...>;
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
Visitor(Fs&&... args)
AK: Allow AK::Variant::visit to return a value This changes Variant::visit() to forward the value returned by the selected visitor invocation. By perfectly forwarding the returned value, this allows for the visitor to return by value or reference. Note that all provided visitors must return the same type - the compiler will otherwise fail with the message: "inconsistent deduction for auto return type".
2021-05-19 11:28:27 -04:00
: Fs(forward<Fs>(args))...
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
{
}
using Fs::operator()...;
};
// Note: Make sure not to default-initialize!
// VariantConstructors::VariantConstructors(T) will set this to the correct value
// So default-constructing to anything will leave the first initialization with that value instead of the correct one.
AK: Make a bunch of Variant methods ALWAYS_INLINE
2021-06-09 20:30:07 +04:30
alignas(data_alignment) u8 m_data[data_size];
AK: Avoid the use of typeinfo in Variant typeid() and RTTI was a nice clutch to implement this, but let's move away from the horrible slowness and implement variants using type indices for faster variants.
2021-05-08 23:38:34 +04:30
IndexType m_index;
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
};
AK: Specialize TypeList for Variant types This allows callers to use the following semantics: using MyVariant = Variant<Empty, int>; template<typename T> size_t size() { return TypeList<T>::size; } auto s = size<MyVariant>(); This will be needed for an upcoming IPC change, which will result in us knowing the Variant type, but not the underlying variadic types that the Variant holds.
2022-12-23 09:18:15 -05:00
template<typename... Ts>
struct TypeList<Variant<Ts...>> : TypeList<Ts...> { };
AK: Add Flatten Variant helper This will be used in future commits. It has to be present for types, that are generated by the IDL since the IDL flattens variants of variants.
2024-11-14 14:14:36 +01:00
namespace Detail {
Meta: Enforce newlines around namespaces This has come up several times during code review, so let's just enforce it using a new clang-format 20 option.
2025-05-13 07:06:33 -04:00
AK: Add Flatten Variant helper This will be used in future commits. It has to be present for types, that are generated by the IDL since the IDL flattens variants of variants.
2024-11-14 14:14:36 +01:00
template<typename T1, typename T2>
struct FlattenVariant;
template<typename... Ts1, typename... Ts2>
struct FlattenVariant<::AK::Variant<Ts1...>, ::AK::Variant<Ts2...>> {
using type = ::AK::Variant<Ts1..., Ts2...>;
};
}
template<typename T1, typename T2>
using FlattenVariant = Detail::FlattenVariant<T1, T2>::type;
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
}
AK: Make it possible to not `using` AK classes into the global namespace This patch adds the `USING_AK_GLOBALLY` macro which is enabled by default, but can be overridden by build flags. This is a step towards integrating Jakt and AK types.
2022-11-26 12:18:30 +01:00
#if USING_AK_GLOBALLY
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
using AK::Empty;
AK: Add Flatten Variant helper This will be used in future commits. It has to be present for types, that are generated by the IDL since the IDL flattens variants of variants.
2024-11-14 14:14:36 +01:00
using AK::FlattenVariant;
AK: Add a Variant<Ts...> implementation Also adds an AK::Empty struct, because 'empty' variants are useful, but this implementation leaves that to the user (i.e. a variant cannot actually be empty, but it can contain an instance of Empty - i.e. a byte). Note that this is more of a constrained Any type, but they basically do the same things anyway :^)
2021-04-26 01:34:10 +04:30
using AK::Variant;
AK: Make it possible to not `using` AK classes into the global namespace This patch adds the `USING_AK_GLOBALLY` macro which is enabled by default, but can be overridden by build flags. This is a step towards integrating Jakt and AK types.
2022-11-26 12:18:30 +01:00
#endif
Reference in a new issue Copy permalink