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
|
#ifndef ENUM_INL_H_
#error "Direct inclusion of this file is not allowed, include enum.h"
// For the sake of sane code completion.
#include "enum.h"
#endif
#include <util/string/printf.h>
namespace NYT {
////////////////////////////////////////////////////////////////////////////////
namespace NDetail {
[[noreturn]]
void ThrowMalformedEnumValueException(
TStringBuf typeName,
TStringBuf value);
void FormatUnknownEnumValue(
TStringBuilderBase* builder,
TStringBuf name,
i64 value);
} // namespace NDetail
template <class T>
std::optional<T> TryParseEnum(TStringBuf value)
{
static_assert(TEnumTraits<T>::IsEnum);
auto tryFromString = [] (TStringBuf value) -> std::optional<T> {
T result;
if (auto ok = TEnumTraits<T>::FindValueByLiteral(DecodeEnumValue(value), &result)) {
return result;
}
return {};
};
if constexpr (TEnumTraits<T>::IsBitEnum) {
T result{};
TStringBuf token;
while (value.NextTok('|', token)) {
if (auto scalar = tryFromString(StripString(token))) {
result |= *scalar;
} else {
return {};
}
}
return result;
} else {
return tryFromString(value);
}
}
template <class T>
T ParseEnum(TStringBuf value)
{
if (auto optionalResult = TryParseEnum<T>(value)) {
return *optionalResult;
}
NYT::NDetail::ThrowMalformedEnumValueException(TEnumTraits<T>::GetTypeName(), value);
}
template <class T>
void FormatEnum(TStringBuilderBase* builder, T value, bool lowerCase)
{
static_assert(TEnumTraits<T>::IsEnum);
auto formatScalarValue = [builder, lowerCase] (T value) {
auto* literal = TEnumTraits<T>::FindLiteralByValue(value);
if (!literal) {
YT_VERIFY(!TEnumTraits<T>::IsBitEnum);
NYT::NDetail::FormatUnknownEnumValue(
builder,
TEnumTraits<T>::GetTypeName(),
static_cast<typename TEnumTraits<T>::TUnderlying>(value));
return;
}
if (lowerCase) {
CamelCaseToUnderscoreCase(builder, *literal);
} else {
builder->AppendString(*literal);
}
};
if constexpr (TEnumTraits<T>::IsBitEnum) {
if (auto* literal = TEnumTraits<T>::FindLiteralByValue(value)) {
formatScalarValue(value);
return;
}
auto first = true;
for (auto scalarValue : TEnumTraits<T>::GetDomainValues()) {
if (Any(value & scalarValue)) {
if (!first) {
builder->AppendString(TStringBuf(" | "));
}
first = false;
formatScalarValue(scalarValue);
}
}
} else {
formatScalarValue(value);
}
}
template <class T>
TString FormatEnum(T value, typename TEnumTraits<T>::TType*)
{
TStringBuilder builder;
FormatEnum(&builder, value, /*lowerCase*/ true);
return builder.Flush();
}
////////////////////////////////////////////////////////////////////////////////
} // namespace NYT
|
