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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
|
#pragma once
#include "preprocessor.h"
#include <util/generic/strbuf.h>
#include <array>
#include <optional>
#include <type_traits>
#include <vector>
#include <library/cpp/yt/exception/exception.h>
namespace NYT {
////////////////////////////////////////////////////////////////////////////////
/*
* Smart enumerations augment C++ enum classes with a bunch of reflection
* capabilities accessible via TEnumTraits class specialization.
*
* Please refer to the unit test for an actual example of usage
* (unittests/enum_ut.cpp).
*/
// The actual overload must be provided with DEFINE_ENUM* (see below).
template <class T>
void GetEnumTraitsImpl(T);
template <class T, class S>
constexpr bool CanFitSubtype();
template <class T>
using TEnumTraitsImpl = decltype(GetEnumTraitsImpl(T()));
template <class T>
constexpr std::optional<T> TryGetEnumUnknownValueImpl(T);
template <
class T,
bool DomainSizeKnown = requires{ TEnumTraitsImpl<T>::DomainSize; }
>
struct TEnumTraitsWithKnownDomain
{ };
template <
class T,
bool = std::is_enum_v<T> && !std::is_same_v<TEnumTraitsImpl<T>, void>
>
struct TEnumTraits
{
static constexpr bool IsEnum = false;
static constexpr bool IsBitEnum = false;
static constexpr bool IsStringSerializableEnum = false;
static constexpr bool IsMonotonic = false;
};
template <class T>
struct TEnumTraitsWithKnownDomain<T, /*DomainSizeKnown*/ true>
{
static constexpr int GetDomainSize();
static constexpr const std::array<TStringBuf, GetDomainSize()>& GetDomainNames();
static constexpr const std::array<T, GetDomainSize()>& GetDomainValues();
// For non-bit enums only.
static constexpr T GetMinValue()
requires (!TEnumTraitsImpl<T>::IsBitEnum);
static constexpr T GetMaxValue()
requires (!TEnumTraitsImpl<T>::IsBitEnum);
// For bit enums only.
static constexpr T GetAllSetValue()
requires (TEnumTraitsImpl<T>::IsBitEnum);
static std::vector<T> Decompose(T value)
requires (TEnumTraitsImpl<T>::IsBitEnum);
};
template <class T>
struct TEnumTraits<T, true>
: public TEnumTraitsWithKnownDomain<T>
{
static constexpr bool IsEnum = true;
static constexpr bool IsBitEnum = TEnumTraitsImpl<T>::IsBitEnum;
static constexpr bool IsStringSerializableEnum = TEnumTraitsImpl<T>::IsStringSerializableEnum;
static constexpr bool IsMonotonic = TEnumTraitsImpl<T>::IsMonotonic;
static TStringBuf GetTypeName();
static constexpr std::optional<T> TryGetUnknownValue();
static std::optional<TStringBuf> FindLiteralByValue(T value);
static std::optional<T> FindValueByLiteral(TStringBuf literal);
static constexpr bool IsKnownValue(T value)
requires (!TEnumTraitsImpl<T>::IsBitEnum);
static constexpr bool IsValidValue(T value);
static TString ToString(T value);
static T FromString(TStringBuf literal);
};
////////////////////////////////////////////////////////////////////////////////
//! Defines a smart enumeration with a specific underlying type.
/*!
* \param enumType Enumeration type.
* \param seq Enumeration domain encoded as a <em>sequence</em>.
* \param underlyingType Underlying type.
*/
#define DEFINE_ENUM_WITH_UNDERLYING_TYPE(enumType, underlyingType, seq) \
ENUM__CLASS(enumType, underlyingType, seq) \
ENUM__BEGIN_TRAITS(enumType, underlyingType, false, false, seq) \
ENUM__VALIDATE_UNIQUE(enumType) \
ENUM__END_TRAITS(enumType) \
static_assert(true)
//! Defines a smart enumeration with a specific underlying type.
//! Duplicate enumeration values are allowed.
#define DEFINE_AMBIGUOUS_ENUM_WITH_UNDERLYING_TYPE(enumType, underlyingType, seq) \
ENUM__CLASS(enumType, underlyingType, seq) \
ENUM__BEGIN_TRAITS(enumType, underlyingType, false, false, seq) \
ENUM__END_TRAITS(enumType) \
static_assert(true)
//! Defines a smart enumeration with the default |int| underlying type.
#define DEFINE_ENUM(enumType, seq) \
DEFINE_ENUM_WITH_UNDERLYING_TYPE(enumType, int, seq)
//! Defines a smart enumeration with a specific underlying type.
/*!
* \param enumType Enumeration type.
* \param seq Enumeration domain encoded as a <em>sequence</em>.
* \param underlyingType Underlying type.
*/
#define DEFINE_BIT_ENUM_WITH_UNDERLYING_TYPE(enumType, underlyingType, seq) \
ENUM__CLASS(enumType, underlyingType, seq) \
ENUM__BITWISE_OPS(enumType) \
ENUM__BEGIN_TRAITS(enumType, underlyingType, true, false, seq) \
ENUM__VALIDATE_UNIQUE(enumType) \
ENUM__ALL_SET_VALUE(enumType, seq) \
ENUM__END_TRAITS(enumType) \
static_assert(true)
//! Defines a smart enumeration with a specific underlying type.
//! Duplicate enumeration values are allowed.
/*!
* \param enumType Enumeration type.
* \param seq Enumeration domain encoded as a <em>sequence</em>.
* \param underlyingType Underlying type.
*/
#define DEFINE_AMBIGUOUS_BIT_ENUM_WITH_UNDERLYING_TYPE(enumType, underlyingType, seq) \
ENUM__CLASS(enumType, underlyingType, seq) \
ENUM__BITWISE_OPS(enumType) \
ENUM__BEGIN_TRAITS(enumType, underlyingType, true, false, seq) \
ENUM__ALL_SET_VALUE(enumType, seq) \
ENUM__END_TRAITS(enumType) \
static_assert(true)
//! Defines a smart enumeration with the default |unsigned int| underlying type.
/*!
* \param enumType Enumeration type.
* \param seq Enumeration domain encoded as a <em>sequence</em>.
*/
#define DEFINE_BIT_ENUM(enumType, seq) \
DEFINE_BIT_ENUM_WITH_UNDERLYING_TYPE(enumType, unsigned int, seq)
//! Defines a smart enumeration with a specific underlying type and IsStringSerializable attribute.
/*!
* \param enumType Enumeration type.
* \param seq Enumeration domain encoded as a <em>sequence</em>.
* \param underlyingType Underlying type.
*/
#define DEFINE_STRING_SERIALIZABLE_ENUM_WITH_UNDERLYING_TYPE(enumType, underlyingType, seq) \
ENUM__CLASS(enumType, underlyingType, seq) \
ENUM__BEGIN_TRAITS(enumType, underlyingType, false, true, seq) \
ENUM__VALIDATE_UNIQUE(enumType) \
ENUM__END_TRAITS(enumType) \
static_assert(true)
//! Defines a smart enumeration with a specific underlying type and IsStringSerializable attribute.
//! Duplicate enumeration values are allowed.
#define DEFINE_AMBIGUOUS_STRING_SERIALIZABLE_ENUM_WITH_UNDERLYING_TYPE(enumType, underlyingType, seq) \
ENUM__CLASS(enumType, underlyingType, seq) \
ENUM__BEGIN_TRAITS(enumType, underlyingType, false, true, seq) \
ENUM__END_TRAITS(enumType) \
static_assert(true)
//! Defines a smart enumeration with the default |int| underlying type and IsStringSerializable attribute.
#define DEFINE_STRING_SERIALIZABLE_ENUM(enumType, seq) \
DEFINE_STRING_SERIALIZABLE_ENUM_WITH_UNDERLYING_TYPE(enumType, int, seq)
//! When enum from another representation (e.g. string or protobuf integer),
//! instructs the parser to treat undeclared values as |unknownValue|.
/*!
* \param enumType Enumeration type.
* \param unknownValue A sentinel value of #enumType.
*/
#define DEFINE_ENUM_UNKNOWN_VALUE(enumType, unknownValue) \
[[maybe_unused]] constexpr std::optional<enumType> TryGetEnumUnknownValueImpl(enumType) \
{ \
return enumType::unknownValue; \
}
////////////////////////////////////////////////////////////////////////////////
//! Returns |true| iff the enumeration value is not bitwise zero.
template <typename E>
requires TEnumTraits<E>::IsBitEnum
constexpr bool Any(E value) noexcept;
//! Returns |true| iff the enumeration value is bitwise zero.
template <typename E>
requires TEnumTraits<E>::IsBitEnum
constexpr bool None(E value) noexcept;
////////////////////////////////////////////////////////////////////////////////
} // namespace NYT
#define ENUM_INL_H_
#include "enum-inl.h"
#undef ENUM_INL_H_
|
