From f63f7584f76a76e71ae452c9e7ea062bcd8aa0ef Mon Sep 17 00:00:00 2001 From: Adam Cozzette Date: Thu, 3 Nov 2022 19:47:00 +0000 Subject: [PATCH] Add a staleness test for the well-known types This commit adds a staleness test in preparation for setting up auto-updating of the well-known type generated code. I also went ahead and updated them manually just to make sure we don't run into any surprises when this starts happening automatically. I had to arrange things so that the generated any.pb.cc (for example) lives at: //src/google/protobuf:wkt/google/protobuf/any.pb.cc This is a weird directory structure, but I think it's the only way to allow the checked-in and generated versions of the file to coexist while ensuring that Bazel always uses the generated version. --- src/google/protobuf/BUILD.bazel | 29 ++- src/google/protobuf/any.pb.cc | 30 +-- src/google/protobuf/any.pb.h | 8 +- src/google/protobuf/api.pb.cc | 144 +++++++------ src/google/protobuf/api.pb.h | 20 +- src/google/protobuf/duration.pb.cc | 36 ++-- src/google/protobuf/duration.pb.h | 46 ++--- src/google/protobuf/empty.pb.cc | 2 +- src/google/protobuf/empty.pb.h | 2 +- src/google/protobuf/field_mask.pb.cc | 25 +-- src/google/protobuf/field_mask.pb.h | 16 +- src/google/protobuf/source_context.pb.cc | 25 +-- src/google/protobuf/source_context.pb.h | 8 +- src/google/protobuf/struct.pb.cc | 100 ++++----- src/google/protobuf/struct.pb.h | 28 +-- src/google/protobuf/timestamp.pb.cc | 36 ++-- src/google/protobuf/timestamp.pb.h | 46 ++--- src/google/protobuf/type.pb.cc | 234 ++++++++++++---------- src/google/protobuf/type.pb.h | 106 +++++----- src/google/protobuf/wrappers.pb.cc | 245 ++++++++++++----------- src/google/protobuf/wrappers.pb.h | 132 ++++++------ 21 files changed, 701 insertions(+), 617 deletions(-) diff --git a/src/google/protobuf/BUILD.bazel b/src/google/protobuf/BUILD.bazel index 7ba289cda8..859b953543 100644 --- a/src/google/protobuf/BUILD.bazel +++ b/src/google/protobuf/BUILD.bazel @@ -5,6 +5,7 @@ load("@rules_cc//cc:defs.bzl", "cc_library", "cc_proto_library", "cc_test") load("@rules_pkg//:mappings.bzl", "pkg_files", "strip_prefix") load("@rules_proto//proto:defs.bzl", "proto_library") +load("@upb//cmake:build_defs.bzl", "staleness_test") load("//build_defs:cpp_opts.bzl", "COPTS", "LINK_OPTS") package( @@ -106,15 +107,22 @@ WELL_KNOWN_TYPES = [ "wrappers", ] +# When we generate code for the well-known types, we put the resulting files in +# wkt/google/protobuf and add ./wkt to the include paths below. This is a +# somewhat strange setup but is necessary to satisfy these two constraints: +# - We need to keep the checked-in sources for now, since Cocoapods relies on +# them. +# - The Bazel build should always use the generated sources so that developers +# don't have to worry about manually updating the checked-in sources. genrule( name = "gen_wkt_cc_sources", srcs = [wkt + ".proto" for wkt in WELL_KNOWN_TYPES], outs = - [wkt + ".pb.h" for wkt in WELL_KNOWN_TYPES] + - [wkt + ".pb.cc" for wkt in WELL_KNOWN_TYPES], + ["wkt/google/protobuf/" + wkt + ".pb.h" for wkt in WELL_KNOWN_TYPES] + + ["wkt/google/protobuf/" + wkt + ".pb.cc" for wkt in WELL_KNOWN_TYPES], cmd = """ $(execpath //src/google/protobuf/compiler:protoc_nowkt) \ - --cpp_out=$(RULEDIR)/../.. \ + --cpp_out=dllexport_decl=PROTOBUF_EXPORT:$(RULEDIR)/wkt \ --proto_path=$$(dirname $$(dirname $$(dirname $(location any.proto)))) \ $(SRCS) """, @@ -122,12 +130,21 @@ genrule( visibility = ["//visibility:private"], ) +staleness_test( + name = "well_known_types_staleness_test", + outs = + [wkt + ".pb.h" for wkt in WELL_KNOWN_TYPES] + + [wkt + ".pb.cc" for wkt in WELL_KNOWN_TYPES], + generated_pattern = "wkt/google/protobuf/%s", + tags = ["manual"], +) + cc_library( name = "wkt_cc_proto", - srcs = [wkt + ".pb.cc" for wkt in WELL_KNOWN_TYPES], - hdrs = [wkt + ".pb.h" for wkt in WELL_KNOWN_TYPES], + srcs = ["wkt/google/protobuf/" + wkt + ".pb.cc" for wkt in WELL_KNOWN_TYPES], + hdrs = ["wkt/google/protobuf/" + wkt + ".pb.h" for wkt in WELL_KNOWN_TYPES], copts = COPTS, - include_prefix = "google/protobuf", + includes = ["wkt"], linkopts = LINK_OPTS, visibility = ["//pkg:__pkg__"], deps = [":protobuf_nowkt"], diff --git a/src/google/protobuf/any.pb.cc b/src/google/protobuf/any.pb.cc index 9649411d68..73314186a9 100644 --- a/src/google/protobuf/any.pb.cc +++ b/src/google/protobuf/any.pb.cc @@ -45,7 +45,7 @@ static constexpr const ::_pb::EnumDescriptor** file_level_enum_descriptors_google_2fprotobuf_2fany_2eproto = nullptr; static constexpr const ::_pb::ServiceDescriptor** file_level_service_descriptors_google_2fprotobuf_2fany_2eproto = nullptr; -const uint32_t TableStruct_google_2fprotobuf_2fany_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( +const ::uint32_t TableStruct_google_2fprotobuf_2fany_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( protodesc_cold) = { ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::Any, _internal_metadata_), @@ -208,7 +208,7 @@ void Any::SetCachedSize(int size) const { void Any::Clear() { // @@protoc_insertion_point(message_clear_start:google.protobuf.Any) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -221,27 +221,29 @@ const char* Any::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - uint32_t tag; + ::uint32_t tag; ptr = ::_pbi::ReadTag(ptr, &tag); switch (tag >> 3) { // string type_url = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { auto str = _internal_mutable_type_url(); ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); CHK_(::_pbi::VerifyUTF8(str, "google.protobuf.Any.type_url")); - } else + } else { goto handle_unusual; + } continue; // bytes value = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { auto str = _internal_mutable_value(); ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); - } else + } else { goto handle_unusual; + } continue; default: goto handle_unusual; @@ -266,11 +268,11 @@ failure: #undef CHK_ } -uint8_t* Any::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +::uint8_t* Any::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.Any) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; // string type_url = 1; @@ -297,12 +299,12 @@ uint8_t* Any::_InternalSerialize( return target; } -size_t Any::ByteSizeLong() const { +::size_t Any::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:google.protobuf.Any) - size_t total_size = 0; + ::size_t total_size = 0; - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -336,7 +338,7 @@ void Any::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_N // @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.Any) GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_type_url().empty()) { diff --git a/src/google/protobuf/any.pb.h b/src/google/protobuf/any.pb.h index ef4109d0c3..032ac9998b 100644 --- a/src/google/protobuf/any.pb.h +++ b/src/google/protobuf/any.pb.h @@ -46,7 +46,7 @@ PROTOBUF_NAMESPACE_CLOSE // Internal implementation detail -- do not use these members. struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fany_2eproto { - static const uint32_t offsets[]; + static const ::uint32_t offsets[]; }; PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fany_2eproto; @@ -189,10 +189,10 @@ class PROTOBUF_EXPORT Any final : PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; - size_t ByteSizeLong() const final; + ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: diff --git a/src/google/protobuf/api.pb.cc b/src/google/protobuf/api.pb.cc index da04763dbe..7f23f9ac61 100644 --- a/src/google/protobuf/api.pb.cc +++ b/src/google/protobuf/api.pb.cc @@ -80,7 +80,7 @@ static constexpr const ::_pb::EnumDescriptor** file_level_enum_descriptors_google_2fprotobuf_2fapi_2eproto = nullptr; static constexpr const ::_pb::ServiceDescriptor** file_level_service_descriptors_google_2fprotobuf_2fapi_2eproto = nullptr; -const uint32_t TableStruct_google_2fprotobuf_2fapi_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( +const ::uint32_t TableStruct_google_2fprotobuf_2fapi_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( protodesc_cold) = { ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::Api, _internal_metadata_), @@ -311,7 +311,7 @@ void Api::SetCachedSize(int size) const { void Api::Clear() { // @@protoc_insertion_point(message_clear_start:google.protobuf.Api) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -332,22 +332,23 @@ const char* Api::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - uint32_t tag; + ::uint32_t tag; ptr = ::_pbi::ReadTag(ptr, &tag); switch (tag >> 3) { // string name = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { auto str = _internal_mutable_name(); ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); CHK_(::_pbi::VerifyUTF8(str, "google.protobuf.Api.name")); - } else + } else { goto handle_unusual; + } continue; // repeated .google.protobuf.Method methods = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { ptr -= 1; do { ptr += 1; @@ -355,12 +356,13 @@ const char* Api::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else + } else { goto handle_unusual; + } continue; // repeated .google.protobuf.Option options = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) { ptr -= 1; do { ptr += 1; @@ -368,30 +370,33 @@ const char* Api::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); - } else + } else { goto handle_unusual; + } continue; // string version = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) { auto str = _internal_mutable_version(); ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); CHK_(::_pbi::VerifyUTF8(str, "google.protobuf.Api.version")); - } else + } else { goto handle_unusual; + } continue; // .google.protobuf.SourceContext source_context = 5; case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) { ptr = ctx->ParseMessage(_internal_mutable_source_context(), ptr); CHK_(ptr); - } else + } else { goto handle_unusual; + } continue; // repeated .google.protobuf.Mixin mixins = 6; case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) { ptr -= 1; do { ptr += 1; @@ -399,17 +404,19 @@ const char* Api::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr)); - } else + } else { goto handle_unusual; + } continue; // .google.protobuf.Syntax syntax = 7; case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { - uint32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) { + ::uint32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); _internal_set_syntax(static_cast<::PROTOBUF_NAMESPACE_ID::Syntax>(val)); - } else + } else { goto handle_unusual; + } continue; default: goto handle_unusual; @@ -434,11 +441,11 @@ failure: #undef CHK_ } -uint8_t* Api::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +::uint8_t* Api::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.Api) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; // string name = 1; @@ -507,12 +514,12 @@ uint8_t* Api::_InternalSerialize( return target; } -size_t Api::ByteSizeLong() const { +::size_t Api::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:google.protobuf.Api) - size_t total_size = 0; + ::size_t total_size = 0; - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -580,7 +587,7 @@ void Api::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_N // @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.Api) GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_impl_.methods_.MergeFrom(from._impl_.methods_); @@ -697,7 +704,7 @@ Method::Method(const Method& from) _this->GetArenaForAllocation()); } ::memcpy(&_impl_.request_streaming_, &from._impl_.request_streaming_, - static_cast(reinterpret_cast(&_impl_.syntax_) - + static_cast<::size_t>(reinterpret_cast(&_impl_.syntax_) - reinterpret_cast(&_impl_.request_streaming_)) + sizeof(_impl_.syntax_)); // @@protoc_insertion_point(copy_constructor:google.protobuf.Method) } @@ -753,7 +760,7 @@ void Method::SetCachedSize(int size) const { void Method::Clear() { // @@protoc_insertion_point(message_clear_start:google.protobuf.Method) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -761,7 +768,7 @@ void Method::Clear() { _impl_.name_.ClearToEmpty(); _impl_.request_type_url_.ClearToEmpty(); _impl_.response_type_url_.ClearToEmpty(); - ::memset(&_impl_.request_streaming_, 0, static_cast( + ::memset(&_impl_.request_streaming_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.syntax_) - reinterpret_cast(&_impl_.request_streaming_)) + sizeof(_impl_.syntax_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); @@ -771,58 +778,63 @@ const char* Method::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - uint32_t tag; + ::uint32_t tag; ptr = ::_pbi::ReadTag(ptr, &tag); switch (tag >> 3) { // string name = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { auto str = _internal_mutable_name(); ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); CHK_(::_pbi::VerifyUTF8(str, "google.protobuf.Method.name")); - } else + } else { goto handle_unusual; + } continue; // string request_type_url = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { auto str = _internal_mutable_request_type_url(); ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); CHK_(::_pbi::VerifyUTF8(str, "google.protobuf.Method.request_type_url")); - } else + } else { goto handle_unusual; + } continue; // bool request_streaming = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) { _impl_.request_streaming_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else + } else { goto handle_unusual; + } continue; // string response_type_url = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) { auto str = _internal_mutable_response_type_url(); ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); CHK_(::_pbi::VerifyUTF8(str, "google.protobuf.Method.response_type_url")); - } else + } else { goto handle_unusual; + } continue; // bool response_streaming = 5; case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) { _impl_.response_streaming_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else + } else { goto handle_unusual; + } continue; // repeated .google.protobuf.Option options = 6; case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) { ptr -= 1; do { ptr += 1; @@ -830,17 +842,19 @@ const char* Method::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr)); - } else + } else { goto handle_unusual; + } continue; // .google.protobuf.Syntax syntax = 7; case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { - uint32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) { + ::uint32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); _internal_set_syntax(static_cast<::PROTOBUF_NAMESPACE_ID::Syntax>(val)); - } else + } else { goto handle_unusual; + } continue; default: goto handle_unusual; @@ -865,11 +879,11 @@ failure: #undef CHK_ } -uint8_t* Method::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +::uint8_t* Method::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.Method) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; // string name = 1; @@ -937,12 +951,12 @@ uint8_t* Method::_InternalSerialize( return target; } -size_t Method::ByteSizeLong() const { +::size_t Method::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:google.protobuf.Method) - size_t total_size = 0; + ::size_t total_size = 0; - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1006,7 +1020,7 @@ void Method::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBU // @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.Method) GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_impl_.options_.MergeFrom(from._impl_.options_); @@ -1154,7 +1168,7 @@ void Mixin::SetCachedSize(int size) const { void Mixin::Clear() { // @@protoc_insertion_point(message_clear_start:google.protobuf.Mixin) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1167,28 +1181,30 @@ const char* Mixin::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - uint32_t tag; + ::uint32_t tag; ptr = ::_pbi::ReadTag(ptr, &tag); switch (tag >> 3) { // string name = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { auto str = _internal_mutable_name(); ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); CHK_(::_pbi::VerifyUTF8(str, "google.protobuf.Mixin.name")); - } else + } else { goto handle_unusual; + } continue; // string root = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { auto str = _internal_mutable_root(); ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); CHK_(::_pbi::VerifyUTF8(str, "google.protobuf.Mixin.root")); - } else + } else { goto handle_unusual; + } continue; default: goto handle_unusual; @@ -1213,11 +1229,11 @@ failure: #undef CHK_ } -uint8_t* Mixin::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +::uint8_t* Mixin::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.Mixin) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; // string name = 1; @@ -1248,12 +1264,12 @@ uint8_t* Mixin::_InternalSerialize( return target; } -size_t Mixin::ByteSizeLong() const { +::size_t Mixin::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:google.protobuf.Mixin) - size_t total_size = 0; + ::size_t total_size = 0; - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1287,7 +1303,7 @@ void Mixin::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF // @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.Mixin) GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_name().empty()) { diff --git a/src/google/protobuf/api.pb.h b/src/google/protobuf/api.pb.h index ea210ec6f4..8e95525ba6 100644 --- a/src/google/protobuf/api.pb.h +++ b/src/google/protobuf/api.pb.h @@ -48,7 +48,7 @@ PROTOBUF_NAMESPACE_CLOSE // Internal implementation detail -- do not use these members. struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fapi_2eproto { - static const uint32_t offsets[]; + static const ::uint32_t offsets[]; }; PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fapi_2eproto; @@ -166,10 +166,10 @@ class PROTOBUF_EXPORT Api final : PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; - size_t ByteSizeLong() const final; + ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: @@ -425,10 +425,10 @@ class PROTOBUF_EXPORT Method final : PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; - size_t ByteSizeLong() const final; + ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: @@ -662,10 +662,10 @@ class PROTOBUF_EXPORT Mixin final : PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; - size_t ByteSizeLong() const final; + ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: diff --git a/src/google/protobuf/duration.pb.cc b/src/google/protobuf/duration.pb.cc index 7c60f7f59f..79bf16cc7a 100644 --- a/src/google/protobuf/duration.pb.cc +++ b/src/google/protobuf/duration.pb.cc @@ -21,7 +21,7 @@ namespace _pbi = ::PROTOBUF_NAMESPACE_ID::internal; PROTOBUF_NAMESPACE_OPEN PROTOBUF_CONSTEXPR Duration::Duration( ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_.seconds_)*/int64_t{0} + /*decltype(_impl_.seconds_)*/::int64_t{0} , /*decltype(_impl_.nanos_)*/0 , /*decltype(_impl_._cached_size_)*/{}} {} struct DurationDefaultTypeInternal { @@ -40,7 +40,7 @@ static constexpr const ::_pb::EnumDescriptor** file_level_enum_descriptors_google_2fprotobuf_2fduration_2eproto = nullptr; static constexpr const ::_pb::ServiceDescriptor** file_level_service_descriptors_google_2fprotobuf_2fduration_2eproto = nullptr; -const uint32_t TableStruct_google_2fprotobuf_2fduration_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( +const ::uint32_t TableStruct_google_2fprotobuf_2fduration_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( protodesc_cold) = { ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::Duration, _internal_metadata_), @@ -131,7 +131,7 @@ inline void Duration::SharedCtor( (void)arena; (void)is_message_owned; new (&_impl_) Impl_{ - decltype(_impl_.seconds_){int64_t{0}} + decltype(_impl_.seconds_){::int64_t{0}} , decltype(_impl_.nanos_){0} , /*decltype(_impl_._cached_size_)*/{} }; @@ -156,11 +156,11 @@ void Duration::SetCachedSize(int size) const { void Duration::Clear() { // @@protoc_insertion_point(message_clear_start:google.protobuf.Duration) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - ::memset(&_impl_.seconds_, 0, static_cast( + ::memset(&_impl_.seconds_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.nanos_) - reinterpret_cast(&_impl_.seconds_)) + sizeof(_impl_.nanos_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); @@ -170,24 +170,26 @@ const char* Duration::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - uint32_t tag; + ::uint32_t tag; ptr = ::_pbi::ReadTag(ptr, &tag); switch (tag >> 3) { // int64 seconds = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) { _impl_.seconds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else + } else { goto handle_unusual; + } continue; // int32 nanos = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) { _impl_.nanos_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else + } else { goto handle_unusual; + } continue; default: goto handle_unusual; @@ -212,11 +214,11 @@ failure: #undef CHK_ } -uint8_t* Duration::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +::uint8_t* Duration::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.Duration) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; // int64 seconds = 1; @@ -239,12 +241,12 @@ uint8_t* Duration::_InternalSerialize( return target; } -size_t Duration::ByteSizeLong() const { +::size_t Duration::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:google.protobuf.Duration) - size_t total_size = 0; + ::size_t total_size = 0; - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -274,7 +276,7 @@ void Duration::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTO // @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.Duration) GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_seconds() != 0) { diff --git a/src/google/protobuf/duration.pb.h b/src/google/protobuf/duration.pb.h index e347599a00..6efd4edad4 100644 --- a/src/google/protobuf/duration.pb.h +++ b/src/google/protobuf/duration.pb.h @@ -46,7 +46,7 @@ PROTOBUF_NAMESPACE_CLOSE // Internal implementation detail -- do not use these members. struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fduration_2eproto { - static const uint32_t offsets[]; + static const ::uint32_t offsets[]; }; PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fduration_2eproto; @@ -154,10 +154,10 @@ class PROTOBUF_EXPORT Duration final : PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; - size_t ByteSizeLong() const final; + ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: @@ -191,20 +191,20 @@ class PROTOBUF_EXPORT Duration final : }; // int64 seconds = 1; void clear_seconds(); - int64_t seconds() const; - void set_seconds(int64_t value); + ::int64_t seconds() const; + void set_seconds(::int64_t value); private: - int64_t _internal_seconds() const; - void _internal_set_seconds(int64_t value); + ::int64_t _internal_seconds() const; + void _internal_set_seconds(::int64_t value); public: // int32 nanos = 2; void clear_nanos(); - int32_t nanos() const; - void set_nanos(int32_t value); + ::int32_t nanos() const; + void set_nanos(::int32_t value); private: - int32_t _internal_nanos() const; - void _internal_set_nanos(int32_t value); + ::int32_t _internal_nanos() const; + void _internal_set_nanos(::int32_t value); public: // @@protoc_insertion_point(class_scope:google.protobuf.Duration) @@ -215,8 +215,8 @@ class PROTOBUF_EXPORT Duration final : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { - int64_t seconds_; - int32_t nanos_; + ::int64_t seconds_; + ::int32_t nanos_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; @@ -240,20 +240,20 @@ class PROTOBUF_EXPORT Duration final : // int64 seconds = 1; inline void Duration::clear_seconds() { - _impl_.seconds_ = int64_t{0}; + _impl_.seconds_ = ::int64_t{0}; } -inline int64_t Duration::_internal_seconds() const { +inline ::int64_t Duration::_internal_seconds() const { return _impl_.seconds_; } -inline int64_t Duration::seconds() const { +inline ::int64_t Duration::seconds() const { // @@protoc_insertion_point(field_get:google.protobuf.Duration.seconds) return _internal_seconds(); } -inline void Duration::_internal_set_seconds(int64_t value) { +inline void Duration::_internal_set_seconds(::int64_t value) { _impl_.seconds_ = value; } -inline void Duration::set_seconds(int64_t value) { +inline void Duration::set_seconds(::int64_t value) { _internal_set_seconds(value); // @@protoc_insertion_point(field_set:google.protobuf.Duration.seconds) } @@ -262,18 +262,18 @@ inline void Duration::set_seconds(int64_t value) { inline void Duration::clear_nanos() { _impl_.nanos_ = 0; } -inline int32_t Duration::_internal_nanos() const { +inline ::int32_t Duration::_internal_nanos() const { return _impl_.nanos_; } -inline int32_t Duration::nanos() const { +inline ::int32_t Duration::nanos() const { // @@protoc_insertion_point(field_get:google.protobuf.Duration.nanos) return _internal_nanos(); } -inline void Duration::_internal_set_nanos(int32_t value) { +inline void Duration::_internal_set_nanos(::int32_t value) { _impl_.nanos_ = value; } -inline void Duration::set_nanos(int32_t value) { +inline void Duration::set_nanos(::int32_t value) { _internal_set_nanos(value); // @@protoc_insertion_point(field_set:google.protobuf.Duration.nanos) } diff --git a/src/google/protobuf/empty.pb.cc b/src/google/protobuf/empty.pb.cc index c04ad78a68..9abd09f702 100644 --- a/src/google/protobuf/empty.pb.cc +++ b/src/google/protobuf/empty.pb.cc @@ -37,7 +37,7 @@ static constexpr const ::_pb::EnumDescriptor** file_level_enum_descriptors_google_2fprotobuf_2fempty_2eproto = nullptr; static constexpr const ::_pb::ServiceDescriptor** file_level_service_descriptors_google_2fprotobuf_2fempty_2eproto = nullptr; -const uint32_t TableStruct_google_2fprotobuf_2fempty_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( +const ::uint32_t TableStruct_google_2fprotobuf_2fempty_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( protodesc_cold) = { ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::Empty, _internal_metadata_), diff --git a/src/google/protobuf/empty.pb.h b/src/google/protobuf/empty.pb.h index 9f118e5db3..9c0db49fbc 100644 --- a/src/google/protobuf/empty.pb.h +++ b/src/google/protobuf/empty.pb.h @@ -47,7 +47,7 @@ PROTOBUF_NAMESPACE_CLOSE // Internal implementation detail -- do not use these members. struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fempty_2eproto { - static const uint32_t offsets[]; + static const ::uint32_t offsets[]; }; PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fempty_2eproto; diff --git a/src/google/protobuf/field_mask.pb.cc b/src/google/protobuf/field_mask.pb.cc index de87758950..be8476c3fa 100644 --- a/src/google/protobuf/field_mask.pb.cc +++ b/src/google/protobuf/field_mask.pb.cc @@ -39,7 +39,7 @@ static constexpr const ::_pb::EnumDescriptor** file_level_enum_descriptors_google_2fprotobuf_2ffield_5fmask_2eproto = nullptr; static constexpr const ::_pb::ServiceDescriptor** file_level_service_descriptors_google_2fprotobuf_2ffield_5fmask_2eproto = nullptr; -const uint32_t TableStruct_google_2fprotobuf_2ffield_5fmask_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( +const ::uint32_t TableStruct_google_2fprotobuf_2ffield_5fmask_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( protodesc_cold) = { ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldMask, _internal_metadata_), @@ -158,7 +158,7 @@ void FieldMask::SetCachedSize(int size) const { void FieldMask::Clear() { // @@protoc_insertion_point(message_clear_start:google.protobuf.FieldMask) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -170,12 +170,12 @@ const char* FieldMask::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - uint32_t tag; + ::uint32_t tag; ptr = ::_pbi::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated string paths = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { ptr -= 1; do { ptr += 1; @@ -185,8 +185,9 @@ const char* FieldMask::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx CHK_(::_pbi::VerifyUTF8(str, "google.protobuf.FieldMask.paths")); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else + } else { goto handle_unusual; + } continue; default: goto handle_unusual; @@ -211,11 +212,11 @@ failure: #undef CHK_ } -uint8_t* FieldMask::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +::uint8_t* FieldMask::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.FieldMask) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated string paths = 1; @@ -236,12 +237,12 @@ uint8_t* FieldMask::_InternalSerialize( return target; } -size_t FieldMask::ByteSizeLong() const { +::size_t FieldMask::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:google.protobuf.FieldMask) - size_t total_size = 0; + ::size_t total_size = 0; - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -269,7 +270,7 @@ void FieldMask::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROT // @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.FieldMask) GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_impl_.paths_.MergeFrom(from._impl_.paths_); diff --git a/src/google/protobuf/field_mask.pb.h b/src/google/protobuf/field_mask.pb.h index 94e3d77e15..5267c45f32 100644 --- a/src/google/protobuf/field_mask.pb.h +++ b/src/google/protobuf/field_mask.pb.h @@ -46,7 +46,7 @@ PROTOBUF_NAMESPACE_CLOSE // Internal implementation detail -- do not use these members. struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2ffield_5fmask_2eproto { - static const uint32_t offsets[]; + static const ::uint32_t offsets[]; }; PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2ffield_5fmask_2eproto; @@ -154,10 +154,10 @@ class PROTOBUF_EXPORT FieldMask final : PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; - size_t ByteSizeLong() const final; + ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: @@ -199,12 +199,12 @@ class PROTOBUF_EXPORT FieldMask final : void set_paths(int index, const std::string& value); void set_paths(int index, std::string&& value); void set_paths(int index, const char* value); - void set_paths(int index, const char* value, size_t size); + void set_paths(int index, const char* value, ::size_t size); std::string* add_paths(); void add_paths(const std::string& value); void add_paths(std::string&& value); void add_paths(const char* value); - void add_paths(const char* value, size_t size); + void add_paths(const char* value, ::size_t size); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& paths() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_paths(); private: @@ -280,7 +280,7 @@ inline void FieldMask::set_paths(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); _impl_.paths_.Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:google.protobuf.FieldMask.paths) } -inline void FieldMask::set_paths(int index, const char* value, size_t size) { +inline void FieldMask::set_paths(int index, const char* value, ::size_t size) { _impl_.paths_.Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:google.protobuf.FieldMask.paths) @@ -300,7 +300,7 @@ inline void FieldMask::add_paths(const char* value) { GOOGLE_DCHECK(value != nullptr); _impl_.paths_.Add()->assign(value); // @@protoc_insertion_point(field_add_char:google.protobuf.FieldMask.paths) } -inline void FieldMask::add_paths(const char* value, size_t size) { +inline void FieldMask::add_paths(const char* value, ::size_t size) { _impl_.paths_.Add()->assign(reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:google.protobuf.FieldMask.paths) } diff --git a/src/google/protobuf/source_context.pb.cc b/src/google/protobuf/source_context.pb.cc index ce0f339939..a4cec865e8 100644 --- a/src/google/protobuf/source_context.pb.cc +++ b/src/google/protobuf/source_context.pb.cc @@ -39,7 +39,7 @@ static constexpr const ::_pb::EnumDescriptor** file_level_enum_descriptors_google_2fprotobuf_2fsource_5fcontext_2eproto = nullptr; static constexpr const ::_pb::ServiceDescriptor** file_level_service_descriptors_google_2fprotobuf_2fsource_5fcontext_2eproto = nullptr; -const uint32_t TableStruct_google_2fprotobuf_2fsource_5fcontext_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( +const ::uint32_t TableStruct_google_2fprotobuf_2fsource_5fcontext_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( protodesc_cold) = { ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::SourceContext, _internal_metadata_), @@ -170,7 +170,7 @@ void SourceContext::SetCachedSize(int size) const { void SourceContext::Clear() { // @@protoc_insertion_point(message_clear_start:google.protobuf.SourceContext) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -182,18 +182,19 @@ const char* SourceContext::_InternalParse(const char* ptr, ::_pbi::ParseContext* #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - uint32_t tag; + ::uint32_t tag; ptr = ::_pbi::ReadTag(ptr, &tag); switch (tag >> 3) { // string file_name = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { auto str = _internal_mutable_file_name(); ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); CHK_(::_pbi::VerifyUTF8(str, "google.protobuf.SourceContext.file_name")); - } else + } else { goto handle_unusual; + } continue; default: goto handle_unusual; @@ -218,11 +219,11 @@ failure: #undef CHK_ } -uint8_t* SourceContext::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +::uint8_t* SourceContext::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.SourceContext) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; // string file_name = 1; @@ -243,12 +244,12 @@ uint8_t* SourceContext::_InternalSerialize( return target; } -size_t SourceContext::ByteSizeLong() const { +::size_t SourceContext::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:google.protobuf.SourceContext) - size_t total_size = 0; + ::size_t total_size = 0; - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -275,7 +276,7 @@ void SourceContext::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const :: // @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.SourceContext) GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_file_name().empty()) { diff --git a/src/google/protobuf/source_context.pb.h b/src/google/protobuf/source_context.pb.h index 6794cc54a2..3bf2774962 100644 --- a/src/google/protobuf/source_context.pb.h +++ b/src/google/protobuf/source_context.pb.h @@ -46,7 +46,7 @@ PROTOBUF_NAMESPACE_CLOSE // Internal implementation detail -- do not use these members. struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fsource_5fcontext_2eproto { - static const uint32_t offsets[]; + static const ::uint32_t offsets[]; }; PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fsource_5fcontext_2eproto; @@ -154,10 +154,10 @@ class PROTOBUF_EXPORT SourceContext final : PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; - size_t ByteSizeLong() const final; + ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: diff --git a/src/google/protobuf/struct.pb.cc b/src/google/protobuf/struct.pb.cc index eb92db0870..576f6c3971 100644 --- a/src/google/protobuf/struct.pb.cc +++ b/src/google/protobuf/struct.pb.cc @@ -79,7 +79,7 @@ static ::_pb::Metadata file_level_metadata_google_2fprotobuf_2fstruct_2eproto[4] static const ::_pb::EnumDescriptor* file_level_enum_descriptors_google_2fprotobuf_2fstruct_2eproto[1]; static constexpr const ::_pb::ServiceDescriptor** file_level_service_descriptors_google_2fprotobuf_2fstruct_2eproto = nullptr; -const uint32_t TableStruct_google_2fprotobuf_2fstruct_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( +const ::uint32_t TableStruct_google_2fprotobuf_2fstruct_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( protodesc_cold) = { PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::Struct_FieldsEntry_DoNotUse, _has_bits_), PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::Struct_FieldsEntry_DoNotUse, _internal_metadata_), @@ -285,7 +285,7 @@ void Struct::SetCachedSize(int size) const { void Struct::Clear() { // @@protoc_insertion_point(message_clear_start:google.protobuf.Struct) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -297,12 +297,12 @@ const char* Struct::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - uint32_t tag; + ::uint32_t tag; ptr = ::_pbi::ReadTag(ptr, &tag); switch (tag >> 3) { // map fields = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { ptr -= 1; do { ptr += 1; @@ -310,8 +310,9 @@ const char* Struct::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else + } else { goto handle_unusual; + } continue; default: goto handle_unusual; @@ -336,11 +337,11 @@ failure: #undef CHK_ } -uint8_t* Struct::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +::uint8_t* Struct::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.Struct) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; // map fields = 1; @@ -377,12 +378,12 @@ uint8_t* Struct::_InternalSerialize( return target; } -size_t Struct::ByteSizeLong() const { +::size_t Struct::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:google.protobuf.Struct) - size_t total_size = 0; + ::size_t total_size = 0; - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -411,7 +412,7 @@ void Struct::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBU // @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.Struct) GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_impl_.fields_.MergeFrom(from._impl_.fields_); @@ -445,7 +446,7 @@ void Struct::InternalSwap(Struct* other) { class Value::_Internal { public: - static constexpr int32_t kOneofCaseOffset = + static constexpr ::int32_t kOneofCaseOffset = PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::Value, _impl_._oneof_case_); static const ::PROTOBUF_NAMESPACE_ID::Struct& struct_value(const Value* msg); static const ::PROTOBUF_NAMESPACE_ID::ListValue& list_value(const Value* msg); @@ -612,7 +613,7 @@ void Value::clear_kind() { void Value::Clear() { // @@protoc_insertion_point(message_clear_start:google.protobuf.Value) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -624,59 +625,65 @@ const char* Value::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - uint32_t tag; + ::uint32_t tag; ptr = ::_pbi::ReadTag(ptr, &tag); switch (tag >> 3) { // .google.protobuf.NullValue null_value = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - uint32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) { + ::uint32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); _internal_set_null_value(static_cast<::PROTOBUF_NAMESPACE_ID::NullValue>(val)); - } else + } else { goto handle_unusual; + } continue; // double number_value = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 17)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 17)) { _internal_set_number_value(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); ptr += sizeof(double); - } else + } else { goto handle_unusual; + } continue; // string string_value = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) { auto str = _internal_mutable_string_value(); ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); CHK_(::_pbi::VerifyUTF8(str, "google.protobuf.Value.string_value")); - } else + } else { goto handle_unusual; + } continue; // bool bool_value = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) { _internal_set_bool_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); CHK_(ptr); - } else + } else { goto handle_unusual; + } continue; // .google.protobuf.Struct struct_value = 5; case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) { ptr = ctx->ParseMessage(_internal_mutable_struct_value(), ptr); CHK_(ptr); - } else + } else { goto handle_unusual; + } continue; // .google.protobuf.ListValue list_value = 6; case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) { ptr = ctx->ParseMessage(_internal_mutable_list_value(), ptr); CHK_(ptr); - } else + } else { goto handle_unusual; + } continue; default: goto handle_unusual; @@ -701,11 +708,11 @@ failure: #undef CHK_ } -uint8_t* Value::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +::uint8_t* Value::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.Value) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; // .google.protobuf.NullValue null_value = 1; @@ -759,12 +766,12 @@ uint8_t* Value::_InternalSerialize( return target; } -size_t Value::ByteSizeLong() const { +::size_t Value::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:google.protobuf.Value) - size_t total_size = 0; + ::size_t total_size = 0; - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -826,7 +833,7 @@ void Value::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF // @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.Value) GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; switch (from.kind_case()) { @@ -940,7 +947,7 @@ void ListValue::SetCachedSize(int size) const { void ListValue::Clear() { // @@protoc_insertion_point(message_clear_start:google.protobuf.ListValue) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -952,12 +959,12 @@ const char* ListValue::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - uint32_t tag; + ::uint32_t tag; ptr = ::_pbi::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated .google.protobuf.Value values = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { ptr -= 1; do { ptr += 1; @@ -965,8 +972,9 @@ const char* ListValue::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else + } else { goto handle_unusual; + } continue; default: goto handle_unusual; @@ -991,11 +999,11 @@ failure: #undef CHK_ } -uint8_t* ListValue::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +::uint8_t* ListValue::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.ListValue) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated .google.protobuf.Value values = 1; @@ -1014,12 +1022,12 @@ uint8_t* ListValue::_InternalSerialize( return target; } -size_t ListValue::ByteSizeLong() const { +::size_t ListValue::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:google.protobuf.ListValue) - size_t total_size = 0; + ::size_t total_size = 0; - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1046,7 +1054,7 @@ void ListValue::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROT // @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.ListValue) GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_impl_.values_.MergeFrom(from._impl_.values_); diff --git a/src/google/protobuf/struct.pb.h b/src/google/protobuf/struct.pb.h index 8eead0ab2c..973221c9ab 100644 --- a/src/google/protobuf/struct.pb.h +++ b/src/google/protobuf/struct.pb.h @@ -50,7 +50,7 @@ PROTOBUF_NAMESPACE_CLOSE // Internal implementation detail -- do not use these members. struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fstruct_2eproto { - static const uint32_t offsets[]; + static const ::uint32_t offsets[]; }; PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fstruct_2eproto; @@ -81,9 +81,9 @@ PROTOBUF_NAMESPACE_OPEN enum NullValue : int { NULL_VALUE = 0, NullValue_INT_MIN_SENTINEL_DO_NOT_USE_ = - std::numeric_limits::min(), + std::numeric_limits<::int32_t>::min(), NullValue_INT_MAX_SENTINEL_DO_NOT_USE_ = - std::numeric_limits::max(), + std::numeric_limits<::int32_t>::max(), }; PROTOBUF_EXPORT bool NullValue_IsValid(int value); @@ -115,7 +115,7 @@ inline bool NullValue_Parse(absl::string_view name, NullValue* value) { // ------------------------------------------------------------------- -class Struct_FieldsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry { @@ -229,10 +229,10 @@ class PROTOBUF_EXPORT Struct final : PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; - size_t ByteSizeLong() const final; + ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: @@ -401,10 +401,10 @@ class PROTOBUF_EXPORT Value final : PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; - size_t ByteSizeLong() const final; + ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: @@ -563,7 +563,7 @@ class PROTOBUF_EXPORT Value final : ::PROTOBUF_NAMESPACE_ID::ListValue* list_value_; } kind_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t _oneof_case_[1]; + ::uint32_t _oneof_case_[1]; }; union { Impl_ _impl_; }; @@ -659,10 +659,10 @@ class PROTOBUF_EXPORT ListValue final : PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; - size_t ByteSizeLong() const final; + ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: diff --git a/src/google/protobuf/timestamp.pb.cc b/src/google/protobuf/timestamp.pb.cc index a26f164d3c..a64dbc0438 100644 --- a/src/google/protobuf/timestamp.pb.cc +++ b/src/google/protobuf/timestamp.pb.cc @@ -21,7 +21,7 @@ namespace _pbi = ::PROTOBUF_NAMESPACE_ID::internal; PROTOBUF_NAMESPACE_OPEN PROTOBUF_CONSTEXPR Timestamp::Timestamp( ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_.seconds_)*/int64_t{0} + /*decltype(_impl_.seconds_)*/::int64_t{0} , /*decltype(_impl_.nanos_)*/0 , /*decltype(_impl_._cached_size_)*/{}} {} struct TimestampDefaultTypeInternal { @@ -40,7 +40,7 @@ static constexpr const ::_pb::EnumDescriptor** file_level_enum_descriptors_google_2fprotobuf_2ftimestamp_2eproto = nullptr; static constexpr const ::_pb::ServiceDescriptor** file_level_service_descriptors_google_2fprotobuf_2ftimestamp_2eproto = nullptr; -const uint32_t TableStruct_google_2fprotobuf_2ftimestamp_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( +const ::uint32_t TableStruct_google_2fprotobuf_2ftimestamp_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( protodesc_cold) = { ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::Timestamp, _internal_metadata_), @@ -131,7 +131,7 @@ inline void Timestamp::SharedCtor( (void)arena; (void)is_message_owned; new (&_impl_) Impl_{ - decltype(_impl_.seconds_){int64_t{0}} + decltype(_impl_.seconds_){::int64_t{0}} , decltype(_impl_.nanos_){0} , /*decltype(_impl_._cached_size_)*/{} }; @@ -156,11 +156,11 @@ void Timestamp::SetCachedSize(int size) const { void Timestamp::Clear() { // @@protoc_insertion_point(message_clear_start:google.protobuf.Timestamp) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - ::memset(&_impl_.seconds_, 0, static_cast( + ::memset(&_impl_.seconds_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.nanos_) - reinterpret_cast(&_impl_.seconds_)) + sizeof(_impl_.nanos_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); @@ -170,24 +170,26 @@ const char* Timestamp::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - uint32_t tag; + ::uint32_t tag; ptr = ::_pbi::ReadTag(ptr, &tag); switch (tag >> 3) { // int64 seconds = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) { _impl_.seconds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else + } else { goto handle_unusual; + } continue; // int32 nanos = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) { _impl_.nanos_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else + } else { goto handle_unusual; + } continue; default: goto handle_unusual; @@ -212,11 +214,11 @@ failure: #undef CHK_ } -uint8_t* Timestamp::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +::uint8_t* Timestamp::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.Timestamp) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; // int64 seconds = 1; @@ -239,12 +241,12 @@ uint8_t* Timestamp::_InternalSerialize( return target; } -size_t Timestamp::ByteSizeLong() const { +::size_t Timestamp::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:google.protobuf.Timestamp) - size_t total_size = 0; + ::size_t total_size = 0; - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -274,7 +276,7 @@ void Timestamp::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROT // @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.Timestamp) GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_seconds() != 0) { diff --git a/src/google/protobuf/timestamp.pb.h b/src/google/protobuf/timestamp.pb.h index 9b19abbeff..a2f5e03071 100644 --- a/src/google/protobuf/timestamp.pb.h +++ b/src/google/protobuf/timestamp.pb.h @@ -46,7 +46,7 @@ PROTOBUF_NAMESPACE_CLOSE // Internal implementation detail -- do not use these members. struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2ftimestamp_2eproto { - static const uint32_t offsets[]; + static const ::uint32_t offsets[]; }; PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2ftimestamp_2eproto; @@ -154,10 +154,10 @@ class PROTOBUF_EXPORT Timestamp final : PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; - size_t ByteSizeLong() const final; + ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: @@ -191,20 +191,20 @@ class PROTOBUF_EXPORT Timestamp final : }; // int64 seconds = 1; void clear_seconds(); - int64_t seconds() const; - void set_seconds(int64_t value); + ::int64_t seconds() const; + void set_seconds(::int64_t value); private: - int64_t _internal_seconds() const; - void _internal_set_seconds(int64_t value); + ::int64_t _internal_seconds() const; + void _internal_set_seconds(::int64_t value); public: // int32 nanos = 2; void clear_nanos(); - int32_t nanos() const; - void set_nanos(int32_t value); + ::int32_t nanos() const; + void set_nanos(::int32_t value); private: - int32_t _internal_nanos() const; - void _internal_set_nanos(int32_t value); + ::int32_t _internal_nanos() const; + void _internal_set_nanos(::int32_t value); public: // @@protoc_insertion_point(class_scope:google.protobuf.Timestamp) @@ -215,8 +215,8 @@ class PROTOBUF_EXPORT Timestamp final : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { - int64_t seconds_; - int32_t nanos_; + ::int64_t seconds_; + ::int32_t nanos_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; @@ -240,20 +240,20 @@ class PROTOBUF_EXPORT Timestamp final : // int64 seconds = 1; inline void Timestamp::clear_seconds() { - _impl_.seconds_ = int64_t{0}; + _impl_.seconds_ = ::int64_t{0}; } -inline int64_t Timestamp::_internal_seconds() const { +inline ::int64_t Timestamp::_internal_seconds() const { return _impl_.seconds_; } -inline int64_t Timestamp::seconds() const { +inline ::int64_t Timestamp::seconds() const { // @@protoc_insertion_point(field_get:google.protobuf.Timestamp.seconds) return _internal_seconds(); } -inline void Timestamp::_internal_set_seconds(int64_t value) { +inline void Timestamp::_internal_set_seconds(::int64_t value) { _impl_.seconds_ = value; } -inline void Timestamp::set_seconds(int64_t value) { +inline void Timestamp::set_seconds(::int64_t value) { _internal_set_seconds(value); // @@protoc_insertion_point(field_set:google.protobuf.Timestamp.seconds) } @@ -262,18 +262,18 @@ inline void Timestamp::set_seconds(int64_t value) { inline void Timestamp::clear_nanos() { _impl_.nanos_ = 0; } -inline int32_t Timestamp::_internal_nanos() const { +inline ::int32_t Timestamp::_internal_nanos() const { return _impl_.nanos_; } -inline int32_t Timestamp::nanos() const { +inline ::int32_t Timestamp::nanos() const { // @@protoc_insertion_point(field_get:google.protobuf.Timestamp.nanos) return _internal_nanos(); } -inline void Timestamp::_internal_set_nanos(int32_t value) { +inline void Timestamp::_internal_set_nanos(::int32_t value) { _impl_.nanos_ = value; } -inline void Timestamp::set_nanos(int32_t value) { +inline void Timestamp::set_nanos(::int32_t value) { _internal_set_nanos(value); // @@protoc_insertion_point(field_set:google.protobuf.Timestamp.nanos) } diff --git a/src/google/protobuf/type.pb.cc b/src/google/protobuf/type.pb.cc index 096d52ef42..d1faed97bb 100644 --- a/src/google/protobuf/type.pb.cc +++ b/src/google/protobuf/type.pb.cc @@ -115,7 +115,7 @@ static ::_pb::Metadata file_level_metadata_google_2fprotobuf_2ftype_2eproto[5]; static const ::_pb::EnumDescriptor* file_level_enum_descriptors_google_2fprotobuf_2ftype_2eproto[3]; static constexpr const ::_pb::ServiceDescriptor** file_level_service_descriptors_google_2fprotobuf_2ftype_2eproto = nullptr; -const uint32_t TableStruct_google_2fprotobuf_2ftype_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( +const ::uint32_t TableStruct_google_2fprotobuf_2ftype_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( protodesc_cold) = { ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::Type, _internal_metadata_), @@ -478,7 +478,7 @@ void Type::SetCachedSize(int size) const { void Type::Clear() { // @@protoc_insertion_point(message_clear_start:google.protobuf.Type) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -498,22 +498,23 @@ const char* Type::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - uint32_t tag; + ::uint32_t tag; ptr = ::_pbi::ReadTag(ptr, &tag); switch (tag >> 3) { // string name = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { auto str = _internal_mutable_name(); ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); CHK_(::_pbi::VerifyUTF8(str, "google.protobuf.Type.name")); - } else + } else { goto handle_unusual; + } continue; // repeated .google.protobuf.Field fields = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { ptr -= 1; do { ptr += 1; @@ -521,12 +522,13 @@ const char* Type::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else + } else { goto handle_unusual; + } continue; // repeated string oneofs = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) { ptr -= 1; do { ptr += 1; @@ -536,12 +538,13 @@ const char* Type::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { CHK_(::_pbi::VerifyUTF8(str, "google.protobuf.Type.oneofs")); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); - } else + } else { goto handle_unusual; + } continue; // repeated .google.protobuf.Option options = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) { ptr -= 1; do { ptr += 1; @@ -549,25 +552,28 @@ const char* Type::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); - } else + } else { goto handle_unusual; + } continue; // .google.protobuf.SourceContext source_context = 5; case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) { ptr = ctx->ParseMessage(_internal_mutable_source_context(), ptr); CHK_(ptr); - } else + } else { goto handle_unusual; + } continue; // .google.protobuf.Syntax syntax = 6; case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { - uint32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) { + ::uint32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); _internal_set_syntax(static_cast<::PROTOBUF_NAMESPACE_ID::Syntax>(val)); - } else + } else { goto handle_unusual; + } continue; default: goto handle_unusual; @@ -592,11 +598,11 @@ failure: #undef CHK_ } -uint8_t* Type::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +::uint8_t* Type::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.Type) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; // string name = 1; @@ -657,12 +663,12 @@ uint8_t* Type::_InternalSerialize( return target; } -size_t Type::ByteSizeLong() const { +::size_t Type::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:google.protobuf.Type) - size_t total_size = 0; + ::size_t total_size = 0; - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -724,7 +730,7 @@ void Type::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_ // @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.Type) GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_impl_.fields_.MergeFrom(from._impl_.fields_); @@ -842,7 +848,7 @@ Field::Field(const Field& from) _this->GetArenaForAllocation()); } ::memcpy(&_impl_.kind_, &from._impl_.kind_, - static_cast(reinterpret_cast(&_impl_.packed_) - + static_cast<::size_t>(reinterpret_cast(&_impl_.packed_) - reinterpret_cast(&_impl_.kind_)) + sizeof(_impl_.packed_)); // @@protoc_insertion_point(copy_constructor:google.protobuf.Field) } @@ -906,7 +912,7 @@ void Field::SetCachedSize(int size) const { void Field::Clear() { // @@protoc_insertion_point(message_clear_start:google.protobuf.Field) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -915,7 +921,7 @@ void Field::Clear() { _impl_.type_url_.ClearToEmpty(); _impl_.json_name_.ClearToEmpty(); _impl_.default_value_.ClearToEmpty(); - ::memset(&_impl_.kind_, 0, static_cast( + ::memset(&_impl_.kind_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.packed_) - reinterpret_cast(&_impl_.kind_)) + sizeof(_impl_.packed_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); @@ -925,74 +931,81 @@ const char* Field::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - uint32_t tag; + ::uint32_t tag; ptr = ::_pbi::ReadTag(ptr, &tag); switch (tag >> 3) { // .google.protobuf.Field.Kind kind = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - uint32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) { + ::uint32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); _internal_set_kind(static_cast<::PROTOBUF_NAMESPACE_ID::Field_Kind>(val)); - } else + } else { goto handle_unusual; + } continue; // .google.protobuf.Field.Cardinality cardinality = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - uint32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) { + ::uint32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); _internal_set_cardinality(static_cast<::PROTOBUF_NAMESPACE_ID::Field_Cardinality>(val)); - } else + } else { goto handle_unusual; + } continue; // int32 number = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) { _impl_.number_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else + } else { goto handle_unusual; + } continue; // string name = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) { auto str = _internal_mutable_name(); ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); CHK_(::_pbi::VerifyUTF8(str, "google.protobuf.Field.name")); - } else + } else { goto handle_unusual; + } continue; // string type_url = 6; case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) { auto str = _internal_mutable_type_url(); ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); CHK_(::_pbi::VerifyUTF8(str, "google.protobuf.Field.type_url")); - } else + } else { goto handle_unusual; + } continue; // int32 oneof_index = 7; case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) { _impl_.oneof_index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else + } else { goto handle_unusual; + } continue; // bool packed = 8; case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 64)) { _impl_.packed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else + } else { goto handle_unusual; + } continue; // repeated .google.protobuf.Option options = 9; case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 74)) { ptr -= 1; do { ptr += 1; @@ -1000,28 +1013,31 @@ const char* Field::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<74>(ptr)); - } else + } else { goto handle_unusual; + } continue; // string json_name = 10; case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 82)) { auto str = _internal_mutable_json_name(); ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); CHK_(::_pbi::VerifyUTF8(str, "google.protobuf.Field.json_name")); - } else + } else { goto handle_unusual; + } continue; // string default_value = 11; case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 90)) { auto str = _internal_mutable_default_value(); ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); CHK_(::_pbi::VerifyUTF8(str, "google.protobuf.Field.default_value")); - } else + } else { goto handle_unusual; + } continue; default: goto handle_unusual; @@ -1046,11 +1062,11 @@ failure: #undef CHK_ } -uint8_t* Field::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +::uint8_t* Field::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.Field) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; // .google.protobuf.Field.Kind kind = 1; @@ -1141,12 +1157,12 @@ uint8_t* Field::_InternalSerialize( return target; } -size_t Field::ByteSizeLong() const { +::size_t Field::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:google.protobuf.Field) - size_t total_size = 0; + ::size_t total_size = 0; - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1228,7 +1244,7 @@ void Field::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF // @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.Field) GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_impl_.options_.MergeFrom(from._impl_.options_); @@ -1400,7 +1416,7 @@ void Enum::SetCachedSize(int size) const { void Enum::Clear() { // @@protoc_insertion_point(message_clear_start:google.protobuf.Enum) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1419,22 +1435,23 @@ const char* Enum::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - uint32_t tag; + ::uint32_t tag; ptr = ::_pbi::ReadTag(ptr, &tag); switch (tag >> 3) { // string name = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { auto str = _internal_mutable_name(); ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); CHK_(::_pbi::VerifyUTF8(str, "google.protobuf.Enum.name")); - } else + } else { goto handle_unusual; + } continue; // repeated .google.protobuf.EnumValue enumvalue = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { ptr -= 1; do { ptr += 1; @@ -1442,12 +1459,13 @@ const char* Enum::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else + } else { goto handle_unusual; + } continue; // repeated .google.protobuf.Option options = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) { ptr -= 1; do { ptr += 1; @@ -1455,25 +1473,28 @@ const char* Enum::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); - } else + } else { goto handle_unusual; + } continue; // .google.protobuf.SourceContext source_context = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_source_context(), ptr); CHK_(ptr); - } else + } else { goto handle_unusual; + } continue; // .google.protobuf.Syntax syntax = 5; case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { - uint32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) { + ::uint32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); _internal_set_syntax(static_cast<::PROTOBUF_NAMESPACE_ID::Syntax>(val)); - } else + } else { goto handle_unusual; + } continue; default: goto handle_unusual; @@ -1498,11 +1519,11 @@ failure: #undef CHK_ } -uint8_t* Enum::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +::uint8_t* Enum::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.Enum) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; // string name = 1; @@ -1553,12 +1574,12 @@ uint8_t* Enum::_InternalSerialize( return target; } -size_t Enum::ByteSizeLong() const { +::size_t Enum::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:google.protobuf.Enum) - size_t total_size = 0; + ::size_t total_size = 0; - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1612,7 +1633,7 @@ void Enum::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_ // @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.Enum) GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_impl_.enumvalue_.MergeFrom(from._impl_.enumvalue_); @@ -1737,7 +1758,7 @@ void EnumValue::SetCachedSize(int size) const { void EnumValue::Clear() { // @@protoc_insertion_point(message_clear_start:google.protobuf.EnumValue) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1751,30 +1772,32 @@ const char* EnumValue::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - uint32_t tag; + ::uint32_t tag; ptr = ::_pbi::ReadTag(ptr, &tag); switch (tag >> 3) { // string name = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { auto str = _internal_mutable_name(); ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); CHK_(::_pbi::VerifyUTF8(str, "google.protobuf.EnumValue.name")); - } else + } else { goto handle_unusual; + } continue; // int32 number = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) { _impl_.number_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else + } else { goto handle_unusual; + } continue; // repeated .google.protobuf.Option options = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) { ptr -= 1; do { ptr += 1; @@ -1782,8 +1805,9 @@ const char* EnumValue::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); - } else + } else { goto handle_unusual; + } continue; default: goto handle_unusual; @@ -1808,11 +1832,11 @@ failure: #undef CHK_ } -uint8_t* EnumValue::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +::uint8_t* EnumValue::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.EnumValue) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; // string name = 1; @@ -1847,12 +1871,12 @@ uint8_t* EnumValue::_InternalSerialize( return target; } -size_t EnumValue::ByteSizeLong() const { +::size_t EnumValue::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:google.protobuf.EnumValue) - size_t total_size = 0; + ::size_t total_size = 0; - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1891,7 +1915,7 @@ void EnumValue::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROT // @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.EnumValue) GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_impl_.options_.MergeFrom(from._impl_.options_); @@ -2016,7 +2040,7 @@ void Option::SetCachedSize(int size) const { void Option::Clear() { // @@protoc_insertion_point(message_clear_start:google.protobuf.Option) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2032,26 +2056,28 @@ const char* Option::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - uint32_t tag; + ::uint32_t tag; ptr = ::_pbi::ReadTag(ptr, &tag); switch (tag >> 3) { // string name = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { auto str = _internal_mutable_name(); ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); CHK_(::_pbi::VerifyUTF8(str, "google.protobuf.Option.name")); - } else + } else { goto handle_unusual; + } continue; // .google.protobuf.Any value = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_value(), ptr); CHK_(ptr); - } else + } else { goto handle_unusual; + } continue; default: goto handle_unusual; @@ -2076,11 +2102,11 @@ failure: #undef CHK_ } -uint8_t* Option::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +::uint8_t* Option::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.Option) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; // string name = 1; @@ -2108,12 +2134,12 @@ uint8_t* Option::_InternalSerialize( return target; } -size_t Option::ByteSizeLong() const { +::size_t Option::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:google.protobuf.Option) - size_t total_size = 0; + ::size_t total_size = 0; - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2147,7 +2173,7 @@ void Option::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBU // @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.Option) GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_name().empty()) { diff --git a/src/google/protobuf/type.pb.h b/src/google/protobuf/type.pb.h index cd31a4bf94..0dcf3eb612 100644 --- a/src/google/protobuf/type.pb.h +++ b/src/google/protobuf/type.pb.h @@ -49,7 +49,7 @@ PROTOBUF_NAMESPACE_CLOSE // Internal implementation detail -- do not use these members. struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2ftype_2eproto { - static const uint32_t offsets[]; + static const ::uint32_t offsets[]; }; PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2ftype_2eproto; @@ -103,9 +103,9 @@ enum Field_Kind : int { Field_Kind_TYPE_SINT32 = 17, Field_Kind_TYPE_SINT64 = 18, Field_Kind_Field_Kind_INT_MIN_SENTINEL_DO_NOT_USE_ = - std::numeric_limits::min(), + std::numeric_limits<::int32_t>::min(), Field_Kind_Field_Kind_INT_MAX_SENTINEL_DO_NOT_USE_ = - std::numeric_limits::max(), + std::numeric_limits<::int32_t>::max(), }; PROTOBUF_EXPORT bool Field_Kind_IsValid(int value); @@ -137,9 +137,9 @@ enum Field_Cardinality : int { Field_Cardinality_CARDINALITY_REQUIRED = 2, Field_Cardinality_CARDINALITY_REPEATED = 3, Field_Cardinality_Field_Cardinality_INT_MIN_SENTINEL_DO_NOT_USE_ = - std::numeric_limits::min(), + std::numeric_limits<::int32_t>::min(), Field_Cardinality_Field_Cardinality_INT_MAX_SENTINEL_DO_NOT_USE_ = - std::numeric_limits::max(), + std::numeric_limits<::int32_t>::max(), }; PROTOBUF_EXPORT bool Field_Cardinality_IsValid(int value); @@ -169,9 +169,9 @@ enum Syntax : int { SYNTAX_PROTO2 = 0, SYNTAX_PROTO3 = 1, Syntax_INT_MIN_SENTINEL_DO_NOT_USE_ = - std::numeric_limits::min(), + std::numeric_limits<::int32_t>::min(), Syntax_INT_MAX_SENTINEL_DO_NOT_USE_ = - std::numeric_limits::max(), + std::numeric_limits<::int32_t>::max(), }; PROTOBUF_EXPORT bool Syntax_IsValid(int value); @@ -292,10 +292,10 @@ class PROTOBUF_EXPORT Type final : PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; - size_t ByteSizeLong() const final; + ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: @@ -360,12 +360,12 @@ class PROTOBUF_EXPORT Type final : void set_oneofs(int index, const std::string& value); void set_oneofs(int index, std::string&& value); void set_oneofs(int index, const char* value); - void set_oneofs(int index, const char* value, size_t size); + void set_oneofs(int index, const char* value, ::size_t size); std::string* add_oneofs(); void add_oneofs(const std::string& value); void add_oneofs(std::string&& value); void add_oneofs(const char* value); - void add_oneofs(const char* value, size_t size); + void add_oneofs(const char* value, ::size_t size); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& oneofs() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_oneofs(); private: @@ -541,10 +541,10 @@ class PROTOBUF_EXPORT Field final : PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; - size_t ByteSizeLong() const final; + ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: @@ -737,20 +737,20 @@ class PROTOBUF_EXPORT Field final : // int32 number = 3; void clear_number(); - int32_t number() const; - void set_number(int32_t value); + ::int32_t number() const; + void set_number(::int32_t value); private: - int32_t _internal_number() const; - void _internal_set_number(int32_t value); + ::int32_t _internal_number() const; + void _internal_set_number(::int32_t value); public: // int32 oneof_index = 7; void clear_oneof_index(); - int32_t oneof_index() const; - void set_oneof_index(int32_t value); + ::int32_t oneof_index() const; + void set_oneof_index(::int32_t value); private: - int32_t _internal_oneof_index() const; - void _internal_set_oneof_index(int32_t value); + ::int32_t _internal_oneof_index() const; + void _internal_set_oneof_index(::int32_t value); public: // bool packed = 8; @@ -777,8 +777,8 @@ class PROTOBUF_EXPORT Field final : ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr default_value_; int kind_; int cardinality_; - int32_t number_; - int32_t oneof_index_; + ::int32_t number_; + ::int32_t oneof_index_; bool packed_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; @@ -875,10 +875,10 @@ class PROTOBUF_EXPORT Enum final : PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; - size_t ByteSizeLong() const final; + ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: @@ -1098,10 +1098,10 @@ class PROTOBUF_EXPORT EnumValue final : PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; - size_t ByteSizeLong() const final; + ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: @@ -1168,11 +1168,11 @@ class PROTOBUF_EXPORT EnumValue final : // int32 number = 2; void clear_number(); - int32_t number() const; - void set_number(int32_t value); + ::int32_t number() const; + void set_number(::int32_t value); private: - int32_t _internal_number() const; - void _internal_set_number(int32_t value); + ::int32_t _internal_number() const; + void _internal_set_number(::int32_t value); public: // @@protoc_insertion_point(class_scope:google.protobuf.EnumValue) @@ -1185,7 +1185,7 @@ class PROTOBUF_EXPORT EnumValue final : struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option > options_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - int32_t number_; + ::int32_t number_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; @@ -1281,10 +1281,10 @@ class PROTOBUF_EXPORT Option final : PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; - size_t ByteSizeLong() const final; + ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: @@ -1502,7 +1502,7 @@ inline void Type::set_oneofs(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); _impl_.oneofs_.Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:google.protobuf.Type.oneofs) } -inline void Type::set_oneofs(int index, const char* value, size_t size) { +inline void Type::set_oneofs(int index, const char* value, ::size_t size) { _impl_.oneofs_.Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:google.protobuf.Type.oneofs) @@ -1522,7 +1522,7 @@ inline void Type::add_oneofs(const char* value) { GOOGLE_DCHECK(value != nullptr); _impl_.oneofs_.Add()->assign(value); // @@protoc_insertion_point(field_add_char:google.protobuf.Type.oneofs) } -inline void Type::add_oneofs(const char* value, size_t size) { +inline void Type::add_oneofs(const char* value, ::size_t size) { _impl_.oneofs_.Add()->assign(reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:google.protobuf.Type.oneofs) } @@ -1725,18 +1725,18 @@ inline void Field::set_cardinality(::PROTOBUF_NAMESPACE_ID::Field_Cardinality va inline void Field::clear_number() { _impl_.number_ = 0; } -inline int32_t Field::_internal_number() const { +inline ::int32_t Field::_internal_number() const { return _impl_.number_; } -inline int32_t Field::number() const { +inline ::int32_t Field::number() const { // @@protoc_insertion_point(field_get:google.protobuf.Field.number) return _internal_number(); } -inline void Field::_internal_set_number(int32_t value) { +inline void Field::_internal_set_number(::int32_t value) { _impl_.number_ = value; } -inline void Field::set_number(int32_t value) { +inline void Field::set_number(::int32_t value) { _internal_set_number(value); // @@protoc_insertion_point(field_set:google.protobuf.Field.number) } @@ -1835,18 +1835,18 @@ inline void Field::set_allocated_type_url(std::string* type_url) { inline void Field::clear_oneof_index() { _impl_.oneof_index_ = 0; } -inline int32_t Field::_internal_oneof_index() const { +inline ::int32_t Field::_internal_oneof_index() const { return _impl_.oneof_index_; } -inline int32_t Field::oneof_index() const { +inline ::int32_t Field::oneof_index() const { // @@protoc_insertion_point(field_get:google.protobuf.Field.oneof_index) return _internal_oneof_index(); } -inline void Field::_internal_set_oneof_index(int32_t value) { +inline void Field::_internal_set_oneof_index(::int32_t value) { _impl_.oneof_index_ = value; } -inline void Field::set_oneof_index(int32_t value) { +inline void Field::set_oneof_index(::int32_t value) { _internal_set_oneof_index(value); // @@protoc_insertion_point(field_set:google.protobuf.Field.oneof_index) } @@ -2283,18 +2283,18 @@ inline void EnumValue::set_allocated_name(std::string* name) { inline void EnumValue::clear_number() { _impl_.number_ = 0; } -inline int32_t EnumValue::_internal_number() const { +inline ::int32_t EnumValue::_internal_number() const { return _impl_.number_; } -inline int32_t EnumValue::number() const { +inline ::int32_t EnumValue::number() const { // @@protoc_insertion_point(field_get:google.protobuf.EnumValue.number) return _internal_number(); } -inline void EnumValue::_internal_set_number(int32_t value) { +inline void EnumValue::_internal_set_number(::int32_t value) { _impl_.number_ = value; } -inline void EnumValue::set_number(int32_t value) { +inline void EnumValue::set_number(::int32_t value) { _internal_set_number(value); // @@protoc_insertion_point(field_set:google.protobuf.EnumValue.number) } diff --git a/src/google/protobuf/wrappers.pb.cc b/src/google/protobuf/wrappers.pb.cc index 9bc739752e..a09a6a27c2 100644 --- a/src/google/protobuf/wrappers.pb.cc +++ b/src/google/protobuf/wrappers.pb.cc @@ -49,7 +49,7 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FloatValueDefaultTypeInternal _FloatValue_default_instance_; PROTOBUF_CONSTEXPR Int64Value::Int64Value( ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_.value_)*/int64_t{0} + /*decltype(_impl_.value_)*/::int64_t{0} , /*decltype(_impl_._cached_size_)*/{}} {} struct Int64ValueDefaultTypeInternal { PROTOBUF_CONSTEXPR Int64ValueDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} @@ -63,7 +63,7 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Int64ValueDefaultTypeInternal _Int64Value_default_instance_; PROTOBUF_CONSTEXPR UInt64Value::UInt64Value( ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_.value_)*/uint64_t{0u} + /*decltype(_impl_.value_)*/::uint64_t{0u} , /*decltype(_impl_._cached_size_)*/{}} {} struct UInt64ValueDefaultTypeInternal { PROTOBUF_CONSTEXPR UInt64ValueDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} @@ -151,7 +151,7 @@ static constexpr const ::_pb::EnumDescriptor** file_level_enum_descriptors_google_2fprotobuf_2fwrappers_2eproto = nullptr; static constexpr const ::_pb::ServiceDescriptor** file_level_service_descriptors_google_2fprotobuf_2fwrappers_2eproto = nullptr; -const uint32_t TableStruct_google_2fprotobuf_2fwrappers_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( +const ::uint32_t TableStruct_google_2fprotobuf_2fwrappers_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( protodesc_cold) = { ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DoubleValue, _internal_metadata_), @@ -359,7 +359,7 @@ void DoubleValue::SetCachedSize(int size) const { void DoubleValue::Clear() { // @@protoc_insertion_point(message_clear_start:google.protobuf.DoubleValue) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -371,16 +371,17 @@ const char* DoubleValue::_InternalParse(const char* ptr, ::_pbi::ParseContext* c #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - uint32_t tag; + ::uint32_t tag; ptr = ::_pbi::ReadTag(ptr, &tag); switch (tag >> 3) { // double value = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 9)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 9)) { _impl_.value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(double); - } else + } else { goto handle_unusual; + } continue; default: goto handle_unusual; @@ -405,17 +406,17 @@ failure: #undef CHK_ } -uint8_t* DoubleValue::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +::uint8_t* DoubleValue::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.DoubleValue) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; // double value = 1; - static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes ::uint64_t and double are the same size."); double tmp_value = this->_internal_value(); - uint64_t raw_value; + ::uint64_t raw_value; memcpy(&raw_value, &tmp_value, sizeof(tmp_value)); if (raw_value != 0) { target = stream->EnsureSpace(target); @@ -430,19 +431,19 @@ uint8_t* DoubleValue::_InternalSerialize( return target; } -size_t DoubleValue::ByteSizeLong() const { +::size_t DoubleValue::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:google.protobuf.DoubleValue) - size_t total_size = 0; + ::size_t total_size = 0; - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // double value = 1; - static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes ::uint64_t and double are the same size."); double tmp_value = this->_internal_value(); - uint64_t raw_value; + ::uint64_t raw_value; memcpy(&raw_value, &tmp_value, sizeof(tmp_value)); if (raw_value != 0) { total_size += 1 + 8; @@ -464,12 +465,12 @@ void DoubleValue::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PR // @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.DoubleValue) GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; - static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes ::uint64_t and double are the same size."); double tmp_value = from._internal_value(); - uint64_t raw_value; + ::uint64_t raw_value; memcpy(&raw_value, &tmp_value, sizeof(tmp_value)); if (raw_value != 0) { _this->_internal_set_value(from._internal_value()); @@ -548,7 +549,7 @@ void FloatValue::SetCachedSize(int size) const { void FloatValue::Clear() { // @@protoc_insertion_point(message_clear_start:google.protobuf.FloatValue) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -560,16 +561,17 @@ const char* FloatValue::_InternalParse(const char* ptr, ::_pbi::ParseContext* ct #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - uint32_t tag; + ::uint32_t tag; ptr = ::_pbi::ReadTag(ptr, &tag); switch (tag >> 3) { // float value = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 13)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 13)) { _impl_.value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); - } else + } else { goto handle_unusual; + } continue; default: goto handle_unusual; @@ -594,17 +596,17 @@ failure: #undef CHK_ } -uint8_t* FloatValue::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +::uint8_t* FloatValue::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.FloatValue) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; // float value = 1; - static_assert(sizeof(uint32_t) == sizeof(float), "Code assumes uint32_t and float are the same size."); + static_assert(sizeof(::uint32_t) == sizeof(float), "Code assumes ::uint32_t and float are the same size."); float tmp_value = this->_internal_value(); - uint32_t raw_value; + ::uint32_t raw_value; memcpy(&raw_value, &tmp_value, sizeof(tmp_value)); if (raw_value != 0) { target = stream->EnsureSpace(target); @@ -619,19 +621,19 @@ uint8_t* FloatValue::_InternalSerialize( return target; } -size_t FloatValue::ByteSizeLong() const { +::size_t FloatValue::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:google.protobuf.FloatValue) - size_t total_size = 0; + ::size_t total_size = 0; - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // float value = 1; - static_assert(sizeof(uint32_t) == sizeof(float), "Code assumes uint32_t and float are the same size."); + static_assert(sizeof(::uint32_t) == sizeof(float), "Code assumes ::uint32_t and float are the same size."); float tmp_value = this->_internal_value(); - uint32_t raw_value; + ::uint32_t raw_value; memcpy(&raw_value, &tmp_value, sizeof(tmp_value)); if (raw_value != 0) { total_size += 1 + 4; @@ -653,12 +655,12 @@ void FloatValue::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PRO // @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.FloatValue) GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; - static_assert(sizeof(uint32_t) == sizeof(float), "Code assumes uint32_t and float are the same size."); + static_assert(sizeof(::uint32_t) == sizeof(float), "Code assumes ::uint32_t and float are the same size."); float tmp_value = from._internal_value(); - uint32_t raw_value; + ::uint32_t raw_value; memcpy(&raw_value, &tmp_value, sizeof(tmp_value)); if (raw_value != 0) { _this->_internal_set_value(from._internal_value()); @@ -713,7 +715,7 @@ inline void Int64Value::SharedCtor( (void)arena; (void)is_message_owned; new (&_impl_) Impl_{ - decltype(_impl_.value_){int64_t{0}} + decltype(_impl_.value_){::int64_t{0}} , /*decltype(_impl_._cached_size_)*/{} }; } @@ -737,11 +739,11 @@ void Int64Value::SetCachedSize(int size) const { void Int64Value::Clear() { // @@protoc_insertion_point(message_clear_start:google.protobuf.Int64Value) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - _impl_.value_ = int64_t{0}; + _impl_.value_ = ::int64_t{0}; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -749,16 +751,17 @@ const char* Int64Value::_InternalParse(const char* ptr, ::_pbi::ParseContext* ct #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - uint32_t tag; + ::uint32_t tag; ptr = ::_pbi::ReadTag(ptr, &tag); switch (tag >> 3) { // int64 value = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) { _impl_.value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else + } else { goto handle_unusual; + } continue; default: goto handle_unusual; @@ -783,11 +786,11 @@ failure: #undef CHK_ } -uint8_t* Int64Value::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +::uint8_t* Int64Value::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.Int64Value) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; // int64 value = 1; @@ -804,12 +807,12 @@ uint8_t* Int64Value::_InternalSerialize( return target; } -size_t Int64Value::ByteSizeLong() const { +::size_t Int64Value::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:google.protobuf.Int64Value) - size_t total_size = 0; + ::size_t total_size = 0; - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -834,7 +837,7 @@ void Int64Value::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PRO // @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.Int64Value) GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_value() != 0) { @@ -890,7 +893,7 @@ inline void UInt64Value::SharedCtor( (void)arena; (void)is_message_owned; new (&_impl_) Impl_{ - decltype(_impl_.value_){uint64_t{0u}} + decltype(_impl_.value_){::uint64_t{0u}} , /*decltype(_impl_._cached_size_)*/{} }; } @@ -914,11 +917,11 @@ void UInt64Value::SetCachedSize(int size) const { void UInt64Value::Clear() { // @@protoc_insertion_point(message_clear_start:google.protobuf.UInt64Value) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - _impl_.value_ = uint64_t{0u}; + _impl_.value_ = ::uint64_t{0u}; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -926,16 +929,17 @@ const char* UInt64Value::_InternalParse(const char* ptr, ::_pbi::ParseContext* c #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - uint32_t tag; + ::uint32_t tag; ptr = ::_pbi::ReadTag(ptr, &tag); switch (tag >> 3) { // uint64 value = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) { _impl_.value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else + } else { goto handle_unusual; + } continue; default: goto handle_unusual; @@ -960,11 +964,11 @@ failure: #undef CHK_ } -uint8_t* UInt64Value::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +::uint8_t* UInt64Value::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.UInt64Value) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; // uint64 value = 1; @@ -981,12 +985,12 @@ uint8_t* UInt64Value::_InternalSerialize( return target; } -size_t UInt64Value::ByteSizeLong() const { +::size_t UInt64Value::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:google.protobuf.UInt64Value) - size_t total_size = 0; + ::size_t total_size = 0; - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1011,7 +1015,7 @@ void UInt64Value::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PR // @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.UInt64Value) GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_value() != 0) { @@ -1091,7 +1095,7 @@ void Int32Value::SetCachedSize(int size) const { void Int32Value::Clear() { // @@protoc_insertion_point(message_clear_start:google.protobuf.Int32Value) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1103,16 +1107,17 @@ const char* Int32Value::_InternalParse(const char* ptr, ::_pbi::ParseContext* ct #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - uint32_t tag; + ::uint32_t tag; ptr = ::_pbi::ReadTag(ptr, &tag); switch (tag >> 3) { // int32 value = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) { _impl_.value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else + } else { goto handle_unusual; + } continue; default: goto handle_unusual; @@ -1137,11 +1142,11 @@ failure: #undef CHK_ } -uint8_t* Int32Value::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +::uint8_t* Int32Value::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.Int32Value) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; // int32 value = 1; @@ -1158,12 +1163,12 @@ uint8_t* Int32Value::_InternalSerialize( return target; } -size_t Int32Value::ByteSizeLong() const { +::size_t Int32Value::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:google.protobuf.Int32Value) - size_t total_size = 0; + ::size_t total_size = 0; - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1188,7 +1193,7 @@ void Int32Value::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PRO // @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.Int32Value) GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_value() != 0) { @@ -1268,7 +1273,7 @@ void UInt32Value::SetCachedSize(int size) const { void UInt32Value::Clear() { // @@protoc_insertion_point(message_clear_start:google.protobuf.UInt32Value) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1280,16 +1285,17 @@ const char* UInt32Value::_InternalParse(const char* ptr, ::_pbi::ParseContext* c #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - uint32_t tag; + ::uint32_t tag; ptr = ::_pbi::ReadTag(ptr, &tag); switch (tag >> 3) { // uint32 value = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) { _impl_.value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else + } else { goto handle_unusual; + } continue; default: goto handle_unusual; @@ -1314,11 +1320,11 @@ failure: #undef CHK_ } -uint8_t* UInt32Value::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +::uint8_t* UInt32Value::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.UInt32Value) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; // uint32 value = 1; @@ -1335,12 +1341,12 @@ uint8_t* UInt32Value::_InternalSerialize( return target; } -size_t UInt32Value::ByteSizeLong() const { +::size_t UInt32Value::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:google.protobuf.UInt32Value) - size_t total_size = 0; + ::size_t total_size = 0; - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1365,7 +1371,7 @@ void UInt32Value::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PR // @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.UInt32Value) GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_value() != 0) { @@ -1445,7 +1451,7 @@ void BoolValue::SetCachedSize(int size) const { void BoolValue::Clear() { // @@protoc_insertion_point(message_clear_start:google.protobuf.BoolValue) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1457,16 +1463,17 @@ const char* BoolValue::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - uint32_t tag; + ::uint32_t tag; ptr = ::_pbi::ReadTag(ptr, &tag); switch (tag >> 3) { // bool value = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) { _impl_.value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else + } else { goto handle_unusual; + } continue; default: goto handle_unusual; @@ -1491,11 +1498,11 @@ failure: #undef CHK_ } -uint8_t* BoolValue::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +::uint8_t* BoolValue::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.BoolValue) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; // bool value = 1; @@ -1512,12 +1519,12 @@ uint8_t* BoolValue::_InternalSerialize( return target; } -size_t BoolValue::ByteSizeLong() const { +::size_t BoolValue::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:google.protobuf.BoolValue) - size_t total_size = 0; + ::size_t total_size = 0; - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1542,7 +1549,7 @@ void BoolValue::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROT // @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.BoolValue) GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_value() != 0) { @@ -1639,7 +1646,7 @@ void StringValue::SetCachedSize(int size) const { void StringValue::Clear() { // @@protoc_insertion_point(message_clear_start:google.protobuf.StringValue) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1651,18 +1658,19 @@ const char* StringValue::_InternalParse(const char* ptr, ::_pbi::ParseContext* c #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - uint32_t tag; + ::uint32_t tag; ptr = ::_pbi::ReadTag(ptr, &tag); switch (tag >> 3) { // string value = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { auto str = _internal_mutable_value(); ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); CHK_(::_pbi::VerifyUTF8(str, "google.protobuf.StringValue.value")); - } else + } else { goto handle_unusual; + } continue; default: goto handle_unusual; @@ -1687,11 +1695,11 @@ failure: #undef CHK_ } -uint8_t* StringValue::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +::uint8_t* StringValue::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.StringValue) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; // string value = 1; @@ -1712,12 +1720,12 @@ uint8_t* StringValue::_InternalSerialize( return target; } -size_t StringValue::ByteSizeLong() const { +::size_t StringValue::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:google.protobuf.StringValue) - size_t total_size = 0; + ::size_t total_size = 0; - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1744,7 +1752,7 @@ void StringValue::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PR // @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.StringValue) GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_value().empty()) { @@ -1846,7 +1854,7 @@ void BytesValue::SetCachedSize(int size) const { void BytesValue::Clear() { // @@protoc_insertion_point(message_clear_start:google.protobuf.BytesValue) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1858,17 +1866,18 @@ const char* BytesValue::_InternalParse(const char* ptr, ::_pbi::ParseContext* ct #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - uint32_t tag; + ::uint32_t tag; ptr = ::_pbi::ReadTag(ptr, &tag); switch (tag >> 3) { // bytes value = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { auto str = _internal_mutable_value(); ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); - } else + } else { goto handle_unusual; + } continue; default: goto handle_unusual; @@ -1893,11 +1902,11 @@ failure: #undef CHK_ } -uint8_t* BytesValue::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +::uint8_t* BytesValue::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.BytesValue) - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; // bytes value = 1; @@ -1914,12 +1923,12 @@ uint8_t* BytesValue::_InternalSerialize( return target; } -size_t BytesValue::ByteSizeLong() const { +::size_t BytesValue::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:google.protobuf.BytesValue) - size_t total_size = 0; + ::size_t total_size = 0; - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1946,7 +1955,7 @@ void BytesValue::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PRO // @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.BytesValue) GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; + ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_value().empty()) { diff --git a/src/google/protobuf/wrappers.pb.h b/src/google/protobuf/wrappers.pb.h index 1f0ac0f74b..8c4838d67c 100644 --- a/src/google/protobuf/wrappers.pb.h +++ b/src/google/protobuf/wrappers.pb.h @@ -46,7 +46,7 @@ PROTOBUF_NAMESPACE_CLOSE // Internal implementation detail -- do not use these members. struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fwrappers_2eproto { - static const uint32_t offsets[]; + static const ::uint32_t offsets[]; }; PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fwrappers_2eproto; @@ -194,10 +194,10 @@ class PROTOBUF_EXPORT DoubleValue final : PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; - size_t ByteSizeLong() const final; + ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: @@ -341,10 +341,10 @@ class PROTOBUF_EXPORT FloatValue final : PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; - size_t ByteSizeLong() const final; + ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: @@ -488,10 +488,10 @@ class PROTOBUF_EXPORT Int64Value final : PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; - size_t ByteSizeLong() const final; + ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: @@ -524,11 +524,11 @@ class PROTOBUF_EXPORT Int64Value final : }; // int64 value = 1; void clear_value(); - int64_t value() const; - void set_value(int64_t value); + ::int64_t value() const; + void set_value(::int64_t value); private: - int64_t _internal_value() const; - void _internal_set_value(int64_t value); + ::int64_t _internal_value() const; + void _internal_set_value(::int64_t value); public: // @@protoc_insertion_point(class_scope:google.protobuf.Int64Value) @@ -539,7 +539,7 @@ class PROTOBUF_EXPORT Int64Value final : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { - int64_t value_; + ::int64_t value_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; @@ -635,10 +635,10 @@ class PROTOBUF_EXPORT UInt64Value final : PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; - size_t ByteSizeLong() const final; + ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: @@ -671,11 +671,11 @@ class PROTOBUF_EXPORT UInt64Value final : }; // uint64 value = 1; void clear_value(); - uint64_t value() const; - void set_value(uint64_t value); + ::uint64_t value() const; + void set_value(::uint64_t value); private: - uint64_t _internal_value() const; - void _internal_set_value(uint64_t value); + ::uint64_t _internal_value() const; + void _internal_set_value(::uint64_t value); public: // @@protoc_insertion_point(class_scope:google.protobuf.UInt64Value) @@ -686,7 +686,7 @@ class PROTOBUF_EXPORT UInt64Value final : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { - uint64_t value_; + ::uint64_t value_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; @@ -782,10 +782,10 @@ class PROTOBUF_EXPORT Int32Value final : PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; - size_t ByteSizeLong() const final; + ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: @@ -818,11 +818,11 @@ class PROTOBUF_EXPORT Int32Value final : }; // int32 value = 1; void clear_value(); - int32_t value() const; - void set_value(int32_t value); + ::int32_t value() const; + void set_value(::int32_t value); private: - int32_t _internal_value() const; - void _internal_set_value(int32_t value); + ::int32_t _internal_value() const; + void _internal_set_value(::int32_t value); public: // @@protoc_insertion_point(class_scope:google.protobuf.Int32Value) @@ -833,7 +833,7 @@ class PROTOBUF_EXPORT Int32Value final : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { - int32_t value_; + ::int32_t value_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; @@ -929,10 +929,10 @@ class PROTOBUF_EXPORT UInt32Value final : PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; - size_t ByteSizeLong() const final; + ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: @@ -965,11 +965,11 @@ class PROTOBUF_EXPORT UInt32Value final : }; // uint32 value = 1; void clear_value(); - uint32_t value() const; - void set_value(uint32_t value); + ::uint32_t value() const; + void set_value(::uint32_t value); private: - uint32_t _internal_value() const; - void _internal_set_value(uint32_t value); + ::uint32_t _internal_value() const; + void _internal_set_value(::uint32_t value); public: // @@protoc_insertion_point(class_scope:google.protobuf.UInt32Value) @@ -980,7 +980,7 @@ class PROTOBUF_EXPORT UInt32Value final : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { - uint32_t value_; + ::uint32_t value_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; @@ -1076,10 +1076,10 @@ class PROTOBUF_EXPORT BoolValue final : PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; - size_t ByteSizeLong() const final; + ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: @@ -1223,10 +1223,10 @@ class PROTOBUF_EXPORT StringValue final : PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; - size_t ByteSizeLong() const final; + ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: @@ -1375,10 +1375,10 @@ class PROTOBUF_EXPORT BytesValue final : PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; - size_t ByteSizeLong() const final; + ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: @@ -1503,20 +1503,20 @@ inline void FloatValue::set_value(float value) { // int64 value = 1; inline void Int64Value::clear_value() { - _impl_.value_ = int64_t{0}; + _impl_.value_ = ::int64_t{0}; } -inline int64_t Int64Value::_internal_value() const { +inline ::int64_t Int64Value::_internal_value() const { return _impl_.value_; } -inline int64_t Int64Value::value() const { +inline ::int64_t Int64Value::value() const { // @@protoc_insertion_point(field_get:google.protobuf.Int64Value.value) return _internal_value(); } -inline void Int64Value::_internal_set_value(int64_t value) { +inline void Int64Value::_internal_set_value(::int64_t value) { _impl_.value_ = value; } -inline void Int64Value::set_value(int64_t value) { +inline void Int64Value::set_value(::int64_t value) { _internal_set_value(value); // @@protoc_insertion_point(field_set:google.protobuf.Int64Value.value) } @@ -1527,20 +1527,20 @@ inline void Int64Value::set_value(int64_t value) { // uint64 value = 1; inline void UInt64Value::clear_value() { - _impl_.value_ = uint64_t{0u}; + _impl_.value_ = ::uint64_t{0u}; } -inline uint64_t UInt64Value::_internal_value() const { +inline ::uint64_t UInt64Value::_internal_value() const { return _impl_.value_; } -inline uint64_t UInt64Value::value() const { +inline ::uint64_t UInt64Value::value() const { // @@protoc_insertion_point(field_get:google.protobuf.UInt64Value.value) return _internal_value(); } -inline void UInt64Value::_internal_set_value(uint64_t value) { +inline void UInt64Value::_internal_set_value(::uint64_t value) { _impl_.value_ = value; } -inline void UInt64Value::set_value(uint64_t value) { +inline void UInt64Value::set_value(::uint64_t value) { _internal_set_value(value); // @@protoc_insertion_point(field_set:google.protobuf.UInt64Value.value) } @@ -1553,18 +1553,18 @@ inline void UInt64Value::set_value(uint64_t value) { inline void Int32Value::clear_value() { _impl_.value_ = 0; } -inline int32_t Int32Value::_internal_value() const { +inline ::int32_t Int32Value::_internal_value() const { return _impl_.value_; } -inline int32_t Int32Value::value() const { +inline ::int32_t Int32Value::value() const { // @@protoc_insertion_point(field_get:google.protobuf.Int32Value.value) return _internal_value(); } -inline void Int32Value::_internal_set_value(int32_t value) { +inline void Int32Value::_internal_set_value(::int32_t value) { _impl_.value_ = value; } -inline void Int32Value::set_value(int32_t value) { +inline void Int32Value::set_value(::int32_t value) { _internal_set_value(value); // @@protoc_insertion_point(field_set:google.protobuf.Int32Value.value) } @@ -1577,18 +1577,18 @@ inline void Int32Value::set_value(int32_t value) { inline void UInt32Value::clear_value() { _impl_.value_ = 0u; } -inline uint32_t UInt32Value::_internal_value() const { +inline ::uint32_t UInt32Value::_internal_value() const { return _impl_.value_; } -inline uint32_t UInt32Value::value() const { +inline ::uint32_t UInt32Value::value() const { // @@protoc_insertion_point(field_get:google.protobuf.UInt32Value.value) return _internal_value(); } -inline void UInt32Value::_internal_set_value(uint32_t value) { +inline void UInt32Value::_internal_set_value(::uint32_t value) { _impl_.value_ = value; } -inline void UInt32Value::set_value(uint32_t value) { +inline void UInt32Value::set_value(::uint32_t value) { _internal_set_value(value); // @@protoc_insertion_point(field_set:google.protobuf.UInt32Value.value) }