mmo-ref/dep-protobuf
1
0
Fork 0
mirror of https://github.com/protocolbuffers/protobuf synced 2026-08-26 02:23:14 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Internal change.

Browse source 
PiperOrigin-RevId: 927378628
This commit is contained in:
Protobuf Team Bot 2026-06-05 10:51:42 -07:00 • committed by Copybara-Service
parent 0d1d7734eb
commit 2f379150bb
6 changed files with 76 additions and 151 deletions
Download patch file Download diff file Expand all files Collapse all files

1
src/google/protobuf/BUILD.bazel
View file

@ -646,7 +646,6 @@ cc_library(
":port",
"@abseil-cpp//absl/base:config",
"@abseil-cpp//absl/log:absl_check",
"@abseil-cpp//absl/strings:cord",
"@abseil-cpp//absl/strings:string_view",
],
)

15
src/google/protobuf/arenastring.h
View file

@ -15,7 +15,6 @@
#include <utility>
#include "absl/log/absl_check.h"
#include "absl/strings/cord.h"
#include "absl/strings/string_view.h"
#include "google/protobuf/arena.h"
#include "google/protobuf/explicitly_constructed.h"
@ -298,7 +297,6 @@ struct PROTOBUF_EXPORT ArenaStringPtr {
void Set(absl::string_view value, Arena* arena);
void Set(std::string&& value, Arena* arena);
void Set(const absl::Cord& value, Arena* arena);
template <typename... OverloadDisambiguator>
void Set(const std::string& value, Arena* arena);
void Set(const char* s, Arena* arena);
@ -308,7 +306,6 @@ struct PROTOBUF_EXPORT ArenaStringPtr {
void SetBytes(std::string&& value, Arena* arena);
template <typename... OverloadDisambiguator>
void SetBytes(const std::string& value, Arena* arena);
void SetBytes(const absl::Cord& value, Arena* arena);
void SetBytes(const char* s, Arena* arena);
void SetBytes(const void* p, size_t n, Arena* arena);
@ -468,14 +465,6 @@ inline void ArenaStringPtr::InitAllocated(std::string* str, Arena* arena) {
}
}
inline void ArenaStringPtr::Set(const absl::Cord& value, Arena* arena) {
if (auto flat = value.TryFlat(); flat.has_value()) {
Set(*flat, arena);
} else {
absl::CopyCordToString(value, MutableNoCopy(arena));
}
}
inline void ArenaStringPtr::Set(const char* s, Arena* arena) {
ABSL_DCHECK(s != nullptr);
Set(absl::string_view{s}, arena);
@ -502,10 +491,6 @@ inline void ArenaStringPtr::SetBytes(std::string&& value, Arena* arena) {
Set(std::move(value), arena);
}
inline void ArenaStringPtr::SetBytes(const absl::Cord& value, Arena* arena) {
Set(value, arena);
}
inline void ArenaStringPtr::SetBytes(const char* s, Arena* arena) {
Set(s, arena);
}

171
src/google/protobuf/generated_message_reflection.cc
View file

@ -315,16 +315,6 @@ using internal::GetConstPointerAtOffset;
using internal::GetConstRefAtOffset;
using internal::GetPointerAtOffset;
template <typename String>
static void Assign(std::string& str, String&& value) {
using RawString = std::decay_t<String>;
if constexpr (std::is_same_v<RawString, absl::Cord>) {
absl::CopyCordToString(value, &str);
} else {
str.assign(std::forward<String>(value));
}
}
void ReportReflectionUsageError(const Descriptor* descriptor,
const FieldDescriptor* field,
const char* method, const char* description) {
@ -2195,18 +2185,13 @@ absl::string_view Reflection::GetStringView(const Message& message,
}
template <typename String>
void Reflection::SetStringImpl(Message* message, const FieldDescriptor* field,
String&& value) const {
void Reflection::SetString(Message* message, const FieldDescriptor* field,
std::string value) const {
USAGE_MUTABLE_CHECK_ALL(SetString, SINGULAR, STRING);
Arena* arena = message->GetArena();
if (field->is_extension()) {
Assign(*MutableExtensionSet(message)->MutableString(
arena, field->number(),
field->requires_utf8_validation() ? FieldDescriptor::TYPE_STRING
: FieldDescriptor::TYPE_BYTES,
field),
std::forward<String>(value));
return;
return MutableExtensionSet(message)->Set<std::string>(
arena, field->number(), field->type(), std::move(value), field);
} else {
switch (field->cpp_string_type()) {
case FieldDescriptor::CppStringType::kCord:
@ -2216,17 +2201,15 @@ void Reflection::SetStringImpl(Message* message, const FieldDescriptor* field,
*MutableField<absl::Cord*>(message, field) =
Arena::Create<absl::Cord>(arena);
}
**MutableField<absl::Cord*>(message, field) =
std::forward<String>(value);
*(*MutableField<absl::Cord*>(message, field)) = value;
break;
}
*MutableField<absl::Cord>(message, field) = std::forward<String>(value);
*MutableField<absl::Cord>(message, field) = value;
break;
case FieldDescriptor::CppStringType::kView:
case FieldDescriptor::CppStringType::kString: {
if (IsInlined(field)) {
MutableField<InlinedStringField>(message, field)
->Set(std::forward<String>(value), arena);
MutableField<InlinedStringField>(message, field)->Set(value, arena);
break;
} else if (IsMicroString(field)) {
if (schema_.InRealOneof(field) && !HasOneofField(*message, field)) {
@ -2234,7 +2217,7 @@ void Reflection::SetStringImpl(Message* message, const FieldDescriptor* field,
MutableField<MicroString>(message, field)->InitDefault();
}
MutableField<MicroString>(message, field)
->Set(std::forward<String>(value), arena);
->Set(std::move(value), arena);
break;
}
@ -2247,29 +2230,59 @@ void Reflection::SetStringImpl(Message* message, const FieldDescriptor* field,
MutableField<ArenaStringPtr>(message, field)->InitDefault();
}
MutableField<ArenaStringPtr>(message, field)
->Set(std::forward<String>(value), arena);
->Set(std::move(value), arena);
break;
}
}
}
}
void Reflection::SetString(Message* message, const FieldDescriptor* field,
std::string value) const {
USAGE_MUTABLE_CHECK_ALL(SetString, SINGULAR, STRING);
SetStringImpl(message, field, std::move(value));
}
void Reflection::SetStringView(Message* message, const FieldDescriptor* field,
absl::string_view value) const {
USAGE_MUTABLE_CHECK_ALL(SetStringView, SINGULAR, STRING);
SetStringImpl(message, field, value);
}
void Reflection::SetString(Message* message, const FieldDescriptor* field,
const absl::Cord& value) const {
USAGE_MUTABLE_CHECK_ALL(SetString, SINGULAR, STRING);
SetStringImpl(message, field, value);
Arena* arena = message->GetArena();
if (field->is_extension()) {
return absl::CopyCordToString(
value, MutableExtensionSet(message)->MutableString(
arena, field->number(), field->type(), field));
} else {
switch (field->cpp_string_type()) {
case FieldDescriptor::CppStringType::kCord:
if (schema_.InRealOneof(field)) {
if (!HasOneofField(*message, field)) {
ClearOneof(message, field->containing_oneof());
*MutableField<absl::Cord*>(message, field) =
Arena::Create<absl::Cord>(arena);
}
*(*MutableField<absl::Cord*>(message, field)) = value;
} else {
*MutableField<absl::Cord>(message, field) = value;
}
break;
case FieldDescriptor::CppStringType::kView:
case FieldDescriptor::CppStringType::kString: {
if (IsInlined(field)) {
auto* str = MutableField<InlinedStringField>(message, field);
str->Set(std::string(value), arena);
} else if (IsMicroString(field)) {
if (schema_.InRealOneof(field) && !HasOneofField(*message, field)) {
ClearOneof(message, field->containing_oneof());
MutableField<MicroString>(message, field)->InitDefault();
}
auto* str = MutableField<MicroString>(message, field);
str->Set(std::string(value), arena);
} else {
if (schema_.InRealOneof(field) && !HasOneofField(*message, field)) {
ClearOneof(message, field->containing_oneof());
MutableField<ArenaStringPtr>(message, field)->InitDefault();
}
auto* str = MutableField<ArenaStringPtr>(message, field);
str->Set(std::string(value), arena);
}
break;
}
}
}
}
std::string Reflection::GetRepeatedString(const Message& message,
@ -2343,80 +2356,48 @@ absl::string_view Reflection::GetRepeatedStringView(
}
template <typename String>
void Reflection::SetRepeatedStringImpl(Message* message,
const FieldDescriptor* field, int index,
String&& value) const {
if (field->is_extension()) {
Assign(*MutableExtensionSet(message)->MutableRepeatedString(field->number(),
index),
std::forward<String>(value));
} else {
switch (field->cpp_string_type()) {
case FieldDescriptor::CppStringType::kCord:
SetRepeatedField<absl::Cord>(message, field, index,
absl::Cord(std::forward<String>(value)));
break;
case FieldDescriptor::CppStringType::kView:
case FieldDescriptor::CppStringType::kString:
Assign(*MutableRepeatedField<std::string>(message, field, index),
std::forward<String>(value));
break;
}
}
}
void Reflection::SetRepeatedString(Message* message,
const FieldDescriptor* field, int index,
std::string value) const {
USAGE_MUTABLE_CHECK_ALL(SetRepeatedString, REPEATED, STRING);
SetRepeatedStringImpl(message, field, index, std::move(value));
}
void Reflection::SetRepeatedStringView(Message* message,
const FieldDescriptor* field, int index,
absl::string_view value) const {
USAGE_MUTABLE_CHECK_ALL(SetRepeatedStringView, REPEATED, STRING);
SetRepeatedStringImpl(message, field, index, value);
}
template <typename String>
void Reflection::AddStringImpl(Message* message, const FieldDescriptor* field,
String&& value) const {
Arena* arena = message->GetArena();
if (field->is_extension()) {
Assign(*MutableExtensionSet(message)->AddString(
arena, field->number(),
field->requires_utf8_validation() ? FieldDescriptor::TYPE_STRING
: FieldDescriptor::TYPE_BYTES,
field),
std::forward<String>(value));
MutableExtensionSet(message)->SetRepeated<std::string>(
field->number(), index, std::move(value));
} else {
switch (field->cpp_string_type()) {
case FieldDescriptor::CppStringType::kCord:
AddField<absl::Cord>(message, field,
absl::Cord(std::forward<String>(value)));
SetRepeatedField<absl::Cord>(message, field, index, absl::Cord(value));
break;
case FieldDescriptor::CppStringType::kView:
case FieldDescriptor::CppStringType::kString:
Assign(*AddField<std::string>(message, field),
std::forward<String>(value));
MutableRepeatedField<std::string>(message, field, index)
->assign(std::move(value));
break;
}
}
}
void Reflection::AddString(Message* message, const FieldDescriptor* field,
std::string value) const {
USAGE_MUTABLE_CHECK_ALL(AddString, REPEATED, STRING);
AddStringImpl(message, field, std::move(value));
}
void Reflection::AddStringView(Message* message, const FieldDescriptor* field,
absl::string_view value) const {
USAGE_MUTABLE_CHECK_ALL(AddStringView, REPEATED, STRING);
AddStringImpl(message, field, value);
if (field->is_extension()) {
MutableExtensionSet(message)->Add<std::string>(
message->GetArena(), field->number(),
field->requires_utf8_validation() ? FieldDescriptor::TYPE_STRING
: FieldDescriptor::TYPE_BYTES,
field) = std::move(value);
} else {
switch (field->cpp_string_type()) {
case FieldDescriptor::CppStringType::kCord:
AddField<absl::Cord>(message, field, absl::Cord(value));
break;
case FieldDescriptor::CppStringType::kView:
case FieldDescriptor::CppStringType::kString:
AddField<std::string>(message, field)->assign(std::move(value));
break;
}
}
}

10
src/google/protobuf/inlined_string_field.h
View file

@ -14,7 +14,6 @@
#include <utility>
#include "absl/log/absl_check.h"
#include "absl/strings/cord.h"
#include "absl/strings/string_view.h"
#include "google/protobuf/arenastring.h"
#include "google/protobuf/explicitly_constructed.h"
@ -101,7 +100,6 @@ class PROTOBUF_EXPORT InlinedStringField {
// Lvalue Set.
void Set(absl::string_view value, Arena* arena);
void Set(const absl::Cord& value, Arena* arena);
// Rvalue Set. If this field is donated, this method might undonate this
// field.
@ -321,14 +319,6 @@ inline void InlinedStringField::Set(absl::string_view value, Arena* arena) {
SetNoArena(value);
}
inline void InlinedStringField::Set(const absl::Cord& value, Arena* arena) {
if (auto flat = value.TryFlat(); flat.has_value()) {
Set(*flat, arena);
} else {
Set(std::string(value), arena);
}
}
inline void InlinedStringField::Set(const char* str, Arena* arena) {
Set(absl::string_view(str), arena);
}

21
src/google/protobuf/message.h
View file

@ -1493,27 +1493,6 @@ class PROTOBUF_EXPORT Reflection final {
const Reflection* reflection,
const char* ptr,
internal::ParseContext* ctx);
void SetStringView(Message* message, const FieldDescriptor* field,
absl::string_view value) const;
void SetRepeatedStringView(Message* message, const FieldDescriptor* field,
int index, absl::string_view value) const;
void AddStringView(Message* message, const FieldDescriptor* field,
absl::string_view value) const;
// Supports const absl::Cord&, std::string&& and absl::string_view.
template <typename String>
void SetStringImpl(Message* message, const FieldDescriptor* field,
String&& value) const;
// Supports const absl::Cord&, std::string&& and absl::string_view.
template <typename String>
void SetRepeatedStringImpl(Message* message, const FieldDescriptor* field,
int index, String&& value) const;
// Supports const absl::Cord&, std::string&& and absl::string_view.
template <typename String>
void AddStringImpl(Message* message, const FieldDescriptor* field,
String&& value) const;
};
extern template void Reflection::SwapFieldsImpl<true>(

9
src/google/protobuf/micro_string.h
View file

@ -14,7 +14,6 @@
#include "absl/base/config.h"
#include "absl/log/absl_check.h"
#include "absl/strings/cord.h"
#include "absl/strings/string_view.h"
#include "google/protobuf/arena.h"
@ -206,14 +205,6 @@ class PROTOBUF_EXPORT MicroString {
void Set(absl::string_view data, Arena* arena) {
SetMaybeConstant(*this, data, arena);
}
void Set(const absl::Cord& value, Arena* arena) {
SetInChunks(value.size(), arena, [&value](auto append) {
for (absl::string_view chunk : value.Chunks()) {
append(chunk);
}
});
}
void Set(absl::string_view data, Arena* arena, size_t inline_capacity) {
SetImpl(data, arena, inline_capacity);
}