in cdk/extra/protobuf/protobuf-3.19.6/src/google/protobuf/reflection_tester.cc [862:1379]
void MapReflectionTester::ExpectMapFieldsSetViaReflection(
const Message& message) {
std::string scratch;
const Reflection* reflection = message.GetReflection();
const Message* sub_message;
MapKey map_key;
MapValueConstRef map_value_const_ref;
// -----------------------------------------------------------------
ASSERT_EQ(2, reflection->FieldSize(message, F("map_int32_int32")));
ASSERT_EQ(2, reflection->FieldSize(message, F("map_int64_int64")));
ASSERT_EQ(2, reflection->FieldSize(message, F("map_uint32_uint32")));
ASSERT_EQ(2, reflection->FieldSize(message, F("map_uint64_uint64")));
ASSERT_EQ(2, reflection->FieldSize(message, F("map_sint32_sint32")));
ASSERT_EQ(2, reflection->FieldSize(message, F("map_sint64_sint64")));
ASSERT_EQ(2, reflection->FieldSize(message, F("map_fixed32_fixed32")));
ASSERT_EQ(2, reflection->FieldSize(message, F("map_fixed64_fixed64")));
ASSERT_EQ(2, reflection->FieldSize(message, F("map_sfixed32_sfixed32")));
ASSERT_EQ(2, reflection->FieldSize(message, F("map_sfixed64_sfixed64")));
ASSERT_EQ(2, reflection->FieldSize(message, F("map_int32_float")));
ASSERT_EQ(2, reflection->FieldSize(message, F("map_int32_double")));
ASSERT_EQ(2, reflection->FieldSize(message, F("map_bool_bool")));
ASSERT_EQ(2, reflection->FieldSize(message, F("map_string_string")));
ASSERT_EQ(2, reflection->FieldSize(message, F("map_int32_bytes")));
ASSERT_EQ(2, reflection->FieldSize(message, F("map_int32_enum")));
ASSERT_EQ(2, reflection->FieldSize(message, F("map_int32_foreign_message")));
{
std::map<int32_t, int32_t> map;
map[0] = 0;
map[1] = 1;
for (int i = 0; i < 2; i++) {
const internal::MapFieldBase& map_field =
reflection->GetRaw<internal::MapFieldBase>(message,
F("map_int32_int32"));
if (map_field.IsRepeatedFieldValid()) {
// Check with RepeatedField Reflection
sub_message =
&reflection->GetRepeatedMessage(message, F("map_int32_int32"), i);
int32_t key = sub_message->GetReflection()->GetInt32(
*sub_message, map_int32_int32_key_);
int32_t val = sub_message->GetReflection()->GetInt32(
*sub_message, map_int32_int32_val_);
EXPECT_EQ(map[key], val);
} else {
// Check with Map Reflection
map_key.SetInt32Value(i);
EXPECT_TRUE(
reflection->ContainsMapKey(message, F("map_int32_int32"), map_key));
EXPECT_TRUE(reflection->LookupMapValue(message, F("map_int32_int32"),
map_key, &map_value_const_ref));
EXPECT_EQ(map_value_const_ref.GetInt32Value(), map[i]);
}
}
}
{
std::map<int64_t, int64_t> map;
map[0] = 0;
map[1] = 1;
for (int i = 0; i < 2; i++) {
const internal::MapFieldBase& map_field =
reflection->GetRaw<internal::MapFieldBase>(message,
F("map_int64_int64"));
if (map_field.IsRepeatedFieldValid()) {
// Check with RepeatedField Reflection
sub_message =
&reflection->GetRepeatedMessage(message, F("map_int64_int64"), i);
int64_t key = sub_message->GetReflection()->GetInt64(
*sub_message, map_int64_int64_key_);
int64_t val = sub_message->GetReflection()->GetInt64(
*sub_message, map_int64_int64_val_);
EXPECT_EQ(map[key], val);
} else {
// Check with Map Reflection
map_key.SetInt64Value(i);
EXPECT_TRUE(
reflection->ContainsMapKey(message, F("map_int64_int64"), map_key));
EXPECT_TRUE(reflection->LookupMapValue(message, F("map_int64_int64"),
map_key, &map_value_const_ref));
EXPECT_EQ(map_value_const_ref.GetInt64Value(), map[i]);
}
}
}
{
std::map<uint32_t, uint32_t> map;
map[0] = 0;
map[1] = 1;
for (int i = 0; i < 2; i++) {
const internal::MapFieldBase& map_field =
reflection->GetRaw<internal::MapFieldBase>(message,
F("map_uint32_uint32"));
if (map_field.IsRepeatedFieldValid()) {
// Check with RepeatedField Reflection
sub_message =
&reflection->GetRepeatedMessage(message, F("map_uint32_uint32"), i);
uint32_t key = sub_message->GetReflection()->GetUInt32(
*sub_message, map_uint32_uint32_key_);
uint32_t val = sub_message->GetReflection()->GetUInt32(
*sub_message, map_uint32_uint32_val_);
EXPECT_EQ(map[key], val);
} else {
// Check with Map Reflection
map_key.SetUInt32Value(i);
EXPECT_TRUE(reflection->ContainsMapKey(message, F("map_uint32_uint32"),
map_key));
EXPECT_TRUE(reflection->LookupMapValue(message, F("map_uint32_uint32"),
map_key, &map_value_const_ref));
EXPECT_EQ(map_value_const_ref.GetUInt32Value(), map[i]);
}
}
}
{
std::map<uint64_t, uint64_t> map;
map[0] = 0;
map[1] = 1;
for (int i = 0; i < 2; i++) {
const internal::MapFieldBase& map_field =
reflection->GetRaw<internal::MapFieldBase>(message,
F("map_uint64_uint64"));
if (map_field.IsRepeatedFieldValid()) {
// Check with RepeatedField Reflection
sub_message =
&reflection->GetRepeatedMessage(message, F("map_uint64_uint64"), i);
uint64_t key = sub_message->GetReflection()->GetUInt64(
*sub_message, map_uint64_uint64_key_);
uint64_t val = sub_message->GetReflection()->GetUInt64(
*sub_message, map_uint64_uint64_val_);
EXPECT_EQ(map[key], val);
} else {
// Check with Map Reflection
map_key.SetUInt64Value(i);
EXPECT_TRUE(reflection->ContainsMapKey(message, F("map_uint64_uint64"),
map_key));
EXPECT_TRUE(reflection->LookupMapValue(message, F("map_uint64_uint64"),
map_key, &map_value_const_ref));
EXPECT_EQ(map_value_const_ref.GetUInt64Value(), map[i]);
}
}
}
{
std::map<int32_t, int32_t> map;
map[0] = 0;
map[1] = 1;
for (int i = 0; i < 2; i++) {
const internal::MapFieldBase& map_field =
reflection->GetRaw<internal::MapFieldBase>(message,
F("map_sint32_sint32"));
if (map_field.IsRepeatedFieldValid()) {
// Check with RepeatedField Reflection
sub_message =
&reflection->GetRepeatedMessage(message, F("map_sint32_sint32"), i);
int32_t key = sub_message->GetReflection()->GetInt32(
*sub_message, map_sint32_sint32_key_);
int32_t val = sub_message->GetReflection()->GetInt32(
*sub_message, map_sint32_sint32_val_);
EXPECT_EQ(map[key], val);
} else {
// Check with Map Reflection
map_key.SetInt32Value(i);
EXPECT_EQ(true, reflection->ContainsMapKey(
message, F("map_sint32_sint32"), map_key));
EXPECT_TRUE(reflection->LookupMapValue(message, F("map_sint32_sint32"),
map_key, &map_value_const_ref));
EXPECT_EQ(map_value_const_ref.GetInt32Value(), map[i]);
}
}
}
{
std::map<int64_t, int64_t> map;
map[0] = 0;
map[1] = 1;
for (int i = 0; i < 2; i++) {
const internal::MapFieldBase& map_field =
reflection->GetRaw<internal::MapFieldBase>(message,
F("map_sint64_sint64"));
if (map_field.IsRepeatedFieldValid()) {
// Check with RepeatedField Reflection
sub_message =
&reflection->GetRepeatedMessage(message, F("map_sint64_sint64"), i);
int64_t key = sub_message->GetReflection()->GetInt64(
*sub_message, map_sint64_sint64_key_);
int64_t val = sub_message->GetReflection()->GetInt64(
*sub_message, map_sint64_sint64_val_);
EXPECT_EQ(map[key], val);
} else {
// Check with Map Reflection
map_key.SetInt64Value(i);
EXPECT_EQ(true, reflection->ContainsMapKey(
message, F("map_sint64_sint64"), map_key));
EXPECT_TRUE(reflection->LookupMapValue(message, F("map_sint64_sint64"),
map_key, &map_value_const_ref));
EXPECT_EQ(map_value_const_ref.GetInt64Value(), map[i]);
}
}
}
{
std::map<uint32_t, uint32_t> map;
map[0] = 0;
map[1] = 1;
for (int i = 0; i < 2; i++) {
const internal::MapFieldBase& map_field =
reflection->GetRaw<internal::MapFieldBase>(message,
F("map_fixed32_fixed32"));
if (map_field.IsRepeatedFieldValid()) {
// Check with RepeatedField Reflection
sub_message = &reflection->GetRepeatedMessage(
message, F("map_fixed32_fixed32"), i);
uint32_t key = sub_message->GetReflection()->GetUInt32(
*sub_message, map_fixed32_fixed32_key_);
uint32_t val = sub_message->GetReflection()->GetUInt32(
*sub_message, map_fixed32_fixed32_val_);
EXPECT_EQ(map[key], val);
} else {
// Check with Map Reflection
map_key.SetUInt32Value(i);
EXPECT_EQ(true, reflection->ContainsMapKey(
message, F("map_fixed32_fixed32"), map_key));
EXPECT_TRUE(reflection->LookupMapValue(
message, F("map_fixed32_fixed32"), map_key, &map_value_const_ref));
EXPECT_EQ(map_value_const_ref.GetUInt32Value(), map[i]);
}
}
}
{
std::map<uint64_t, uint64_t> map;
map[0] = 0;
map[1] = 1;
for (int i = 0; i < 2; i++) {
const internal::MapFieldBase& map_field =
reflection->GetRaw<internal::MapFieldBase>(message,
F("map_fixed64_fixed64"));
if (map_field.IsRepeatedFieldValid()) {
// Check with RepeatedField Reflection
sub_message = &reflection->GetRepeatedMessage(
message, F("map_fixed64_fixed64"), i);
uint64_t key = sub_message->GetReflection()->GetUInt64(
*sub_message, map_fixed64_fixed64_key_);
uint64_t val = sub_message->GetReflection()->GetUInt64(
*sub_message, map_fixed64_fixed64_val_);
EXPECT_EQ(map[key], val);
} else {
// Check with Map Reflection
map_key.SetUInt64Value(i);
EXPECT_EQ(true, reflection->ContainsMapKey(
message, F("map_fixed64_fixed64"), map_key));
EXPECT_TRUE(reflection->LookupMapValue(
message, F("map_fixed64_fixed64"), map_key, &map_value_const_ref));
EXPECT_EQ(map_value_const_ref.GetUInt64Value(), map[i]);
}
}
}
{
std::map<int32_t, int32_t> map;
map[0] = 0;
map[1] = 1;
for (int i = 0; i < 2; i++) {
const internal::MapFieldBase& map_field =
reflection->GetRaw<internal::MapFieldBase>(
message, F("map_sfixed32_sfixed32"));
if (map_field.IsRepeatedFieldValid()) {
// Check with RepeatedField Reflection
sub_message = &reflection->GetRepeatedMessage(
message, F("map_sfixed32_sfixed32"), i);
int32_t key = sub_message->GetReflection()->GetInt32(
*sub_message, map_sfixed32_sfixed32_key_);
int32_t val = sub_message->GetReflection()->GetInt32(
*sub_message, map_sfixed32_sfixed32_val_);
EXPECT_EQ(map[key], val);
} else {
// Check with Map Reflection
map_key.SetInt32Value(i);
EXPECT_EQ(true, reflection->ContainsMapKey(
message, F("map_sfixed32_sfixed32"), map_key));
EXPECT_TRUE(reflection->LookupMapValue(message,
F("map_sfixed32_sfixed32"),
map_key, &map_value_const_ref));
EXPECT_EQ(map_value_const_ref.GetInt32Value(), map[i]);
}
}
}
{
std::map<int64_t, int64_t> map;
map[0] = 0;
map[1] = 1;
for (int i = 0; i < 2; i++) {
const internal::MapFieldBase& map_field =
reflection->GetRaw<internal::MapFieldBase>(
message, F("map_sfixed64_sfixed64"));
if (map_field.IsRepeatedFieldValid()) {
// Check with RepeatedField Reflection
sub_message = &reflection->GetRepeatedMessage(
message, F("map_sfixed64_sfixed64"), i);
int64_t key = sub_message->GetReflection()->GetInt64(
*sub_message, map_sfixed64_sfixed64_key_);
int64_t val = sub_message->GetReflection()->GetInt64(
*sub_message, map_sfixed64_sfixed64_val_);
EXPECT_EQ(map[key], val);
} else {
// Check with Map Reflection
map_key.SetInt64Value(i);
EXPECT_EQ(true, reflection->ContainsMapKey(
message, F("map_sfixed64_sfixed64"), map_key));
EXPECT_TRUE(reflection->LookupMapValue(message,
F("map_sfixed64_sfixed64"),
map_key, &map_value_const_ref));
EXPECT_EQ(map_value_const_ref.GetInt64Value(), map[i]);
}
}
}
{
std::map<int32_t, float> map;
map[0] = 0.0;
map[1] = 1.0;
for (int i = 0; i < 2; i++) {
const internal::MapFieldBase& map_field =
reflection->GetRaw<internal::MapFieldBase>(message,
F("map_int32_float"));
if (map_field.IsRepeatedFieldValid()) {
// Check with RepeatedField Reflection
sub_message =
&reflection->GetRepeatedMessage(message, F("map_int32_float"), i);
int32_t key = sub_message->GetReflection()->GetInt32(
*sub_message, map_int32_float_key_);
float val = sub_message->GetReflection()->GetFloat(
*sub_message, map_int32_float_val_);
EXPECT_EQ(map[key], val);
} else {
// Check with Map Reflection
map_key.SetInt32Value(i);
EXPECT_EQ(true, reflection->ContainsMapKey(
message, F("map_int32_float"), map_key));
EXPECT_TRUE(reflection->LookupMapValue(message, F("map_int32_float"),
map_key, &map_value_const_ref));
EXPECT_EQ(map_value_const_ref.GetFloatValue(), map[i]);
}
}
}
{
std::map<int32_t, double> map;
map[0] = 0.0;
map[1] = 1.0;
for (int i = 0; i < 2; i++) {
const internal::MapFieldBase& map_field =
reflection->GetRaw<internal::MapFieldBase>(message,
F("map_int32_double"));
if (map_field.IsRepeatedFieldValid()) {
// Check with RepeatedField Reflection
sub_message =
&reflection->GetRepeatedMessage(message, F("map_int32_double"), i);
int32_t key = sub_message->GetReflection()->GetInt32(
*sub_message, map_int32_double_key_);
double val = sub_message->GetReflection()->GetDouble(
*sub_message, map_int32_double_val_);
EXPECT_EQ(map[key], val);
} else {
// Check with Map Reflection
map_key.SetInt32Value(i);
EXPECT_EQ(true, reflection->ContainsMapKey(
message, F("map_int32_double"), map_key));
EXPECT_TRUE(reflection->LookupMapValue(message, F("map_int32_double"),
map_key, &map_value_const_ref));
EXPECT_EQ(map_value_const_ref.GetDoubleValue(), map[i]);
}
}
}
{
std::map<bool, bool> map;
map[false] = false;
map[true] = true;
std::vector<bool> keys = {false, true};
std::vector<bool> vals = {false, true};
for (int i = 0; i < 2; i++) {
const internal::MapFieldBase& map_field =
reflection->GetRaw<internal::MapFieldBase>(message,
F("map_bool_bool"));
if (map_field.IsRepeatedFieldValid()) {
// Check with RepeatedField Reflection
sub_message =
&reflection->GetRepeatedMessage(message, F("map_bool_bool"), i);
bool key = sub_message->GetReflection()->GetBool(*sub_message,
map_bool_bool_key_);
bool val = sub_message->GetReflection()->GetBool(*sub_message,
map_bool_bool_val_);
EXPECT_EQ(map[key], val);
} else {
// Check with Map Reflection
map_key.SetBoolValue(keys[i]);
EXPECT_EQ(true, reflection->ContainsMapKey(message, F("map_bool_bool"),
map_key));
EXPECT_TRUE(reflection->LookupMapValue(message, F("map_bool_bool"),
map_key, &map_value_const_ref));
EXPECT_EQ(map_value_const_ref.GetBoolValue(), vals[i]);
}
}
}
{
std::map<std::string, std::string> map;
map["0"] = "0";
map["1"] = "1";
std::vector<std::string> keys = {"0", "1"};
std::vector<std::string> vals = {"0", "1"};
for (int i = 0; i < 2; i++) {
const internal::MapFieldBase& map_field =
reflection->GetRaw<internal::MapFieldBase>(message,
F("map_string_string"));
if (map_field.IsRepeatedFieldValid()) {
// Check with RepeatedField Reflection
sub_message =
&reflection->GetRepeatedMessage(message, F("map_string_string"), i);
std::string key = sub_message->GetReflection()->GetString(
*sub_message, map_string_string_key_);
std::string val = sub_message->GetReflection()->GetString(
*sub_message, map_string_string_val_);
EXPECT_EQ(map[key], val);
} else {
// Check with Map Reflection
map_key.SetStringValue(keys[i]);
EXPECT_EQ(true, reflection->ContainsMapKey(
message, F("map_string_string"), map_key));
EXPECT_TRUE(reflection->LookupMapValue(message, F("map_string_string"),
map_key, &map_value_const_ref));
EXPECT_EQ(map_value_const_ref.GetStringValue(), vals[i]);
}
}
}
{
std::map<int32_t, std::string> map;
map[0] = "0";
map[1] = "1";
for (int i = 0; i < 2; i++) {
const internal::MapFieldBase& map_field =
reflection->GetRaw<internal::MapFieldBase>(message,
F("map_int32_bytes"));
if (map_field.IsRepeatedFieldValid()) {
// Check with RepeatedField Reflection
sub_message =
&reflection->GetRepeatedMessage(message, F("map_int32_bytes"), i);
int32_t key = sub_message->GetReflection()->GetInt32(
*sub_message, map_int32_bytes_key_);
std::string val = sub_message->GetReflection()->GetString(
*sub_message, map_int32_bytes_val_);
EXPECT_EQ(map[key], val);
} else {
// Check with Map Reflection
map_key.SetInt32Value(i);
EXPECT_EQ(true, reflection->ContainsMapKey(
message, F("map_int32_bytes"), map_key));
EXPECT_TRUE(reflection->LookupMapValue(message, F("map_int32_bytes"),
map_key, &map_value_const_ref));
EXPECT_EQ(map_value_const_ref.GetStringValue(), map[i]);
}
}
}
{
std::map<int32_t, const EnumValueDescriptor*> map;
map[0] = map_enum_bar_;
map[1] = map_enum_baz_;
for (int i = 0; i < 2; i++) {
const internal::MapFieldBase& map_field =
reflection->GetRaw<internal::MapFieldBase>(message,
F("map_int32_enum"));
if (map_field.IsRepeatedFieldValid()) {
// Check with RepeatedField Reflection
sub_message =
&reflection->GetRepeatedMessage(message, F("map_int32_enum"), i);
int32_t key = sub_message->GetReflection()->GetInt32(
*sub_message, map_int32_enum_key_);
const EnumValueDescriptor* val = sub_message->GetReflection()->GetEnum(
*sub_message, map_int32_enum_val_);
EXPECT_EQ(map[key], val);
} else {
// Check with Map Reflection
map_key.SetInt32Value(i);
EXPECT_EQ(true, reflection->ContainsMapKey(message, F("map_int32_enum"),
map_key));
EXPECT_TRUE(reflection->LookupMapValue(message, F("map_int32_enum"),
map_key, &map_value_const_ref));
EXPECT_EQ(map_value_const_ref.GetEnumValue(), map[i]->number());
}
}
}
{
std::map<int32_t, int32_t> map;
map[0] = 0;
map[1] = 1;
for (int i = 0; i < 2; i++) {
const internal::MapFieldBase& map_field =
reflection->GetRaw<internal::MapFieldBase>(
message, F("map_int32_foreign_message"));
if (map_field.IsRepeatedFieldValid()) {
// Check with RepeatedField Reflection
sub_message = &reflection->GetRepeatedMessage(
message, F("map_int32_foreign_message"), i);
int32_t key = sub_message->GetReflection()->GetInt32(
*sub_message, map_int32_foreign_message_key_);
const Message& foreign_message =
sub_message->GetReflection()->GetMessage(
*sub_message, map_int32_foreign_message_val_);
int32_t val = foreign_message.GetReflection()->GetInt32(foreign_message,
foreign_c_);
EXPECT_EQ(map[key], val);
} else {
// Check with Map Reflection
map_key.SetInt32Value(i);
EXPECT_EQ(true, reflection->ContainsMapKey(
message, F("map_int32_foreign_message"), map_key));
EXPECT_TRUE(reflection->LookupMapValue(message,
F("map_int32_foreign_message"),
map_key, &map_value_const_ref));
const Message& foreign_message = map_value_const_ref.GetMessageValue();
EXPECT_EQ(foreign_message.GetReflection()->GetInt32(foreign_message,
foreign_c_),
map[i]);
}
}
}
}