Chiebot-Mirror
/
protobuf
mirror of https://github.com/protocolbuffers/protobuf.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Introduce C++ feature for UTF8 validation.

Browse Source 
This will replace the frontend string_field_validation field, which we've discovered can't accurately model all of the unique behaviors in each language.

PiperOrigin-RevId: 556996541
pull/13395/head
Mike Kruskal 2 years ago committed by Copybara-Service
parent 3be00f7638
commit c7119e6d56
3 changed files with 231 additions and 27 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 128
      src/google/protobuf/cpp_features.pb.cc
  2. 109
      src/google/protobuf/cpp_features.pb.h
  3. 21
      src/google/protobuf/cpp_features.proto

128
src/google/protobuf/cpp_features.pb.cc
Unescape View File

@ -27,6 +27,7 @@ PROTOBUF_CONSTEXPR CppFeatures::CppFeatures(::_pbi::ConstantInitialized)
/*decltype(_impl_._has_bits_)*/ {},
/*decltype(_impl_._cached_size_)*/ {},
/*decltype(_impl_.legacy_closed_enum_)*/ false,
/*decltype(_impl_.utf8_validation_)*/ 0,
} {}
struct CppFeaturesDefaultTypeInternal {
PROTOBUF_CONSTEXPR CppFeaturesDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
@ -40,8 +41,7 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_EXPORT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CppFeaturesDefaultTypeInternal _CppFeatures_default_instance_;
} // namespace pb
static ::_pb::Metadata file_level_metadata_google_2fprotobuf_2fcpp_5ffeatures_2eproto[1];
static constexpr const ::_pb::EnumDescriptor**
file_level_enum_descriptors_google_2fprotobuf_2fcpp_5ffeatures_2eproto = nullptr;
static const ::_pb::EnumDescriptor* file_level_enum_descriptors_google_2fprotobuf_2fcpp_5ffeatures_2eproto[1];
static constexpr const ::_pb::ServiceDescriptor**
file_level_service_descriptors_google_2fprotobuf_2fcpp_5ffeatures_2eproto = nullptr;
const ::uint32_t TableStruct_google_2fprotobuf_2fcpp_5ffeatures_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(
@ -55,12 +55,14 @@ const ::uint32_t TableStruct_google_2fprotobuf_2fcpp_5ffeatures_2eproto::offsets
~0u, // no _split_
~0u, // no sizeof(Split)
PROTOBUF_FIELD_OFFSET(::pb::CppFeatures, _impl_.legacy_closed_enum_),
PROTOBUF_FIELD_OFFSET(::pb::CppFeatures, _impl_.utf8_validation_),
0,
1,
};
static const ::_pbi::MigrationSchema
schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
{0, 9, -1, sizeof(::pb::CppFeatures)},
{0, 10, -1, sizeof(::pb::CppFeatures)},
};
static const ::_pb::Message* const file_default_instances[] = {
@ -68,11 +70,15 @@ static const ::_pb::Message* const file_default_instances[] = {
};
const char descriptor_table_protodef_google_2fprotobuf_2fcpp_5ffeatures_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
"\n\"google/protobuf/cpp_features.proto\022\002pb"
"\032 google/protobuf/descriptor.proto\"D\n\013Cp"
"pFeatures\0225\n\022legacy_closed_enum\030\001 \001(\010B\031\210"
"\001\001\230\001\004\230\001\001\242\001\r\n\0042023\022\005false::\n\003cpp\022\033.google"
".protobuf.FeatureSet\030\350\007 \001(\0132\017.pb.CppFeat"
"ures"
"\032 google/protobuf/descriptor.proto\"\373\001\n\013C"
"ppFeatures\0225\n\022legacy_closed_enum\030\001 \001(\010B\031"
"\210\001\001\230\001\004\230\001\001\242\001\r\n\0042023\022\005false\022Y\n\017utf8_valida"
"tion\030\002 \001(\0162\036.pb.CppFeatures.Utf8Validati"
"onB \210\001\001\230\001\004\230\001\001\242\001\024\n\0042023\022\014VERIFY_PARSE\"Z\n\016"
"Utf8Validation\022\033\n\027UTF8_VALIDATION_UNKNOW"
"N\020\000\022\020\n\014VERIFY_PARSE\020\001\022\017\n\013VERIFY_DLOG\020\002\022\010"
"\n\004NONE\020\003::\n\003cpp\022\033.google.protobuf.Featur"
"eSet\030\350\007 \001(\0132\017.pb.CppFeatures"
};
static const ::_pbi::DescriptorTable* const descriptor_table_google_2fprotobuf_2fcpp_5ffeatures_2eproto_deps[1] =
{
@ -82,7 +88,7 @@ static ::absl::once_flag descriptor_table_google_2fprotobuf_2fcpp_5ffeatures_2ep
const ::_pbi::DescriptorTable descriptor_table_google_2fprotobuf_2fcpp_5ffeatures_2eproto = {
false,
false,
204,
388,
descriptor_table_protodef_google_2fprotobuf_2fcpp_5ffeatures_2eproto,
"google/protobuf/cpp_features.proto",
&descriptor_table_google_2fprotobuf_2fcpp_5ffeatures_2eproto_once,
@ -112,6 +118,34 @@ PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_google_2
return &descriptor_table_google_2fprotobuf_2fcpp_5ffeatures_2eproto;
}
namespace pb {
const ::google::protobuf::EnumDescriptor* CppFeatures_Utf8Validation_descriptor() {
::google::protobuf::internal::AssignDescriptors(&descriptor_table_google_2fprotobuf_2fcpp_5ffeatures_2eproto);
return file_level_enum_descriptors_google_2fprotobuf_2fcpp_5ffeatures_2eproto[0];
}
bool CppFeatures_Utf8Validation_IsValid(int value) {
switch (value) {
case 0:
case 1:
case 2:
case 3:
return true;
default:
return false;
}
}
#if (__cplusplus < 201703) && \
(!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr CppFeatures_Utf8Validation CppFeatures::UTF8_VALIDATION_UNKNOWN;
constexpr CppFeatures_Utf8Validation CppFeatures::VERIFY_PARSE;
constexpr CppFeatures_Utf8Validation CppFeatures::VERIFY_DLOG;
constexpr CppFeatures_Utf8Validation CppFeatures::NONE;
constexpr CppFeatures_Utf8Validation CppFeatures::Utf8Validation_MIN;
constexpr CppFeatures_Utf8Validation CppFeatures::Utf8Validation_MAX;
constexpr int CppFeatures::Utf8Validation_ARRAYSIZE;
#endif // (__cplusplus < 201703) &&
// (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
// ===================================================================
class CppFeatures::_Internal {
@ -122,6 +156,9 @@ class CppFeatures::_Internal {
static void set_has_legacy_closed_enum(HasBits* has_bits) {
(*has_bits)[0] |= 1u;
}
static void set_has_utf8_validation(HasBits* has_bits) {
(*has_bits)[0] |= 2u;
}
};
CppFeatures::CppFeatures(::google::protobuf::Arena* arena)
@ -141,6 +178,7 @@ inline void CppFeatures::SharedCtor(::_pb::Arena* arena) {
decltype(_impl_._has_bits_){},
/*decltype(_impl_._cached_size_)*/ {},
decltype(_impl_.legacy_closed_enum_){false},
decltype(_impl_.utf8_validation_){0},
};
}
CppFeatures::~CppFeatures() {
@ -161,7 +199,12 @@ PROTOBUF_NOINLINE void CppFeatures::Clear() {
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
_impl_.legacy_closed_enum_ = false;
cached_has_bits = _impl_._has_bits_[0];
if (cached_has_bits & 0x00000003u) {
::memset(&_impl_.legacy_closed_enum_, 0, static_cast<::size_t>(
reinterpret_cast<char*>(&_impl_.utf8_validation_) -
reinterpret_cast<char*>(&_impl_.legacy_closed_enum_)) + sizeof(_impl_.utf8_validation_));
}
_impl_._has_bits_.Clear();
_internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}
@ -174,20 +217,23 @@ const char* CppFeatures::_InternalParse(
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<0, 1, 0, 0, 2> CppFeatures::_table_ = {
const ::_pbi::TcParseTable<1, 2, 1, 0, 2> CppFeatures::_table_ = {
{
PROTOBUF_FIELD_OFFSET(CppFeatures, _impl_._has_bits_),
0, // no _extensions_
1, 0, // max_field_number, fast_idx_mask
2, 8, // max_field_number, fast_idx_mask
offsetof(decltype(_table_), field_lookup_table),
4294967294, // skipmap
4294967292, // skipmap
offsetof(decltype(_table_), field_entries),
1, // num_field_entries
0, // num_aux_entries
offsetof(decltype(_table_), field_names), // no aux_entries
2, // num_field_entries
1, // num_aux_entries
offsetof(decltype(_table_), aux_entries),
&_CppFeatures_default_instance_._instance,
::_pbi::TcParser::GenericFallback, // fallback
}, {{
// optional .pb.CppFeatures.Utf8Validation utf8_validation = 2 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = {
{::_pbi::TcParser::FastEr0S1,
{16, 1, 3, PROTOBUF_FIELD_OFFSET(CppFeatures, _impl_.utf8_validation_)}},
// optional bool legacy_closed_enum = 1 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = {
{::_pbi::TcParser::SingularVarintNoZag1<bool, offsetof(CppFeatures, _impl_.legacy_closed_enum_), 0>(),
{8, 0, 0, PROTOBUF_FIELD_OFFSET(CppFeatures, _impl_.legacy_closed_enum_)}},
@ -197,9 +243,12 @@ const ::_pbi::TcParseTable<0, 1, 0, 0, 2> CppFeatures::_table_ = {
// optional bool legacy_closed_enum = 1 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = {
{PROTOBUF_FIELD_OFFSET(CppFeatures, _impl_.legacy_closed_enum_), _Internal::kHasBitsOffset + 0, 0,
(0 | ::_fl::kFcOptional | ::_fl::kBool)},
}},
// no aux_entries
{{
// optional .pb.CppFeatures.Utf8Validation utf8_validation = 2 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = {
{PROTOBUF_FIELD_OFFSET(CppFeatures, _impl_.utf8_validation_), _Internal::kHasBitsOffset + 1, 0,
(0 | ::_fl::kFcOptional | ::_fl::kEnumRange)},
}}, {{
{0, 4},
}}, {{
}},
};
@ -218,6 +267,13 @@ const ::_pbi::TcParseTable<0, 1, 0, 0, 2> CppFeatures::_table_ = {
1, this->_internal_legacy_closed_enum(), target);
}
// optional .pb.CppFeatures.Utf8Validation utf8_validation = 2 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = {
if (cached_has_bits & 0x00000002u) {
target = stream->EnsureSpace(target);
target = ::_pbi::WireFormatLite::WriteEnumToArray(
2, this->_internal_utf8_validation(), target);
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
target =
::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
@ -235,12 +291,20 @@ const ::_pbi::TcParseTable<0, 1, 0, 0, 2> CppFeatures::_table_ = {
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
// optional bool legacy_closed_enum = 1 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = {
cached_has_bits = _impl_._has_bits_[0];
if (cached_has_bits & 0x00000001u) {
total_size += 2;
}
if (cached_has_bits & 0x00000003u) {
// optional bool legacy_closed_enum = 1 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = {
if (cached_has_bits & 0x00000001u) {
total_size += 2;
}
// optional .pb.CppFeatures.Utf8Validation utf8_validation = 2 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = {
if (cached_has_bits & 0x00000002u) {
total_size += 1 +
::_pbi::WireFormatLite::EnumSize(this->_internal_utf8_validation());
}
}
return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}
@ -259,8 +323,15 @@ void CppFeatures::MergeImpl(::google::protobuf::Message& to_msg, const ::google:
::uint32_t cached_has_bits = 0;
(void) cached_has_bits;
if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
_this->_internal_set_legacy_closed_enum(from._internal_legacy_closed_enum());
cached_has_bits = from._impl_._has_bits_[0];
if (cached_has_bits & 0x00000003u) {
if (cached_has_bits & 0x00000001u) {
_this->_impl_.legacy_closed_enum_ = from._impl_.legacy_closed_enum_;
}
if (cached_has_bits & 0x00000002u) {
_this->_impl_.utf8_validation_ = from._impl_.utf8_validation_;
}
_this->_impl_._has_bits_[0] |= cached_has_bits;
}
_this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
}
@ -280,7 +351,12 @@ void CppFeatures::InternalSwap(CppFeatures* other) {
using std::swap;
_internal_metadata_.InternalSwap(&other->_internal_metadata_);
swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
swap(_impl_.legacy_closed_enum_, other->_impl_.legacy_closed_enum_);
::google::protobuf::internal::memswap<
PROTOBUF_FIELD_OFFSET(CppFeatures, _impl_.utf8_validation_)
+ sizeof(CppFeatures::_impl_.utf8_validation_)
- PROTOBUF_FIELD_OFFSET(CppFeatures, _impl_.legacy_closed_enum_)>(
reinterpret_cast<char*>(&_impl_.legacy_closed_enum_),
reinterpret_cast<char*>(&other->_impl_.legacy_closed_enum_));
}
::google::protobuf::Metadata CppFeatures::GetMetadata() const {

109
src/google/protobuf/cpp_features.pb.h
Unescape View File

@ -31,6 +31,7 @@
#include "google/protobuf/message.h"
#include "google/protobuf/repeated_field.h" // IWYU pragma: export
#include "google/protobuf/extension_set.h" // IWYU pragma: export
#include "google/protobuf/generated_enum_reflection.h"
#include "google/protobuf/unknown_field_set.h"
#include "google/protobuf/descriptor.pb.h"
// @@protoc_insertion_point(includes)
@ -65,6 +66,36 @@ namespace protobuf {
} // namespace google
namespace pb {
enum CppFeatures_Utf8Validation : int {
CppFeatures_Utf8Validation_UTF8_VALIDATION_UNKNOWN = 0,
CppFeatures_Utf8Validation_VERIFY_PARSE = 1,
CppFeatures_Utf8Validation_VERIFY_DLOG = 2,
CppFeatures_Utf8Validation_NONE = 3,
};
PROTOBUF_EXPORT bool CppFeatures_Utf8Validation_IsValid(int value);
constexpr CppFeatures_Utf8Validation CppFeatures_Utf8Validation_Utf8Validation_MIN = static_cast<CppFeatures_Utf8Validation>(0);
constexpr CppFeatures_Utf8Validation CppFeatures_Utf8Validation_Utf8Validation_MAX = static_cast<CppFeatures_Utf8Validation>(3);
constexpr int CppFeatures_Utf8Validation_Utf8Validation_ARRAYSIZE = 3 + 1;
PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*
CppFeatures_Utf8Validation_descriptor();
template <typename T>
const std::string& CppFeatures_Utf8Validation_Name(T value) {
static_assert(std::is_same<T, CppFeatures_Utf8Validation>::value ||
std::is_integral<T>::value,
"Incorrect type passed to Utf8Validation_Name().");
return CppFeatures_Utf8Validation_Name(static_cast<CppFeatures_Utf8Validation>(value));
}
template <>
inline const std::string& CppFeatures_Utf8Validation_Name(CppFeatures_Utf8Validation value) {
return ::google::protobuf::internal::NameOfDenseEnum<CppFeatures_Utf8Validation_descriptor,
0, 3>(
static_cast<int>(value));
}
inline bool CppFeatures_Utf8Validation_Parse(absl::string_view name, CppFeatures_Utf8Validation* value) {
return ::google::protobuf::internal::ParseNamedEnum<CppFeatures_Utf8Validation>(
CppFeatures_Utf8Validation_descriptor(), name, value);
}
// ===================================================================
@ -196,10 +227,33 @@ class PROTOBUF_EXPORT CppFeatures final :
// nested types ----------------------------------------------------
using Utf8Validation = CppFeatures_Utf8Validation;
static constexpr Utf8Validation UTF8_VALIDATION_UNKNOWN = CppFeatures_Utf8Validation_UTF8_VALIDATION_UNKNOWN;
static constexpr Utf8Validation VERIFY_PARSE = CppFeatures_Utf8Validation_VERIFY_PARSE;
static constexpr Utf8Validation VERIFY_DLOG = CppFeatures_Utf8Validation_VERIFY_DLOG;
static constexpr Utf8Validation NONE = CppFeatures_Utf8Validation_NONE;
static inline bool Utf8Validation_IsValid(int value) {
return CppFeatures_Utf8Validation_IsValid(value);
}
static constexpr Utf8Validation Utf8Validation_MIN = CppFeatures_Utf8Validation_Utf8Validation_MIN;
static constexpr Utf8Validation Utf8Validation_MAX = CppFeatures_Utf8Validation_Utf8Validation_MAX;
static constexpr int Utf8Validation_ARRAYSIZE = CppFeatures_Utf8Validation_Utf8Validation_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor* Utf8Validation_descriptor() {
return CppFeatures_Utf8Validation_descriptor();
}
template <typename T>
static inline const std::string& Utf8Validation_Name(T value) {
return CppFeatures_Utf8Validation_Name(value);
}
static inline bool Utf8Validation_Parse(absl::string_view name, Utf8Validation* value) {
return CppFeatures_Utf8Validation_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kLegacyClosedEnumFieldNumber = 1,
kUtf8ValidationFieldNumber = 2,
};
// optional bool legacy_closed_enum = 1 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = {
bool has_legacy_closed_enum() const;
@ -211,6 +265,17 @@ class PROTOBUF_EXPORT CppFeatures final :
bool _internal_legacy_closed_enum() const;
void _internal_set_legacy_closed_enum(bool value);
public:
// optional .pb.CppFeatures.Utf8Validation utf8_validation = 2 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = {
bool has_utf8_validation() const;
void clear_utf8_validation() ;
::pb::CppFeatures_Utf8Validation utf8_validation() const;
void set_utf8_validation(::pb::CppFeatures_Utf8Validation value);
private:
::pb::CppFeatures_Utf8Validation _internal_utf8_validation() const;
void _internal_set_utf8_validation(::pb::CppFeatures_Utf8Validation value);
public:
// @@protoc_insertion_point(class_scope:pb.CppFeatures)
private:
@ -218,7 +283,7 @@ class PROTOBUF_EXPORT CppFeatures final :
friend class ::google::protobuf::internal::TcParser;
static const ::google::protobuf::internal::TcParseTable<
0, 1, 0,
1, 2, 1,
0, 2>
_table_;
template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
@ -228,6 +293,7 @@ class PROTOBUF_EXPORT CppFeatures final :
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable ::google::protobuf::internal::CachedSize _cached_size_;
bool legacy_closed_enum_;
int utf8_validation_;
PROTOBUF_TSAN_DECLARE_MEMBER;
};
union { Impl_ _impl_; };
@ -281,6 +347,34 @@ inline void CppFeatures::_internal_set_legacy_closed_enum(bool value) {
_impl_.legacy_closed_enum_ = value;
}
// optional .pb.CppFeatures.Utf8Validation utf8_validation = 2 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = {
inline bool CppFeatures::has_utf8_validation() const {
bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline void CppFeatures::clear_utf8_validation() {
_impl_.utf8_validation_ = 0;
_impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::pb::CppFeatures_Utf8Validation CppFeatures::utf8_validation() const {
// @@protoc_insertion_point(field_get:pb.CppFeatures.utf8_validation)
return _internal_utf8_validation();
}
inline void CppFeatures::set_utf8_validation(::pb::CppFeatures_Utf8Validation value) {
_internal_set_utf8_validation(value);
// @@protoc_insertion_point(field_set:pb.CppFeatures.utf8_validation)
}
inline ::pb::CppFeatures_Utf8Validation CppFeatures::_internal_utf8_validation() const {
PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
return static_cast<::pb::CppFeatures_Utf8Validation>(_impl_.utf8_validation_);
}
inline void CppFeatures::_internal_set_utf8_validation(::pb::CppFeatures_Utf8Validation value) {
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
assert(::pb::CppFeatures_Utf8Validation_IsValid(value));
_impl_._has_bits_[0] |= 0x00000002u;
_impl_.utf8_validation_ = value;
}
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif // __GNUC__
@ -289,6 +383,19 @@ inline void CppFeatures::_internal_set_legacy_closed_enum(bool value) {
} // namespace pb
namespace google {
namespace protobuf {
template <>
struct is_proto_enum<::pb::CppFeatures_Utf8Validation> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::pb::CppFeatures_Utf8Validation>() {
return ::pb::CppFeatures_Utf8Validation_descriptor();
}
} // namespace protobuf
} // namespace google
// @@protoc_insertion_point(global_scope)
#include "google/protobuf/port_undef.inc"

21
src/google/protobuf/cpp_features.proto
Unescape View File

@ -49,4 +49,25 @@ message CppFeatures {
targets = TARGET_TYPE_FILE,
edition_defaults = { edition: "2023", value: "false" }
];
// The UTF8 validation strategy to use. See go/editions-utf8-validation for
// more information on this feature.
enum Utf8Validation {
// Invalid default, which should never be used.
UTF8_VALIDATION_UNKNOWN = 0;
// Default proto3 behavior, which verifies UTF8 validity during parse.
VERIFY_PARSE = 1;
// Default proto2 behavior, which verifies UTF8 validity during both parse
// and serialize in debug builds. On failure an error is logged, but the
// operation continues.
VERIFY_DLOG = 2;
// No UTF8 validation is done ever.
NONE = 3;
}
optional Utf8Validation utf8_validation = 2 [
retention = RETENTION_RUNTIME,
targets = TARGET_TYPE_FIELD,
targets = TARGET_TYPE_FILE,
edition_defaults = { edition: "2023", value: "VERIFY_PARSE" }
];
}

Write Preview
Loading…
Cancel
Save