1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
/*
* Copyright (C) 2025 Samuel Weinig <sam@webkit.org>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once
#include <variant>
#include <wtf/Brigand.h>
#include <wtf/CompactVariant.h>
#include <wtf/StdLibExtras.h>
#include <wtf/VariantExtras.h>
namespace WTF {
// `FlatteningVariantAdaptor` adapts "Variant-Like" types and attempts to
// minimize memory usage by *flattening* nested "Variant-Like" types.
//
// For example, take the following usage:
//
// using Foo = FlatteningVariantAdaptor<std::variant, std::variant<std::string, int>, double>;
//
// Here, `Foo` will be internally represented by:
//
// std::variant<std::string, int, double>
//
// allowing a single index to be used for all options.
//
// To add support for flattening to variant-like type, clients can specialize
// `FlatteningVariantTraits` to expose the list of the nested types.
//
// Standard aliases for a flattening `std::variant` and `CompactVariant` are
// provided called `FlatteningVariant` and `FlatteningCompactVariant`.
// MARK: - FlatteningVariantTraits
template<typename T> struct FlatteningVariantTraits {
using TypeList = brigand::list<T>;
};
template<typename... Ts> struct FlatteningVariantTraits<std::variant<Ts...>> {
using TypeList = brigand::list<Ts...>;
};
template<typename... Ts> struct FlatteningVariantTraits<CompactVariant<Ts...>> {
using TypeList = brigand::list<Ts...>;
};
// MARK: - FlatteningVariantAdaptor
template<template<typename...> typename VariantType, typename... Ts> class FlatteningVariantAdaptor {
template<typename... Us> using Wrapper = VariantType<Us...>;
public:
using TypeList = brigand::append<typename FlatteningVariantTraits<Ts>::TypeList...>;
using Representation = brigand::wrap<TypeList, Wrapper>;
template<typename T> static constexpr Representation extract(T&& value)
{
if constexpr (brigand::size<typename FlatteningVariantTraits<std::remove_cvref_t<T>>::TypeList>::value == 1)
return std::forward<T>(value);
else
return WTF::switchOn(std::forward<T>(value), []<typename U>(U&& value) { return extract(std::forward<U>(value)); });
}
template<typename T> constexpr FlatteningVariantAdaptor(T&& value)
: m_value { extract(std::forward<T>(value)) }
{
}
// Checks if type `T` is included in the flattened list of types.
template<typename T> constexpr bool holdsAlternative() const
{
return holdsAlternative<T>(m_value);
}
// Switches on the flattened list of types.
template<typename... F> decltype(auto) switchOn(F&&... functors) const
{
return WTF::switchOn(m_value, std::forward<F>(functors)...);
}
// TODO: Add `holdsAlternativeFromOriginalList` that checks all flattened alternatives for the provided type.
// TODO: Add `switchOnOriginalList` that reconstructs extracted values.
bool operator==(const FlatteningVariantAdaptor&) const = default;
private:
Representation m_value;
};
// Specialization of `FlatteningVariantTraits` for `FlatteningVariantAdaptor` itself so that
// recursively used `FlatteningVariantAdaptor` types can flatten together.
template<template<typename...> typename VariantType, typename... Ts> struct FlatteningVariantTraits<FlatteningVariantAdaptor<VariantType, Ts...>> {
using TypeList = typename FlatteningVariantAdaptor<VariantType, Ts...>::TypeList;
};
// MARK: - Standard FlatteningVariantAdaptor Aliases
template<typename... Ts> using FlatteningVariant = FlatteningVariantAdaptor<std::variant, Ts...>;
template<typename... Ts> using FlatteningCompactVariant = FlatteningVariantAdaptor<CompactVariant, Ts...>;
} // namespace WTF
using WTF::FlatteningCompactVariant;
using WTF::FlatteningVariant;
using WTF::FlatteningVariantTraits;
|
