Skip to content

Commit 8d8391b

Browse files
jckingcopybara-github
jcking
authored and
copybara-github
committed
Implement hand-rolled variant for cel::MapValue
PiperOrigin-RevId: 740338853
1 parent e21db03 commit 8d8391b

File tree

4 files changed

+335
-156
lines changed

4 files changed

+335
-156
lines changed

‎common/values/map_value.cc

Lines changed: 109 additions & 98 deletions
Original file line numberDiff line numberDiff line change
@@ -23,9 +23,8 @@
2323
#include "absl/status/statusor.h"
2424
#include "absl/strings/cord.h"
2525
#include "absl/strings/str_cat.h"
26-
#include "absl/strings/string_view.h"
2726
#include "absl/types/optional.h"
28-
#include "absl/types/variant.h"
27+
#include "common/native_type.h"
2928
#include "common/optional_ref.h"
3029
#include "common/value.h"
3130
#include "common/value_kind.h"
@@ -46,58 +45,60 @@ absl::Status InvalidMapKeyTypeError(ValueKind kind) {
4645

4746
} // namespace
4847

49-
absl::string_view MapValue::GetTypeName() const {
50-
return absl::visit(
51-
[](const auto& alternative) -> absl::string_view {
52-
return alternative.GetTypeName();
53-
},
54-
variant_);
48+
NativeTypeId MapValue::GetTypeId() const {
49+
return variant_.Visit([](const auto& alternative) -> NativeTypeId {
50+
return NativeTypeId::Of(alternative);
51+
});
5552
}
5653

5754
std::string MapValue::DebugString() const {
58-
return absl::visit(
59-
[](const auto& alternative) -> std::string {
60-
return alternative.DebugString();
61-
},
62-
variant_);
55+
return variant_.Visit([](const auto& alternative) -> std::string {
56+
return alternative.DebugString();
57+
});
6358
}
6459

6560
absl::Status MapValue::SerializeTo(
6661
absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
6762
absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
6863
absl::Nonnull<absl::Cord*> value) const {
69-
return absl::visit(
70-
[descriptor_pool, message_factory,
71-
value](const auto& alternative) -> absl::Status {
72-
return alternative.SerializeTo(descriptor_pool, message_factory, value);
73-
},
74-
variant_);
64+
ABSL_DCHECK(descriptor_pool != nullptr);
65+
ABSL_DCHECK(message_factory != nullptr);
66+
ABSL_DCHECK(value != nullptr);
67+
68+
return variant_.Visit([&](const auto& alternative) -> absl::Status {
69+
return alternative.SerializeTo(descriptor_pool, message_factory, value);
70+
});
7571
}
7672

7773
absl::Status MapValue::ConvertToJson(
7874
absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
7975
absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
8076
absl::Nonnull<google::protobuf::Message*> json) const {
81-
return absl::visit(
82-
[descriptor_pool, message_factory,
83-
json](const auto& alternative) -> absl::Status {
84-
return alternative.ConvertToJson(descriptor_pool, message_factory,
85-
json);
86-
},
87-
variant_);
77+
ABSL_DCHECK(descriptor_pool != nullptr);
78+
ABSL_DCHECK(message_factory != nullptr);
79+
ABSL_DCHECK(json != nullptr);
80+
ABSL_DCHECK_EQ(json->GetDescriptor()->well_known_type(),
81+
google::protobuf::Descriptor::WELLKNOWNTYPE_VALUE);
82+
83+
return variant_.Visit([&](const auto& alternative) -> absl::Status {
84+
return alternative.ConvertToJson(descriptor_pool, message_factory, json);
85+
});
8886
}
8987

9088
absl::Status MapValue::ConvertToJsonObject(
9189
absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
9290
absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
9391
absl::Nonnull<google::protobuf::Message*> json) const {
94-
return absl::visit(
95-
[descriptor_pool, message_factory,
96-
json](const auto& alternative) -> absl::Status {
97-
return alternative.ConvertToJsonObject(descriptor_pool, message_factory,
98-
json);
99-
},
100-
variant_);
92+
ABSL_DCHECK(descriptor_pool != nullptr);
93+
ABSL_DCHECK(message_factory != nullptr);
94+
ABSL_DCHECK(json != nullptr);
95+
ABSL_DCHECK_EQ(json->GetDescriptor()->well_known_type(),
96+
google::protobuf::Descriptor::WELLKNOWNTYPE_STRUCT);
97+
98+
return variant_.Visit([&](const auto& alternative) -> absl::Status {
99+
return alternative.ConvertToJsonObject(descriptor_pool, message_factory,
100+
json);
101+
});
101102
}
102103

103104
absl::Status MapValue::Equal(
@@ -110,105 +111,114 @@ absl::Status MapValue::Equal(
110111
ABSL_DCHECK(arena != nullptr);
111112
ABSL_DCHECK(result != nullptr);
112113

113-
return absl::visit(
114-
[&other, descriptor_pool, message_factory, arena,
115-
result](const auto& alternative) -> absl::Status {
116-
return alternative.Equal(other, descriptor_pool, message_factory, arena,
117-
result);
118-
},
119-
variant_);
114+
return variant_.Visit([&](const auto& alternative) -> absl::Status {
115+
return alternative.Equal(other, descriptor_pool, message_factory, arena,
116+
result);
117+
});
120118
}
121119

122120
bool MapValue::IsZeroValue() const {
123-
return absl::visit(
124-
[](const auto& alternative) -> bool { return alternative.IsZeroValue(); },
125-
variant_);
121+
return variant_.Visit([](const auto& alternative) -> bool {
122+
return alternative.IsZeroValue();
123+
});
126124
}
127125

128126
absl::StatusOr<bool> MapValue::IsEmpty() const {
129-
return absl::visit(
130-
[](const auto& alternative) -> bool { return alternative.IsEmpty(); },
131-
variant_);
127+
return variant_.Visit([](const auto& alternative) -> absl::StatusOr<bool> {
128+
return alternative.IsEmpty();
129+
});
132130
}
133131

134132
absl::StatusOr<size_t> MapValue::Size() const {
135-
return absl::visit(
136-
[](const auto& alternative) -> size_t { return alternative.Size(); },
137-
variant_);
133+
return variant_.Visit([](const auto& alternative) -> absl::StatusOr<size_t> {
134+
return alternative.Size();
135+
});
138136
}
139137

140138
absl::Status MapValue::Get(
141139
const Value& key,
142140
absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
143141
absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
144142
absl::Nonnull<google::protobuf::Arena*> arena, absl::Nonnull<Value*> result) const {
145-
return absl::visit(
146-
[&](const auto& alternative) -> absl::Status {
147-
return alternative.Get(key, descriptor_pool, message_factory, arena,
148-
result);
149-
},
150-
variant_);
143+
ABSL_DCHECK(descriptor_pool != nullptr);
144+
ABSL_DCHECK(message_factory != nullptr);
145+
ABSL_DCHECK(arena != nullptr);
146+
ABSL_DCHECK(result != nullptr);
147+
148+
return variant_.Visit([&](const auto& alternative) -> absl::Status {
149+
return alternative.Get(key, descriptor_pool, message_factory, arena,
150+
result);
151+
});
151152
}
152153

153154
absl::StatusOr<bool> MapValue::Find(
154155
const Value& key,
155156
absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
156157
absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
157158
absl::Nonnull<google::protobuf::Arena*> arena, absl::Nonnull<Value*> result) const {
158-
return absl::visit(
159-
[&](const auto& alternative) -> absl::StatusOr<bool> {
160-
return alternative.Find(key, descriptor_pool, message_factory, arena,
161-
result);
162-
},
163-
variant_);
159+
ABSL_DCHECK(descriptor_pool != nullptr);
160+
ABSL_DCHECK(message_factory != nullptr);
161+
ABSL_DCHECK(arena != nullptr);
162+
ABSL_DCHECK(result != nullptr);
163+
164+
return variant_.Visit([&](const auto& alternative) -> absl::StatusOr<bool> {
165+
return alternative.Find(key, descriptor_pool, message_factory, arena,
166+
result);
167+
});
164168
}
165169

166170
absl::Status MapValue::Has(
167171
const Value& key,
168172
absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
169173
absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
170174
absl::Nonnull<google::protobuf::Arena*> arena, absl::Nonnull<Value*> result) const {
171-
return absl::visit(
172-
[&](const auto& alternative) -> absl::Status {
173-
return alternative.Has(key, descriptor_pool, message_factory, arena,
174-
result);
175-
},
176-
variant_);
175+
ABSL_DCHECK(descriptor_pool != nullptr);
176+
ABSL_DCHECK(message_factory != nullptr);
177+
ABSL_DCHECK(arena != nullptr);
178+
ABSL_DCHECK(result != nullptr);
179+
180+
return variant_.Visit([&](const auto& alternative) -> absl::Status {
181+
return alternative.Has(key, descriptor_pool, message_factory, arena,
182+
result);
183+
});
177184
}
178185

179186
absl::Status MapValue::ListKeys(
180187
absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
181188
absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
182189
absl::Nonnull<google::protobuf::Arena*> arena,
183190
absl::Nonnull<ListValue*> result) const {
184-
return absl::visit(
185-
[&](const auto& alternative) -> absl::Status {
186-
return alternative.ListKeys(descriptor_pool, message_factory, arena,
187-
result);
188-
},
189-
variant_);
191+
ABSL_DCHECK(descriptor_pool != nullptr);
192+
ABSL_DCHECK(message_factory != nullptr);
193+
ABSL_DCHECK(arena != nullptr);
194+
ABSL_DCHECK(result != nullptr);
195+
196+
return variant_.Visit([&](const auto& alternative) -> absl::Status {
197+
return alternative.ListKeys(descriptor_pool, message_factory, arena,
198+
result);
199+
});
190200
}
191201

192202
absl::Status MapValue::ForEach(
193203
ForEachCallback callback,
194204
absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
195205
absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
196206
absl::Nonnull<google::protobuf::Arena*> arena) const {
197-
return absl::visit(
198-
[&](const auto& alternative) -> absl::Status {
199-
return alternative.ForEach(callback, descriptor_pool, message_factory,
200-
arena);
201-
},
202-
variant_);
207+
ABSL_DCHECK(descriptor_pool != nullptr);
208+
ABSL_DCHECK(message_factory != nullptr);
209+
ABSL_DCHECK(arena != nullptr);
210+
211+
return variant_.Visit([&](const auto& alternative) -> absl::Status {
212+
return alternative.ForEach(callback, descriptor_pool, message_factory,
213+
arena);
214+
});
203215
}
204216

205217
absl::StatusOr<absl::Nonnull<ValueIteratorPtr>> MapValue::NewIterator() const {
206-
return absl::visit(
207-
[](const auto& alternative)
208-
-> absl::StatusOr<absl::Nonnull<ValueIteratorPtr>> {
209-
return alternative.NewIterator();
210-
},
211-
variant_);
218+
return variant_.Visit([](const auto& alternative)
219+
-> absl::StatusOr<absl::Nonnull<ValueIteratorPtr>> {
220+
return alternative.NewIterator();
221+
});
212222
}
213223

214224
namespace common_internal {
@@ -324,45 +334,46 @@ absl::Status CheckMapKey(const Value& key) {
324334
}
325335

326336
optional_ref<const CustomMapValue> MapValue::AsCustom() const& {
327-
if (const auto* alt = absl::get_if<CustomMapValue>(&variant_);
328-
alt != nullptr) {
329-
return *alt;
337+
if (const auto* alternative = variant_.As<CustomMapValue>();
338+
alternative != nullptr) {
339+
return *alternative;
330340
}
331341
return absl::nullopt;
332342
}
333343

334344
absl::optional<CustomMapValue> MapValue::AsCustom() && {
335-
if (auto* alt = absl::get_if<CustomMapValue>(&variant_); alt != nullptr) {
336-
return std::move(*alt);
345+
if (auto* alternative = variant_.As<CustomMapValue>();
346+
alternative != nullptr) {
347+
return std::move(*alternative);
337348
}
338349
return absl::nullopt;
339350
}
340351

341352
const CustomMapValue& MapValue::GetCustom() const& {
342353
ABSL_DCHECK(IsCustom());
343-
return absl::get<CustomMapValue>(variant_);
354+
355+
return variant_.Get<CustomMapValue>();
344356
}
345357

346358
CustomMapValue MapValue::GetCustom() && {
347359
ABSL_DCHECK(IsCustom());
348-
return absl::get<CustomMapValue>(std::move(variant_));
360+
361+
return std::move(variant_).Get<CustomMapValue>();
349362
}
350363

351364
common_internal::ValueVariant MapValue::ToValueVariant() const& {
352-
return absl::visit(
365+
return variant_.Visit(
353366
[](const auto& alternative) -> common_internal::ValueVariant {
354367
return common_internal::ValueVariant(alternative);
355-
},
356-
variant_);
368+
});
357369
}
358370

359371
common_internal::ValueVariant MapValue::ToValueVariant() && {
360-
return absl::visit(
372+
return std::move(variant_).Visit(
361373
[](auto&& alternative) -> common_internal::ValueVariant {
362374
// NOLINTNEXTLINE(bugprone-move-forwarding-reference)
363375
return common_internal::ValueVariant(std::move(alternative));
364-
},
365-
std::move(variant_));
376+
});
366377
}
367378

368379
} // namespace cel

0 commit comments

Comments
 (0)