570 lines
23 KiB
C++
570 lines
23 KiB
C++
// Protocol Buffers - Google's data interchange format
|
|
// Copyright 2023 Google LLC. All rights reserved.
|
|
//
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file or at
|
|
// https://developers.google.com/open-source/licenses/bsd
|
|
|
|
#include "protos_generator/gen_accessors.h"
|
|
|
|
#include <string>
|
|
|
|
#include "absl/container/flat_hash_set.h"
|
|
#include "absl/strings/match.h"
|
|
#include "absl/strings/str_cat.h"
|
|
#include "absl/strings/string_view.h"
|
|
#include "google/protobuf/descriptor.h"
|
|
#include "protos_generator/gen_repeated_fields.h"
|
|
#include "protos_generator/gen_utils.h"
|
|
#include "protos_generator/names.h"
|
|
#include "protos_generator/output.h"
|
|
#include "upb_generator/common.h"
|
|
#include "upb_generator/keywords.h"
|
|
#include "upb_generator/names.h"
|
|
|
|
namespace protos_generator {
|
|
|
|
namespace protobuf = ::google::protobuf;
|
|
|
|
using NameToFieldDescriptorMap =
|
|
absl::flat_hash_map<absl::string_view, const protobuf::FieldDescriptor*>;
|
|
|
|
void WriteFieldAccessorHazzer(const protobuf::Descriptor* desc,
|
|
const protobuf::FieldDescriptor* field,
|
|
absl::string_view resolved_field_name,
|
|
absl::string_view resolved_upbc_name,
|
|
Output& output);
|
|
void WriteFieldAccessorClear(const protobuf::Descriptor* desc,
|
|
const protobuf::FieldDescriptor* field,
|
|
absl::string_view resolved_field_name,
|
|
absl::string_view resolved_upbc_name,
|
|
Output& output);
|
|
void WriteMapFieldAccessors(const protobuf::Descriptor* desc,
|
|
const protobuf::FieldDescriptor* field,
|
|
absl::string_view resolved_field_name,
|
|
absl::string_view resolved_upbc_name,
|
|
Output& output);
|
|
|
|
void WriteMapAccessorDefinitions(const protobuf::Descriptor* message,
|
|
const protobuf::FieldDescriptor* field,
|
|
absl::string_view resolved_field_name,
|
|
absl::string_view class_name, Output& output);
|
|
|
|
// Returns C++ class member name by resolving naming conflicts across
|
|
// proto field names (such as clear_ prefixes) and keyword collisions.
|
|
//
|
|
// The Upb C generator prefixes all accessors with package and class names
|
|
// avoiding collisions. Therefore we need to use raw field names when calling
|
|
// into C accessors but need to fully resolve conflicts for C++ class members.
|
|
std::string ResolveFieldName(const protobuf::FieldDescriptor* field,
|
|
const NameToFieldDescriptorMap& field_names);
|
|
|
|
NameToFieldDescriptorMap CreateFieldNameMap(
|
|
const protobuf::Descriptor* message) {
|
|
NameToFieldDescriptorMap field_names;
|
|
for (int i = 0; i < message->field_count(); i++) {
|
|
const protobuf::FieldDescriptor* field = message->field(i);
|
|
field_names.emplace(field->name(), field);
|
|
}
|
|
return field_names;
|
|
}
|
|
|
|
void WriteFieldAccessorsInHeader(const protobuf::Descriptor* desc,
|
|
Output& output) {
|
|
// Generate const methods.
|
|
OutputIndenter i(output);
|
|
|
|
auto field_names = CreateFieldNameMap(desc);
|
|
auto upbc_field_names = upb::generator::CreateFieldNameMap(desc);
|
|
|
|
for (const auto* field : FieldNumberOrder(desc)) {
|
|
std::string resolved_field_name = ResolveFieldName(field, field_names);
|
|
std::string resolved_upbc_name =
|
|
upb::generator::ResolveFieldName(field, upbc_field_names);
|
|
WriteFieldAccessorHazzer(desc, field, resolved_field_name,
|
|
resolved_upbc_name, output);
|
|
WriteFieldAccessorClear(desc, field, resolved_field_name,
|
|
resolved_upbc_name, output);
|
|
|
|
if (field->is_map()) {
|
|
WriteMapFieldAccessors(desc, field, resolved_field_name,
|
|
resolved_upbc_name, output);
|
|
} else if (desc->options().map_entry()) {
|
|
// TODO Implement map entry
|
|
} else if (field->is_repeated()) {
|
|
WriteRepeatedFieldsInMessageHeader(desc, field, resolved_field_name,
|
|
resolved_upbc_name, output);
|
|
} else {
|
|
// non-repeated.
|
|
if (field->cpp_type() == protobuf::FieldDescriptor::CPPTYPE_STRING) {
|
|
output(R"cc(
|
|
$0 $1() const;
|
|
void set_$1($0 value);
|
|
)cc",
|
|
CppConstType(field), resolved_field_name);
|
|
} else if (field->cpp_type() ==
|
|
protobuf::FieldDescriptor::CPPTYPE_MESSAGE) {
|
|
output(R"cc(
|
|
$1 $2() const;
|
|
$0 mutable_$2();
|
|
)cc",
|
|
MessagePtrConstType(field, /* const */ false),
|
|
MessagePtrConstType(field, /* const */ true),
|
|
resolved_field_name, resolved_upbc_name);
|
|
} else {
|
|
output(
|
|
R"cc(
|
|
inline $0 $1() const { return $2_$3(msg_); }
|
|
inline void set_$1($0 value) { return $2_set_$3(msg_, value); }
|
|
)cc",
|
|
CppConstType(field), resolved_field_name, MessageName(desc),
|
|
resolved_upbc_name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void WriteFieldAccessorHazzer(const protobuf::Descriptor* desc,
|
|
const protobuf::FieldDescriptor* field,
|
|
const absl::string_view resolved_field_name,
|
|
const absl::string_view resolved_upbc_name,
|
|
Output& output) {
|
|
// Generate hazzer (if any).
|
|
if (field->has_presence()) {
|
|
// Has presence.
|
|
output("inline bool has_$0() const { return $1_has_$2(msg_); }\n",
|
|
resolved_field_name, MessageName(desc), resolved_upbc_name);
|
|
}
|
|
}
|
|
|
|
void WriteFieldAccessorClear(const protobuf::Descriptor* desc,
|
|
const protobuf::FieldDescriptor* field,
|
|
const absl::string_view resolved_field_name,
|
|
const absl::string_view resolved_upbc_name,
|
|
Output& output) {
|
|
if (field->has_presence()) {
|
|
output("void clear_$0() { $2_clear_$1(msg_); }\n", resolved_field_name,
|
|
resolved_upbc_name, MessageName(desc));
|
|
}
|
|
}
|
|
|
|
void WriteMapFieldAccessors(const protobuf::Descriptor* desc,
|
|
const protobuf::FieldDescriptor* field,
|
|
const absl::string_view resolved_field_name,
|
|
const absl::string_view resolved_upbc_name,
|
|
Output& output) {
|
|
const protobuf::Descriptor* entry = field->message_type();
|
|
const protobuf::FieldDescriptor* key = entry->FindFieldByNumber(1);
|
|
const protobuf::FieldDescriptor* val = entry->FindFieldByNumber(2);
|
|
output(
|
|
R"cc(
|
|
inline size_t $0_size() const { return $1_$3_size(msg_); }
|
|
inline void clear_$0() { $1_clear_$3(msg_); }
|
|
void delete_$0($2 key);
|
|
)cc",
|
|
resolved_field_name, MessageName(desc), CppConstType(key),
|
|
resolved_upbc_name);
|
|
|
|
if (val->cpp_type() == protobuf::FieldDescriptor::CPPTYPE_MESSAGE) {
|
|
output(
|
|
R"cc(
|
|
bool set_$0($1 key, $3 value);
|
|
bool set_$0($1 key, $4 value);
|
|
absl::StatusOr<$3> get_$0($1 key);
|
|
)cc",
|
|
resolved_field_name, CppConstType(key), CppConstType(val),
|
|
MessagePtrConstType(val, /* is_const */ true),
|
|
MessagePtrConstType(val, /* is_const */ false));
|
|
} else {
|
|
output(
|
|
R"cc(
|
|
bool set_$0($1 key, $2 value);
|
|
absl::StatusOr<$2> get_$0($1 key);
|
|
)cc",
|
|
resolved_field_name, CppConstType(key), CppConstType(val));
|
|
}
|
|
}
|
|
|
|
void WriteAccessorsInSource(const protobuf::Descriptor* desc, Output& output) {
|
|
std::string class_name = ClassName(desc);
|
|
absl::StrAppend(&class_name, "Access");
|
|
output("namespace internal {\n");
|
|
const char arena_expression[] = "arena_";
|
|
auto field_names = CreateFieldNameMap(desc);
|
|
auto upbc_field_names = upb::generator::CreateFieldNameMap(desc);
|
|
|
|
// Generate const methods.
|
|
OutputIndenter i(output);
|
|
for (const auto* field : FieldNumberOrder(desc)) {
|
|
std::string resolved_field_name = ResolveFieldName(field, field_names);
|
|
std::string resolved_upbc_name =
|
|
upb::generator::ResolveFieldName(field, upbc_field_names);
|
|
if (field->is_map()) {
|
|
WriteMapAccessorDefinitions(desc, field, resolved_field_name, class_name,
|
|
output);
|
|
} else if (desc->options().map_entry()) {
|
|
// TODO Implement map entry
|
|
} else if (field->is_repeated()) {
|
|
if (field->cpp_type() == protobuf::FieldDescriptor::CPPTYPE_MESSAGE) {
|
|
WriteRepeatedMessageAccessor(desc, field, resolved_field_name,
|
|
class_name, output);
|
|
} else if (field->cpp_type() ==
|
|
protobuf::FieldDescriptor::CPPTYPE_STRING) {
|
|
WriteRepeatedStringAccessor(desc, field, resolved_field_name,
|
|
class_name, output);
|
|
} else {
|
|
WriteRepeatedScalarAccessor(desc, field, resolved_field_name,
|
|
class_name, output);
|
|
}
|
|
} else {
|
|
// non-repeated field.
|
|
if (field->cpp_type() == protobuf::FieldDescriptor::CPPTYPE_STRING) {
|
|
output(
|
|
R"cc(
|
|
$1 $0::$2() const {
|
|
return ::protos::UpbStrToStringView($3_$4(msg_));
|
|
}
|
|
)cc",
|
|
class_name, CppConstType(field), resolved_field_name,
|
|
MessageName(desc), resolved_upbc_name);
|
|
// Set string.
|
|
output(
|
|
R"cc(
|
|
void $0::set_$2($1 value) {
|
|
$4_set_$3(msg_, ::protos::UpbStrFromStringView(value, $5));
|
|
}
|
|
)cc",
|
|
class_name, CppConstType(field), resolved_field_name,
|
|
resolved_upbc_name, MessageName(desc), arena_expression);
|
|
} else if (field->cpp_type() ==
|
|
protobuf::FieldDescriptor::CPPTYPE_MESSAGE) {
|
|
output(
|
|
R"cc(
|
|
$1 $0::$2() const {
|
|
if (!has_$2()) {
|
|
return $4::default_instance();
|
|
}
|
|
return ::protos::internal::CreateMessage<$4>(
|
|
(upb_Message*)($3_$5(msg_)), arena_);
|
|
}
|
|
)cc",
|
|
class_name, MessagePtrConstType(field, /* is_const */ true),
|
|
resolved_field_name, MessageName(desc),
|
|
MessageBaseType(field, /* maybe_const */ false),
|
|
resolved_upbc_name);
|
|
|
|
output(
|
|
R"cc(
|
|
$1 $0::mutable_$2() {
|
|
return ::protos::internal::CreateMessageProxy<$4>(
|
|
(upb_Message*)($3_mutable_$5(msg_, $6)), $6);
|
|
}
|
|
)cc",
|
|
class_name, MessagePtrConstType(field, /* is_const */ false),
|
|
resolved_field_name, MessageName(desc),
|
|
MessageBaseType(field, /* maybe_const */ false), resolved_upbc_name,
|
|
arena_expression);
|
|
}
|
|
}
|
|
}
|
|
output("\n");
|
|
output("} // namespace internal\n\n");
|
|
}
|
|
|
|
void WriteMapAccessorDefinitions(const protobuf::Descriptor* message,
|
|
const protobuf::FieldDescriptor* field,
|
|
const absl::string_view resolved_field_name,
|
|
const absl::string_view class_name,
|
|
Output& output) {
|
|
const protobuf::Descriptor* entry = field->message_type();
|
|
const protobuf::FieldDescriptor* key = entry->FindFieldByNumber(1);
|
|
const protobuf::FieldDescriptor* val = entry->FindFieldByNumber(2);
|
|
absl::string_view upbc_name = field->name();
|
|
absl::string_view converted_key_name = "key";
|
|
absl::string_view optional_conversion_code = "";
|
|
|
|
if (key->cpp_type() == protobuf::FieldDescriptor::CPPTYPE_STRING) {
|
|
// Insert conversion from absl::string_view to upb_StringView.
|
|
// Creates upb_StringView on stack to prevent allocation.
|
|
converted_key_name = "upb_key";
|
|
optional_conversion_code =
|
|
"upb_StringView upb_key = {key.data(), key.size()};\n";
|
|
}
|
|
if (val->cpp_type() == protobuf::FieldDescriptor::CPPTYPE_MESSAGE) {
|
|
output(
|
|
R"cc(
|
|
bool $0::set_$1($2 key, $3 value) {
|
|
upb_Message* clone = upb_Message_DeepClone(
|
|
::protos::internal::PrivateAccess::GetInternalMsg(value), &$9,
|
|
arena_);
|
|
$6return $4_$8_set(msg_, $7, ($5*)clone, arena_);
|
|
}
|
|
)cc",
|
|
class_name, resolved_field_name, CppConstType(key),
|
|
MessagePtrConstType(val, /* is_const */ true), MessageName(message),
|
|
MessageName(val->message_type()), optional_conversion_code,
|
|
converted_key_name, upbc_name,
|
|
::upb::generator::MessageInit(val->message_type()->full_name()));
|
|
output(
|
|
R"cc(
|
|
bool $0::set_$1($2 key, $3 value) {
|
|
upb_Message* clone = upb_Message_DeepClone(
|
|
::protos::internal::PrivateAccess::GetInternalMsg(value), &$9,
|
|
arena_);
|
|
$6return $4_$8_set(msg_, $7, ($5*)clone, arena_);
|
|
}
|
|
)cc",
|
|
class_name, resolved_field_name, CppConstType(key),
|
|
MessagePtrConstType(val, /* is_const */ false), MessageName(message),
|
|
MessageName(val->message_type()), optional_conversion_code,
|
|
converted_key_name, upbc_name,
|
|
::upb::generator::MessageInit(val->message_type()->full_name()));
|
|
output(
|
|
R"cc(
|
|
absl::StatusOr<$3> $0::get_$1($2 key) {
|
|
$5* msg_value;
|
|
$7bool success = $4_$9_get(msg_, $8, &msg_value);
|
|
if (success) {
|
|
return ::protos::internal::CreateMessage<$6>(UPB_UPCAST(msg_value), arena_);
|
|
}
|
|
return absl::NotFoundError("");
|
|
}
|
|
)cc",
|
|
class_name, resolved_field_name, CppConstType(key),
|
|
MessagePtrConstType(val, /* is_const */ true), MessageName(message),
|
|
MessageName(val->message_type()),
|
|
QualifiedClassName(val->message_type()), optional_conversion_code,
|
|
converted_key_name, upbc_name);
|
|
output(
|
|
R"cc(
|
|
void $0::delete_$1($2 key) { $6$4_$8_delete(msg_, $7); }
|
|
)cc",
|
|
class_name, resolved_field_name, CppConstType(key),
|
|
MessagePtrConstType(val, /* is_const */ false), MessageName(message),
|
|
MessageName(val->message_type()), optional_conversion_code,
|
|
converted_key_name, upbc_name);
|
|
} else if (val->cpp_type() == protobuf::FieldDescriptor::CPPTYPE_STRING) {
|
|
output(
|
|
R"cc(
|
|
bool $0::set_$1($2 key, $3 value) {
|
|
$5return $4_$7_set(msg_, $6,
|
|
::protos::UpbStrFromStringView(value, arena_),
|
|
arena_);
|
|
}
|
|
)cc",
|
|
class_name, resolved_field_name, CppConstType(key), CppConstType(val),
|
|
MessageName(message), optional_conversion_code, converted_key_name,
|
|
upbc_name);
|
|
output(
|
|
R"cc(
|
|
absl::StatusOr<$3> $0::get_$1($2 key) {
|
|
upb_StringView value;
|
|
$5bool success = $4_$7_get(msg_, $6, &value);
|
|
if (success) {
|
|
return absl::string_view(value.data, value.size);
|
|
}
|
|
return absl::NotFoundError("");
|
|
}
|
|
)cc",
|
|
class_name, resolved_field_name, CppConstType(key), CppConstType(val),
|
|
MessageName(message), optional_conversion_code, converted_key_name,
|
|
upbc_name);
|
|
output(
|
|
R"cc(
|
|
void $0::delete_$1($2 key) { $5$4_$7_delete(msg_, $6); }
|
|
)cc",
|
|
class_name, resolved_field_name, CppConstType(key), CppConstType(val),
|
|
MessageName(message), optional_conversion_code, converted_key_name,
|
|
upbc_name);
|
|
} else {
|
|
output(
|
|
R"cc(
|
|
bool $0::set_$1($2 key, $3 value) {
|
|
$5return $4_$7_set(msg_, $6, value, arena_);
|
|
}
|
|
)cc",
|
|
class_name, resolved_field_name, CppConstType(key), CppConstType(val),
|
|
MessageName(message), optional_conversion_code, converted_key_name,
|
|
upbc_name);
|
|
output(
|
|
R"cc(
|
|
absl::StatusOr<$3> $0::get_$1($2 key) {
|
|
$3 value;
|
|
$5bool success = $4_$7_get(msg_, $6, &value);
|
|
if (success) {
|
|
return value;
|
|
}
|
|
return absl::NotFoundError("");
|
|
}
|
|
)cc",
|
|
class_name, resolved_field_name, CppConstType(key), CppConstType(val),
|
|
MessageName(message), optional_conversion_code, converted_key_name,
|
|
upbc_name);
|
|
output(
|
|
R"cc(
|
|
void $0::delete_$1($2 key) { $5$4_$7_delete(msg_, $6); }
|
|
)cc",
|
|
class_name, resolved_field_name, CppConstType(key), CppConstType(val),
|
|
MessageName(message), optional_conversion_code, converted_key_name,
|
|
upbc_name);
|
|
}
|
|
}
|
|
|
|
void WriteUsingAccessorsInHeader(const protobuf::Descriptor* desc,
|
|
MessageClassType handle_type, Output& output) {
|
|
bool read_only = handle_type == MessageClassType::kMessageCProxy;
|
|
|
|
// Generate const methods.
|
|
OutputIndenter i(output);
|
|
std::string class_name = ClassName(desc);
|
|
auto field_names = CreateFieldNameMap(desc);
|
|
|
|
for (const auto* field : FieldNumberOrder(desc)) {
|
|
std::string resolved_field_name = ResolveFieldName(field, field_names);
|
|
// Generate hazzer (if any).
|
|
if (field->has_presence()) {
|
|
output("using $0Access::has_$1;\n", class_name, resolved_field_name);
|
|
if (!read_only) {
|
|
output("using $0Access::clear_$1;\n", class_name, resolved_field_name);
|
|
}
|
|
}
|
|
if (field->is_map()) {
|
|
output(
|
|
R"cc(
|
|
using $0Access::$1_size;
|
|
using $0Access::get_$1;
|
|
)cc",
|
|
class_name, resolved_field_name);
|
|
if (!read_only) {
|
|
output(
|
|
R"cc(
|
|
using $0Access::clear_$1;
|
|
using $0Access::delete_$1;
|
|
using $0Access::set_$1;
|
|
)cc",
|
|
class_name, resolved_field_name);
|
|
}
|
|
} else if (desc->options().map_entry()) {
|
|
// TODO Implement map entry
|
|
} else if (field->is_repeated()) {
|
|
WriteRepeatedFieldUsingAccessors(field, class_name, resolved_field_name,
|
|
output, read_only);
|
|
} else {
|
|
if (field->cpp_type() == protobuf::FieldDescriptor::CPPTYPE_MESSAGE) {
|
|
output("using $0Access::$1;\n", ClassName(desc), resolved_field_name);
|
|
if (!read_only) {
|
|
output("using $0Access::mutable_$1;\n", class_name,
|
|
resolved_field_name);
|
|
}
|
|
} else {
|
|
output("using $0Access::$1;\n", class_name, resolved_field_name);
|
|
if (!read_only) {
|
|
output("using $0Access::set_$1;\n", class_name, resolved_field_name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (int i = 0; i < desc->real_oneof_decl_count(); ++i) {
|
|
const protobuf::OneofDescriptor* oneof = desc->oneof_decl(i);
|
|
output("using $0Access::$1_case;\n", class_name, oneof->name());
|
|
output("using $0Access::$1Case;\n", class_name,
|
|
ToCamelCase(oneof->name(), /*lower_first=*/false));
|
|
for (int j = 0; j < oneof->field_count(); ++j) {
|
|
const protobuf::FieldDescriptor* field = oneof->field(j);
|
|
output("using $0Access::k$1;\n", class_name,
|
|
ToCamelCase(field->name(), /*lower_first=*/false),
|
|
field->number());
|
|
}
|
|
output("using $0Access::$1_NOT_SET;\n", class_name,
|
|
absl::AsciiStrToUpper(oneof->name()));
|
|
}
|
|
}
|
|
|
|
void WriteOneofAccessorsInHeader(const protobuf::Descriptor* desc,
|
|
Output& output) {
|
|
// Generate const methods.
|
|
OutputIndenter i(output);
|
|
std::string class_name = ClassName(desc);
|
|
auto field_names = CreateFieldNameMap(desc);
|
|
for (int i = 0; i < desc->real_oneof_decl_count(); ++i) {
|
|
const protobuf::OneofDescriptor* oneof = desc->oneof_decl(i);
|
|
output("enum $0Case {\n",
|
|
ToCamelCase(oneof->name(), /*lower_first=*/false));
|
|
for (int j = 0; j < oneof->field_count(); ++j) {
|
|
const protobuf::FieldDescriptor* field = oneof->field(j);
|
|
output(" k$0 = $1,\n", ToCamelCase(field->name(), /*lower_first=*/false),
|
|
field->number());
|
|
}
|
|
output(" $0_NOT_SET = 0,\n", absl::AsciiStrToUpper(oneof->name()));
|
|
output("};\n\n");
|
|
output("$0Case $1_case() const {\n",
|
|
ToCamelCase(oneof->name(), /*lower_first=*/false), oneof->name());
|
|
for (int j = 0; j < oneof->field_count(); ++j) {
|
|
const protobuf::FieldDescriptor* field = oneof->field(j);
|
|
std::string resolved_field_name = ResolveFieldName(field, field_names);
|
|
output(" if (has_$0()) { return k$1; }\n", resolved_field_name,
|
|
ToCamelCase(field->name(), /*lower_first=*/false));
|
|
}
|
|
output(" return $0_NOT_SET;\n", absl::AsciiStrToUpper(oneof->name()));
|
|
output("}\n;");
|
|
}
|
|
}
|
|
|
|
std::string ResolveFieldName(const protobuf::FieldDescriptor* field,
|
|
const NameToFieldDescriptorMap& field_names) {
|
|
// C++ implementation specific reserved names.
|
|
static const auto& kReservedNames =
|
|
*new absl::flat_hash_set<absl::string_view>({
|
|
"msg",
|
|
"msg_",
|
|
"arena",
|
|
"arena_",
|
|
});
|
|
|
|
// C++ specific prefixes used by code generator for field access.
|
|
static constexpr absl::string_view kClearMethodPrefix = "clear_";
|
|
static constexpr absl::string_view kSetMethodPrefix = "set_";
|
|
static constexpr absl::string_view kHasMethodPrefix = "has_";
|
|
static constexpr absl::string_view kDeleteMethodPrefix = "delete_";
|
|
static constexpr absl::string_view kAddToRepeatedMethodPrefix = "add_";
|
|
static constexpr absl::string_view kResizeArrayMethodPrefix = "resize_";
|
|
|
|
// List of generated accessor prefixes to check against.
|
|
// Example:
|
|
// optional repeated string phase = 236;
|
|
// optional bool clear_phase = 237;
|
|
static constexpr absl::string_view kAccessorPrefixes[] = {
|
|
kClearMethodPrefix, kDeleteMethodPrefix, kAddToRepeatedMethodPrefix,
|
|
kResizeArrayMethodPrefix, kSetMethodPrefix, kHasMethodPrefix};
|
|
|
|
absl::string_view field_name = field->name();
|
|
if (kReservedNames.count(field_name) > 0) {
|
|
if (absl::EndsWith(field_name, "_")) {
|
|
return absl::StrCat(field_name, "_");
|
|
} else {
|
|
return absl::StrCat(field_name, "__");
|
|
}
|
|
}
|
|
for (const auto prefix : kAccessorPrefixes) {
|
|
// If field name starts with a prefix such as clear_ and the proto
|
|
// contains a field name with trailing end, depending on type of field
|
|
// (repeated, map, message) we have a conflict to resolve.
|
|
if (absl::StartsWith(field_name, prefix)) {
|
|
auto match = field_names.find(field_name.substr(prefix.size()));
|
|
if (match != field_names.end()) {
|
|
const auto* candidate = match->second;
|
|
if (candidate->is_repeated() || candidate->is_map() ||
|
|
(candidate->cpp_type() ==
|
|
protobuf::FieldDescriptor::CPPTYPE_STRING &&
|
|
prefix == kClearMethodPrefix) ||
|
|
prefix == kSetMethodPrefix || prefix == kHasMethodPrefix) {
|
|
return absl::StrCat(field_name, "_");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return upb::generator::ResolveKeywordConflict(std::string(field_name));
|
|
}
|
|
|
|
} // namespace protos_generator
|