Skip to content

Commit e21db03

Browse files
jckingcopybara-github
jcking
authored and
copybara-github
committed
Implement hand-rolled variant for cel::ListValue
PiperOrigin-RevId: 740338496
1 parent 0e3539e commit e21db03

File tree

4 files changed

+319
-175
lines changed

4 files changed

+319
-175
lines changed

‎common/values/list_value.cc‎

Lines changed: 91 additions & 86 deletions
Original file line numberDiff line numberDiff line change
@@ -21,9 +21,8 @@
2121
#include "absl/status/status.h"
2222
#include "absl/status/statusor.h"
2323
#include "absl/strings/cord.h"
24-
#include "absl/strings/string_view.h"
2524
#include "absl/types/optional.h"
26-
#include "absl/types/variant.h"
25+
#include "common/native_type.h"
2726
#include "common/optional_ref.h"
2827
#include "common/value.h"
2928
#include "common/values/value_variant.h"
@@ -34,58 +33,60 @@
3433

3534
namespace cel {
3635

37-
absl::string_view ListValue::GetTypeName() const {
38-
return absl::visit(
39-
[](const auto& alternative) -> absl::string_view {
40-
return alternative.GetTypeName();
41-
},
42-
variant_);
36+
NativeTypeId ListValue::GetTypeId() const {
37+
return variant_.Visit([](const auto& alternative) -> NativeTypeId {
38+
return NativeTypeId::Of(alternative);
39+
});
4340
}
4441

4542
std::string ListValue::DebugString() const {
46-
return absl::visit(
47-
[](const auto& alternative) -> std::string {
48-
return alternative.DebugString();
49-
},
50-
variant_);
43+
return variant_.Visit([](const auto& alternative) -> std::string {
44+
return alternative.DebugString();
45+
});
5146
}
5247

5348
absl::Status ListValue::SerializeTo(
5449
absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
5550
absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
5651
absl::Nonnull<absl::Cord*> value) const {
57-
return absl::visit(
58-
[descriptor_pool, message_factory,
59-
value](const auto& alternative) -> absl::Status {
60-
return alternative.SerializeTo(descriptor_pool, message_factory, value);
61-
},
62-
variant_);
52+
ABSL_DCHECK(descriptor_pool != nullptr);
53+
ABSL_DCHECK(message_factory != nullptr);
54+
ABSL_DCHECK(value != nullptr);
55+
56+
return variant_.Visit([&](const auto& alternative) -> absl::Status {
57+
return alternative.SerializeTo(descriptor_pool, message_factory, value);
58+
});
6359
}
6460

6561
absl::Status ListValue::ConvertToJson(
6662
absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
6763
absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
6864
absl::Nonnull<google::protobuf::Message*> json) const {
69-
return absl::visit(
70-
[descriptor_pool, message_factory,
71-
json](const auto& alternative) -> absl::Status {
72-
return alternative.ConvertToJson(descriptor_pool, message_factory,
73-
json);
74-
},
75-
variant_);
65+
ABSL_DCHECK(descriptor_pool != nullptr);
66+
ABSL_DCHECK(message_factory != nullptr);
67+
ABSL_DCHECK(json != nullptr);
68+
ABSL_DCHECK_EQ(json->GetDescriptor()->well_known_type(),
69+
google::protobuf::Descriptor::WELLKNOWNTYPE_VALUE);
70+
71+
return variant_.Visit([&](const auto& alternative) -> absl::Status {
72+
return alternative.ConvertToJson(descriptor_pool, message_factory, json);
73+
});
7674
}
7775

7876
absl::Status ListValue::ConvertToJsonArray(
7977
absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
8078
absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
8179
absl::Nonnull<google::protobuf::Message*> json) const {
82-
return absl::visit(
83-
[descriptor_pool, message_factory,
84-
json](const auto& alternative) -> absl::Status {
85-
return alternative.ConvertToJsonArray(descriptor_pool, message_factory,
86-
json);
87-
},
88-
variant_);
80+
ABSL_DCHECK(descriptor_pool != nullptr);
81+
ABSL_DCHECK(message_factory != nullptr);
82+
ABSL_DCHECK(json != nullptr);
83+
ABSL_DCHECK_EQ(json->GetDescriptor()->well_known_type(),
84+
google::protobuf::Descriptor::WELLKNOWNTYPE_LISTVALUE);
85+
86+
return variant_.Visit([&](const auto& alternative) -> absl::Status {
87+
return alternative.ConvertToJsonArray(descriptor_pool, message_factory,
88+
json);
89+
});
8990
}
9091

9192
absl::Status ListValue::Equal(
@@ -98,78 +99,81 @@ absl::Status ListValue::Equal(
9899
ABSL_DCHECK(arena != nullptr);
99100
ABSL_DCHECK(result != nullptr);
100101

101-
return absl::visit(
102-
[&other, descriptor_pool, message_factory, arena,
103-
result](const auto& alternative) -> absl::Status {
104-
return alternative.Equal(other, descriptor_pool, message_factory, arena,
105-
result);
106-
},
107-
variant_);
102+
return variant_.Visit([&](const auto& alternative) -> absl::Status {
103+
return alternative.Equal(other, descriptor_pool, message_factory, arena,
104+
result);
105+
});
108106
}
109107

110108
bool ListValue::IsZeroValue() const {
111-
return absl::visit(
112-
[](const auto& alternative) -> bool { return alternative.IsZeroValue(); },
113-
variant_);
109+
return variant_.Visit([](const auto& alternative) -> bool {
110+
return alternative.IsZeroValue();
111+
});
114112
}
115113

116114
absl::StatusOr<bool> ListValue::IsEmpty() const {
117-
return absl::visit(
118-
[](const auto& alternative) -> bool { return alternative.IsEmpty(); },
119-
variant_);
115+
return variant_.Visit([](const auto& alternative) -> absl::StatusOr<bool> {
116+
return alternative.IsEmpty();
117+
});
120118
}
121119

122120
absl::StatusOr<size_t> ListValue::Size() const {
123-
return absl::visit(
124-
[](const auto& alternative) -> size_t { return alternative.Size(); },
125-
variant_);
121+
return variant_.Visit([](const auto& alternative) -> absl::StatusOr<size_t> {
122+
return alternative.Size();
123+
});
126124
}
127125

128126
absl::Status ListValue::Get(
129127
size_t index, absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
130128
absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
131129
absl::Nonnull<google::protobuf::Arena*> arena, absl::Nonnull<Value*> result) const {
132-
return absl::visit(
133-
[&](const auto& alternative) -> absl::Status {
134-
return alternative.Get(index, descriptor_pool, message_factory, arena,
135-
result);
136-
},
137-
variant_);
130+
ABSL_DCHECK(descriptor_pool != nullptr);
131+
ABSL_DCHECK(message_factory != nullptr);
132+
ABSL_DCHECK(arena != nullptr);
133+
ABSL_DCHECK(result != nullptr);
134+
135+
return variant_.Visit([&](const auto& alternative) -> absl::Status {
136+
return alternative.Get(index, descriptor_pool, message_factory, arena,
137+
result);
138+
});
138139
}
139140

140141
absl::Status ListValue::ForEach(
141142
ForEachWithIndexCallback callback,
142143
absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
143144
absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
144145
absl::Nonnull<google::protobuf::Arena*> arena) const {
145-
return absl::visit(
146-
[&](const auto& alternative) -> absl::Status {
147-
return alternative.ForEach(callback, descriptor_pool, message_factory,
148-
arena);
149-
},
150-
variant_);
146+
ABSL_DCHECK(descriptor_pool != nullptr);
147+
ABSL_DCHECK(message_factory != nullptr);
148+
ABSL_DCHECK(arena != nullptr);
149+
150+
return variant_.Visit([&](const auto& alternative) -> absl::Status {
151+
return alternative.ForEach(callback, descriptor_pool, message_factory,
152+
arena);
153+
});
151154
}
152155

153156
absl::StatusOr<absl::Nonnull<ValueIteratorPtr>> ListValue::NewIterator() const {
154-
return absl::visit(
155-
[](const auto& alternative)
156-
-> absl::StatusOr<absl::Nonnull<ValueIteratorPtr>> {
157-
return alternative.NewIterator();
158-
},
159-
variant_);
157+
return variant_.Visit([](const auto& alternative)
158+
-> absl::StatusOr<absl::Nonnull<ValueIteratorPtr>> {
159+
return alternative.NewIterator();
160+
});
160161
}
161162

162163
absl::Status ListValue::Contains(
163164
const Value& other,
164165
absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
165166
absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
166167
absl::Nonnull<google::protobuf::Arena*> arena, absl::Nonnull<Value*> result) const {
167-
return absl::visit(
168-
[&](const auto& alternative) -> absl::Status {
169-
return alternative.Contains(other, descriptor_pool, message_factory,
170-
arena, result);
171-
},
172-
variant_);
168+
ABSL_DCHECK(descriptor_pool != nullptr);
169+
ABSL_DCHECK(message_factory != nullptr);
170+
ABSL_DCHECK(arena != nullptr);
171+
ABSL_DCHECK(result != nullptr);
172+
173+
return variant_.Visit([&](const auto& alternative) -> absl::Status {
174+
return alternative.Contains(other, descriptor_pool, message_factory, arena,
175+
result);
176+
});
173177
}
174178

175179
namespace common_internal {
@@ -255,45 +259,46 @@ absl::Status ListValueEqual(
255259
} // namespace common_internal
256260

257261
optional_ref<const CustomListValue> ListValue::AsCustom() const& {
258-
if (const auto* alt = absl::get_if<CustomListValue>(&variant_);
259-
alt != nullptr) {
260-
return *alt;
262+
if (const auto* alternative = variant_.As<CustomListValue>();
263+
alternative != nullptr) {
264+
return *alternative;
261265
}
262266
return absl::nullopt;
263267
}
264268

265269
absl::optional<CustomListValue> ListValue::AsCustom() && {
266-
if (auto* alt = absl::get_if<CustomListValue>(&variant_); alt != nullptr) {
267-
return std::move(*alt);
270+
if (auto* alternative = variant_.As<CustomListValue>();
271+
alternative != nullptr) {
272+
return std::move(*alternative);
268273
}
269274
return absl::nullopt;
270275
}
271276

272277
const CustomListValue& ListValue::GetCustom() const& {
273278
ABSL_DCHECK(IsCustom());
274-
return absl::get<CustomListValue>(variant_);
279+
280+
return variant_.Get<CustomListValue>();
275281
}
276282

277283
CustomListValue ListValue::GetCustom() && {
278284
ABSL_DCHECK(IsCustom());
279-
return absl::get<CustomListValue>(std::move(variant_));
285+
286+
return std::move(variant_).Get<CustomListValue>();
280287
}
281288

282289
common_internal::ValueVariant ListValue::ToValueVariant() const& {
283-
return absl::visit(
290+
return variant_.Visit(
284291
[](const auto& alternative) -> common_internal::ValueVariant {
285292
return common_internal::ValueVariant(alternative);
286-
},
287-
variant_);
293+
});
288294
}
289295

290296
common_internal::ValueVariant ListValue::ToValueVariant() && {
291-
return absl::visit(
297+
return std::move(variant_).Visit(
292298
[](auto&& alternative) -> common_internal::ValueVariant {
293299
// NOLINTNEXTLINE(bugprone-move-forwarding-reference)
294300
return common_internal::ValueVariant(std::move(alternative));
295-
},
296-
std::move(variant_));
301+
});
297302
}
298303

299304
} // namespace cel

0 commit comments

Comments
 (0)