aboutsummaryrefslogtreecommitdiffhomepage
path: root/src/google/protobuf/compiler/cpp/cpp_string_field.cc
diff options
context:
space:
mode:
Diffstat (limited to 'src/google/protobuf/compiler/cpp/cpp_string_field.cc')
-rw-r--r--src/google/protobuf/compiler/cpp/cpp_string_field.cc177
1 files changed, 140 insertions, 37 deletions
diff --git a/src/google/protobuf/compiler/cpp/cpp_string_field.cc b/src/google/protobuf/compiler/cpp/cpp_string_field.cc
index c9901e84..cf6c4b33 100644
--- a/src/google/protobuf/compiler/cpp/cpp_string_field.cc
+++ b/src/google/protobuf/compiler/cpp/cpp_string_field.cc
@@ -34,8 +34,8 @@
#include <google/protobuf/compiler/cpp/cpp_string_field.h>
#include <google/protobuf/compiler/cpp/cpp_helpers.h>
-#include <google/protobuf/io/printer.h>
#include <google/protobuf/descriptor.pb.h>
+#include <google/protobuf/io/printer.h>
#include <google/protobuf/stubs/strutil.h>
@@ -53,7 +53,7 @@ void SetStringVariables(const FieldDescriptor* descriptor,
(*variables)["default"] = DefaultValue(descriptor);
(*variables)["default_length"] =
SimpleItoa(descriptor->default_value_string().length());
- string default_variable_string = "_default_" + FieldName(descriptor) + "_";
+ string default_variable_string = MakeDefaultName(descriptor);
(*variables)["default_variable_name"] = default_variable_string;
(*variables)["default_variable"] =
descriptor->default_value_string().empty()
@@ -82,8 +82,24 @@ void SetStringVariables(const FieldDescriptor* descriptor,
StringFieldGenerator::StringFieldGenerator(const FieldDescriptor* descriptor,
const Options& options)
- : FieldGenerator(options), descriptor_(descriptor),
- lite_(!HasDescriptorMethods(descriptor->file(), options)) {
+ : FieldGenerator(options),
+ descriptor_(descriptor),
+ lite_(!HasDescriptorMethods(descriptor->file(), options)),
+ inlined_(false) {
+
+ // TODO(ckennelly): Handle inlining for any.proto.
+ if (IsAnyMessage(descriptor_->containing_type())) {
+ inlined_ = false;
+ }
+ if (descriptor_->containing_type()->options().map_entry()) {
+ inlined_ = false;
+ }
+
+ // Limit to proto2, as we rely on has bits to distinguish field presence for
+ // release_$name$. On proto3, we cannot use the address of the string
+ // instance when the field has been inlined.
+ inlined_ = inlined_ && HasFieldPresence(descriptor_->file());
+
SetStringVariables(descriptor, &variables_, options);
}
@@ -91,27 +107,36 @@ StringFieldGenerator::~StringFieldGenerator() {}
void StringFieldGenerator::
GeneratePrivateMembers(io::Printer* printer) const {
- // N.B. that we continue to use |ArenaStringPtr| instead of |string*| for
- // string fields, even when SupportArenas(descriptor_) == false. Why?
- // The simple answer is to avoid unmaintainable complexity. The reflection
- // code assumes ArenaStringPtrs. These are *almost* in-memory-compatible with
- // string*, except for the pointer tags and related ownership semantics. We
- // could modify the runtime code to use string* for the not-supporting-arenas
- // case, but this would require a way to detect which type of class was
- // generated (adding overhead and complexity to GeneratedMessageReflection)
- // and littering the runtime code paths with conditionals. It's simpler to
- // stick with this but use lightweight accessors that assume arena == NULL.
- // There should be very little overhead anyway because it's just a tagged
- // pointer in-memory.
- printer->Print(variables_, "::google::protobuf::internal::ArenaStringPtr $name$_;\n");
+ if (inlined_) {
+ printer->Print(variables_,
+ "::google::protobuf::internal::InlinedStringField $name$_;\n");
+ } else {
+ // N.B. that we continue to use |ArenaStringPtr| instead of |string*| for
+ // string fields, even when SupportArenas(descriptor_) == false. Why? The
+ // simple answer is to avoid unmaintainable complexity. The reflection code
+ // assumes ArenaStringPtrs. These are *almost* in-memory-compatible with
+ // string*, except for the pointer tags and related ownership semantics. We
+ // could modify the runtime code to use string* for the
+ // not-supporting-arenas case, but this would require a way to detect which
+ // type of class was generated (adding overhead and complexity to
+ // GeneratedMessageReflection) and littering the runtime code paths with
+ // conditionals. It's simpler to stick with this but use lightweight
+ // accessors that assume arena == NULL. There should be very little
+ // overhead anyway because it's just a tagged pointer in-memory.
+ printer->Print(variables_, "::google::protobuf::internal::ArenaStringPtr $name$_;\n");
+ }
}
void StringFieldGenerator::
GenerateStaticMembers(io::Printer* printer) const {
if (!descriptor_->default_value_string().empty()) {
+ // We make the default instance public, so it can be initialized by
+ // non-friend code.
printer->Print(variables_,
+ "public:\n"
"static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string>"
- " $default_variable_name$;\n");
+ " $default_variable_name$;\n"
+ "private:\n");
}
}
@@ -246,9 +271,23 @@ GenerateInlineAccessorDefinitions(io::Printer* printer) const {
" return $name$_.Mutable($default_variable$, GetArenaNoVirtual());\n"
"}\n"
"inline ::std::string* $classname$::$release_name$() {\n"
- " // @@protoc_insertion_point(field_release:$full_name$)\n"
+ " // @@protoc_insertion_point(field_release:$full_name$)\n");
+
+ if (HasFieldPresence(descriptor_->file())) {
+ printer->Print(variables_,
+ " if (!has_$name$()) {\n"
+ " return NULL;\n"
+ " }\n"
+ " $clear_hasbit$\n"
+ " return $name$_.ReleaseNonDefault("
+ "$default_variable$, GetArenaNoVirtual());\n");
+ } else {
+ printer->Print(variables_,
" $clear_hasbit$\n"
- " return $name$_.Release($default_variable$, GetArenaNoVirtual());\n"
+ " return $name$_.Release($default_variable$, GetArenaNoVirtual());\n");
+ }
+
+ printer->Print(variables_,
"}\n"
"inline void $classname$::set_allocated_$name$(::std::string* $name$) {\n"
" if ($name$ != NULL) {\n"
@@ -322,9 +361,22 @@ GenerateInlineAccessorDefinitions(io::Printer* printer) const {
" return $name$_.MutableNoArena($default_variable$);\n"
"}\n"
"inline ::std::string* $classname$::$release_name$() {\n"
- " // @@protoc_insertion_point(field_release:$full_name$)\n"
+ " // @@protoc_insertion_point(field_release:$full_name$)\n");
+
+ if (HasFieldPresence(descriptor_->file())) {
+ printer->Print(variables_,
+ " if (!has_$name$()) {\n"
+ " return NULL;\n"
+ " }\n"
" $clear_hasbit$\n"
- " return $name$_.ReleaseNoArena($default_variable$);\n"
+ " return $name$_.ReleaseNonDefaultNoArena($default_variable$);\n");
+ } else {
+ printer->Print(variables_,
+ " $clear_hasbit$\n"
+ " return $name$_.ReleaseNoArena($default_variable$);\n");
+ }
+
+ printer->Print(variables_,
"}\n"
"inline void $classname$::set_allocated_$name$(::std::string* $name$) {\n"
" if ($name$ != NULL) {\n"
@@ -343,7 +395,7 @@ GenerateNonInlineAccessorDefinitions(io::Printer* printer) const {
if (!descriptor_->default_value_string().empty()) {
// Initialized in GenerateDefaultInstanceAllocator.
printer->Print(variables_,
- "::google::protobuf::internal::ExplicitlyConstructed< ::std::string> "
+ "::google::protobuf::internal::ExplicitlyConstructed<::std::string> "
"$classname$::$default_variable_name$;\n");
}
}
@@ -383,18 +435,34 @@ GenerateMessageClearingCode(io::Printer* printer) const {
// If we have field presence, then the Clear() method of the protocol buffer
// will have checked that this field is set. If so, we can avoid redundant
// checks against default_variable.
- const bool must_be_present = HasFieldPresence(descriptor_->file());
-
- if (must_be_present) {
+ const bool must_be_present =
+ HasFieldPresence(descriptor_->file());
+
+ if (inlined_ && must_be_present) {
+ // Calling mutable_$name$() gives us a string reference and sets the has bit
+ // for $name$ (in proto2). We may get here when the string field is inlined
+ // but the string's contents have not been changed by the user, so we cannot
+ // make an assertion about the contents of the string and could never make
+ // an assertion about the string instance.
+ //
+ // For non-inlined strings, we distinguish from non-default by comparing
+ // instances, rather than contents.
printer->Print(variables_,
"GOOGLE_DCHECK(!$name$_.IsDefault($default_variable$));\n");
}
if (SupportsArenas(descriptor_)) {
if (descriptor_->default_value_string().empty()) {
- printer->Print(variables_,
- "$name$_.ClearToEmpty($default_variable$, GetArenaNoVirtual());\n");
+ if (must_be_present) {
+ printer->Print(variables_,
+ "$name$_.ClearNonDefaultToEmpty();\n");
+ } else {
+ printer->Print(variables_,
+ "$name$_.ClearToEmpty($default_variable$, GetArenaNoVirtual());\n");
+ }
} else {
+ // Clear to a non-empty default is more involved, as we try to use the
+ // Arena if one is present and may need to reallocate the string.
printer->Print(variables_,
"$name$_.ClearToDefault($default_variable$, GetArenaNoVirtual());\n");
}
@@ -402,7 +470,7 @@ GenerateMessageClearingCode(io::Printer* printer) const {
// When Arenas are disabled and field presence has been checked, we can
// safely treat the ArenaStringPtr as a string*.
if (descriptor_->default_value_string().empty()) {
- printer->Print(variables_, "$name$_.UnsafeMutablePointer()->clear();\n");
+ printer->Print(variables_, "$name$_.ClearNonDefaultToEmptyNoArena();\n");
} else {
printer->Print(
variables_,
@@ -433,13 +501,29 @@ GenerateMergingCode(io::Printer* printer) const {
void StringFieldGenerator::
GenerateSwappingCode(io::Printer* printer) const {
- printer->Print(variables_, "$name$_.Swap(&other->$name$_);\n");
+ if (inlined_) {
+ printer->Print(
+ variables_,
+ "$name$_.Swap(&other->$name$_);\n");
+ } else {
+ printer->Print(
+ variables_,
+ "$name$_.Swap(&other->$name$_, $default_variable$,\n"
+ " GetArenaNoVirtual());\n");
+ }
}
void StringFieldGenerator::
GenerateConstructorCode(io::Printer* printer) const {
+ // TODO(ckennelly): Construct non-empty strings as part of the initializer
+ // list.
+ if (inlined_ && descriptor_->default_value_string().empty()) {
+ // Automatic initialization will construct the string.
+ return;
+ }
+
printer->Print(variables_,
- "$name$_.UnsafeSetDefault($default_variable$);\n");
+ "$name$_.UnsafeSetDefault($default_variable$);\n");
}
void StringFieldGenerator::
@@ -472,8 +556,23 @@ GenerateCopyConstructorCode(io::Printer* printer) const {
void StringFieldGenerator::
GenerateDestructorCode(io::Printer* printer) const {
+ if (inlined_) {
+ // The destructor is automatically invoked.
+ return;
+ }
+
+ printer->Print(variables_, "$name$_.DestroyNoArena($default_variable$);\n");
+}
+
+bool StringFieldGenerator::GenerateArenaDestructorCode(
+ io::Printer* printer) const {
+ if (!inlined_) {
+ return false;
+ }
+
printer->Print(variables_,
- "$name$_.DestroyNoArena($default_variable$);\n");
+ "_this->$name$_.DestroyNoArena($default_variable$);\n");
+ return true;
}
void StringFieldGenerator::
@@ -544,13 +643,17 @@ GenerateByteSize(io::Printer* printer) const {
" this->$name$());\n");
}
+uint32 StringFieldGenerator::CalculateFieldTag() const {
+ return inlined_ ? 1 : 0;
+}
+
// ===================================================================
-StringOneofFieldGenerator::
-StringOneofFieldGenerator(const FieldDescriptor* descriptor,
- const Options& options)
- : StringFieldGenerator(descriptor, options),
- dependent_field_(options.proto_h) {
+StringOneofFieldGenerator::StringOneofFieldGenerator(
+ const FieldDescriptor* descriptor, const Options& options)
+ : StringFieldGenerator(descriptor, options) {
+ inlined_ = false;
+
SetCommonOneofFieldVariables(descriptor, &variables_);
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-19 17:09:16 +0000