Merge remote-tracking branch 'refs/remotes/upstream/main' into sync-stage
# Conflicts:
# src/google/protobuf/compiler/objectivec/objectivec_enum.cc
# src/google/protobuf/compiler/objectivec/objectivec_extension.cc
# src/google/protobuf/compiler/objectivec/objectivec_field.cc
# src/google/protobuf/compiler/objectivec/objectivec_file.cc
# src/google/protobuf/compiler/objectivec/objectivec_generator.cc
# src/google/protobuf/compiler/objectivec/objectivec_helpers.cc
# src/google/protobuf/compiler/objectivec/objectivec_message.cc
# src/google/protobuf/compiler/objectivec/objectivec_oneof.cc
# src/google/protobuf/compiler/objectivec/objectivec_primitive_field.cc
# src/google/protobuf/compiler/plugin.pb.h
# src/google/protobuf/descriptor.pb.h
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 76e2c4e..dead8be 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -19,6 +19,10 @@
if(POLICY CMP0091)
cmake_policy(SET CMP0091 NEW)
endif()
+# Honor visibility properties for all target types.
+if(POLICY CMP0063)
+ cmake_policy(SET CMP0063 NEW)
+endif()
# Project
project(protobuf C CXX)
@@ -53,6 +57,11 @@
set(CMAKE_CXX_EXTENSIONS OFF)
endif()
+# For -fvisibility=hidden and -fvisibility-inlines-hidden
+set(CMAKE_C_VISIBILITY_PRESET hidden)
+set(CMAKE_CXX_VISIBILITY_PRESET hidden)
+set(CMAKE_VISIBILITY_INLINES_HIDDEN ON)
+
# The Intel compiler isn't able to deal with noinline member functions of
# template classes defined in headers. As such it spams the output with
# warning #2196: routine is both "inline" and "noinline"
diff --git a/cmake/install.cmake b/cmake/install.cmake
index 26a55be..90230c5 100644
--- a/cmake/install.cmake
+++ b/cmake/install.cmake
@@ -47,7 +47,7 @@
set(protobuf_HEADERS
${libprotobuf_hdrs}
${libprotoc_hdrs}
- ${wkt_protos_proto_srcs}
+ ${wkt_protos_files}
${descriptor_proto_proto_srcs}
${plugin_proto_proto_srcs}
)
diff --git a/java/core/src/main/java/com/google/protobuf/TextFormat.java b/java/core/src/main/java/com/google/protobuf/TextFormat.java
index 7fba30a..aa1cc34 100644
--- a/java/core/src/main/java/com/google/protobuf/TextFormat.java
+++ b/java/core/src/main/java/com/google/protobuf/TextFormat.java
@@ -61,7 +61,6 @@
private static final String DEBUG_STRING_SILENT_MARKER = "\t ";
-
/**
* Outputs a textual representation of the Protocol Message supplied into the parameter output.
* (This representation is the new version of the classic "ProtocolPrinter" output from the
@@ -739,9 +738,9 @@
// Groups must be serialized with their original capitalization.
generator.print(field.getMessageType().getName());
} else {
- generator.print(field.getName());
- }
+ generator.print(field.getName());
}
+ }
if (field.getJavaType() == FieldDescriptor.JavaType.MESSAGE) {
generator.print(" {");
@@ -1836,16 +1835,16 @@
extension = target.findExtensionByName(extensionRegistry, name);
if (extension == null) {
- String message =
- (tokenizer.getPreviousLine() + 1)
- + ":"
- + (tokenizer.getPreviousColumn() + 1)
- + ":\t"
- + type.getFullName()
- + ".["
- + name
- + "]";
- unknownFields.add(new UnknownField(message, UnknownField.Type.EXTENSION));
+ String message =
+ (tokenizer.getPreviousLine() + 1)
+ + ":"
+ + (tokenizer.getPreviousColumn() + 1)
+ + ":\t"
+ + type.getFullName()
+ + ".["
+ + name
+ + "]";
+ unknownFields.add(new UnknownField(message, UnknownField.Type.EXTENSION));
} else {
if (extension.descriptor.getContainingType() != type) {
throw tokenizer.parseExceptionPreviousToken(
diff --git a/java/core/src/test/proto/com/google/protobuf/map_for_proto2_lite_test.proto b/java/core/src/test/proto/com/google/protobuf/map_for_proto2_lite_test.proto
index 4ec9688..95ab8c0 100644
--- a/java/core/src/test/proto/com/google/protobuf/map_for_proto2_lite_test.proto
+++ b/java/core/src/test/proto/com/google/protobuf/map_for_proto2_lite_test.proto
@@ -125,6 +125,3 @@
// null is not a 'reserved word' per se but as a literal needs similar care
map<string, SampleEnum> null = 10;
}
-package map_for_proto2_lite_test;
-option java_package = "map_lite_test";
-option optimize_for = LITE_RUNTIME;
diff --git a/python/google/protobuf/pyext/message.cc b/python/google/protobuf/pyext/message.cc
index 7990e95..ebad6b4 100644
--- a/python/google/protobuf/pyext/message.cc
+++ b/python/google/protobuf/pyext/message.cc
@@ -42,7 +42,7 @@
#include <string>
#include <vector>
-#include "google/protobuf/stubs/strutil.h"
+#include "absl/strings/match.h"
#ifndef PyVarObject_HEAD_INIT
#define PyVarObject_HEAD_INIT(type, size) PyObject_HEAD_INIT(type) size,
@@ -70,6 +70,7 @@
#include "google/protobuf/pyext/unknown_field_set.h"
#include "google/protobuf/pyext/unknown_fields.h"
#include "google/protobuf/util/message_differencer.h"
+#include "google/protobuf/stubs/strutil.h"
#include "absl/strings/string_view.h"
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/io/strtod.h"
@@ -409,7 +410,7 @@
Py_ssize_t attr_size;
static const char kSuffix[] = "_FIELD_NUMBER";
if (PyString_AsStringAndSize(name, &attr, &attr_size) >= 0 &&
- HasSuffixString(absl::string_view(attr, attr_size), kSuffix)) {
+ absl::EndsWith(absl::string_view(attr, attr_size), kSuffix)) {
std::string field_name(attr, attr_size - sizeof(kSuffix) + 1);
LowerString(&field_name);
diff --git a/python/google/protobuf/text_format.py b/python/google/protobuf/text_format.py
index 2b79428..57696f0 100644
--- a/python/google/protobuf/text_format.py
+++ b/python/google/protobuf/text_format.py
@@ -1013,6 +1013,8 @@
if not tokenizer.TryConsume(','):
tokenizer.TryConsume(';')
+
+ def _LogSilentMarker(self, field_name):
pass
def _DetectSilentMarker(self, tokenizer, field_name):
diff --git a/src/google/protobuf/any_lite.cc b/src/google/protobuf/any_lite.cc
index fb812d7..a15d19f 100644
--- a/src/google/protobuf/any_lite.cc
+++ b/src/google/protobuf/any_lite.cc
@@ -29,7 +29,7 @@
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "google/protobuf/io/zero_copy_stream_impl_lite.h"
-#include "google/protobuf/stubs/strutil.h"
+#include "absl/strings/match.h"
#include "absl/strings/str_cat.h"
#include "google/protobuf/any.h"
#include "google/protobuf/arenastring.h"
@@ -72,7 +72,7 @@
absl::string_view type_url = type_url_->Get();
return type_url.size() >= type_name.size() + 1 &&
type_url[type_url.size() - type_name.size() - 1] == '/' &&
- HasSuffixString(type_url, type_name);
+ absl::EndsWith(type_url, type_name);
}
bool ParseAnyTypeUrl(absl::string_view type_url, std::string* url_prefix,
diff --git a/src/google/protobuf/arena.cc b/src/google/protobuf/arena.cc
index 0eb8cc9..4b4b19e 100644
--- a/src/google/protobuf/arena.cc
+++ b/src/google/protobuf/arena.cc
@@ -105,7 +105,7 @@
size_t* space_allocated_;
};
-SerialArena::SerialArena(Block* b, ThreadSafeArena& parent)
+SerialArena::SerialArena(ArenaBlock* b, ThreadSafeArena& parent)
: parent_(parent), space_allocated_(b->size()) {
set_head(b);
set_ptr(b->Pointer(kBlockHeaderSize + ThreadSafeArena::kSerialArenaSize));
@@ -117,13 +117,13 @@
ThreadSafeArenaStats::RecordAllocateStats(parent.arena_stats_.MutableStats(),
/*used=*/0, /*allocated=*/mem.size,
/*wasted=*/0);
- auto b = new (mem.ptr) Block{nullptr, mem.size};
+ auto b = new (mem.ptr) ArenaBlock{nullptr, mem.size};
return new (b->Pointer(kBlockHeaderSize)) SerialArena(b, parent);
}
template <typename Deallocator>
SerialArena::Memory SerialArena::Free(Deallocator deallocator) {
- Block* b = head();
+ ArenaBlock* b = head();
Memory mem = {b, b->size()};
while (b->next) {
b = b->next; // We must first advance before deleting this block
@@ -179,7 +179,7 @@
ThreadSafeArenaStats::RecordAllocateStats(parent_.arena_stats_.MutableStats(),
/*used=*/used,
/*allocated=*/mem.size, wasted);
- set_head(new (mem.ptr) Block{head(), mem.size});
+ set_head(new (mem.ptr) ArenaBlock{head(), mem.size});
set_ptr(head()->Pointer(kBlockHeaderSize));
limit_ = head()->Pointer(head()->size());
@@ -199,7 +199,7 @@
const uint64_t current_block_size = head()->size();
uint64_t space_used = std::min(
static_cast<uint64_t>(
- ptr() - const_cast<Block*>(head())->Pointer(kBlockHeaderSize)),
+ ptr() - const_cast<ArenaBlock*>(head())->Pointer(kBlockHeaderSize)),
current_block_size);
space_used += space_used_.load(std::memory_order_relaxed);
// Remove the overhead of the SerialArena itself.
@@ -208,7 +208,7 @@
}
void SerialArena::CleanupList() {
- Block* b = head();
+ ArenaBlock* b = head();
b->cleanup_nodes = limit_;
do {
char* limit = reinterpret_cast<char*>(
diff --git a/src/google/protobuf/arena.h b/src/google/protobuf/arena.h
index 4bc3994..d3dec65 100644
--- a/src/google/protobuf/arena.h
+++ b/src/google/protobuf/arena.h
@@ -252,9 +252,6 @@
inline ~Arena() {}
- // TODO(protobuf-team): Fix callers to use constructor and delete this method.
- void Init(const ArenaOptions&) {}
-
// API to create proto2 message objects on the arena. If the arena passed in
// is nullptr, then a heap allocated object is returned. Type T must be a
// message defined in a .proto file with cc_enable_arenas set to true,
diff --git a/src/google/protobuf/arena_impl.h b/src/google/protobuf/arena_impl.h
index 2eb6c50..b8969a5 100644
--- a/src/google/protobuf/arena_impl.h
+++ b/src/google/protobuf/arena_impl.h
@@ -90,6 +90,29 @@
}
}
+// Arena blocks are variable length malloc-ed objects. The following structure
+// describes the common header for all blocks.
+struct ArenaBlock {
+ ArenaBlock(ArenaBlock* next, size_t size)
+ : next(next), cleanup_nodes(nullptr), relaxed_size(size) {
+ GOOGLE_DCHECK_GT(size, sizeof(ArenaBlock));
+ }
+
+ char* Pointer(size_t n) {
+ GOOGLE_DCHECK(n <= size());
+ return reinterpret_cast<char*>(this) + n;
+ }
+
+ size_t size() const { return relaxed_size.load(std::memory_order_relaxed); }
+
+ ArenaBlock* const next;
+ void* cleanup_nodes;
+
+ private:
+ const std::atomic<size_t> relaxed_size;
+ // data follows
+};
+
namespace cleanup {
template <typename T>
@@ -545,29 +568,8 @@
template <typename Deallocator>
Memory Free(Deallocator deallocator);
- // Blocks are variable length malloc-ed objects. The following structure
- // describes the common header for all blocks.
- struct Block {
- Block(Block* next, size_t size)
- : next(next), cleanup_nodes(nullptr), relaxed_size(size) {}
-
- char* Pointer(size_t n) {
- GOOGLE_DCHECK(n <= size());
- return reinterpret_cast<char*>(this) + n;
- }
-
- size_t size() const { return relaxed_size.load(std::memory_order_relaxed); }
-
- Block* const next;
- void* cleanup_nodes;
-
- private:
- const std::atomic<size_t> relaxed_size;
- // data follows
- };
-
ThreadSafeArena& parent_;
- std::atomic<Block*> head_; // Head of linked list of blocks.
+ std::atomic<ArenaBlock*> head_; // Head of linked list of blocks.
std::atomic<size_t> space_used_{0}; // Necessary for metrics.
std::atomic<size_t> space_allocated_;
@@ -577,9 +579,11 @@
std::atomic<char*> ptr_;
// Helper getters/setters to handle relaxed operations on atomic variables.
- Block* head() { return head_.load(std::memory_order_relaxed); }
- const Block* head() const { return head_.load(std::memory_order_relaxed); }
- void set_head(Block* head) {
+ ArenaBlock* head() { return head_.load(std::memory_order_relaxed); }
+ const ArenaBlock* head() const {
+ return head_.load(std::memory_order_relaxed);
+ }
+ void set_head(ArenaBlock* head) {
return head_.store(head, std::memory_order_relaxed);
}
char* ptr() { return ptr_.load(std::memory_order_relaxed); }
@@ -604,7 +608,8 @@
CachedBlock** cached_blocks_ = nullptr;
// Constructor is private as only New() should be used.
- inline SerialArena(Block* b, ThreadSafeArena& parent);
+ inline SerialArena(ArenaBlock* b, ThreadSafeArena& parent);
+
void* AllocateAlignedFallback(size_t n);
void* AllocateAlignedWithCleanupFallback(size_t n, size_t align,
void (*destructor)(void*));
@@ -612,7 +617,7 @@
void AllocateNewBlock(size_t n);
public:
- static constexpr size_t kBlockHeaderSize = AlignUpTo8(sizeof(Block));
+ static constexpr size_t kBlockHeaderSize = AlignUpTo8(sizeof(ArenaBlock));
};
// Tag type used to invoke the constructor of message-owned arena.
diff --git a/src/google/protobuf/compiler/code_generator.cc b/src/google/protobuf/compiler/code_generator.cc
index 6c1a967..3f48e37 100644
--- a/src/google/protobuf/compiler/code_generator.cc
+++ b/src/google/protobuf/compiler/code_generator.cc
@@ -38,8 +38,8 @@
#include "google/protobuf/stubs/common.h"
#include "google/protobuf/compiler/plugin.pb.h"
#include "google/protobuf/descriptor.h"
-#include "google/protobuf/stubs/strutil.h"
#include "absl/strings/str_split.h"
+#include "absl/strings/strip.h"
namespace google {
namespace protobuf {
@@ -126,10 +126,10 @@
// Strips ".proto" or ".protodevel" from the end of a filename.
std::string StripProto(const std::string& filename) {
- if (HasSuffixString(filename, ".protodevel")) {
- return StripSuffixString(filename, ".protodevel");
+ if (absl::EndsWith(filename, ".protodevel")) {
+ return std::string(absl::StripSuffix(filename, ".protodevel"));
} else {
- return StripSuffixString(filename, ".proto");
+ return std::string(absl::StripSuffix(filename, ".proto"));
}
}
diff --git a/src/google/protobuf/compiler/command_line_interface.cc b/src/google/protobuf/compiler/command_line_interface.cc
index 09d82f0..dba9729 100644
--- a/src/google/protobuf/compiler/command_line_interface.cc
+++ b/src/google/protobuf/compiler/command_line_interface.cc
@@ -75,6 +75,7 @@
#include "google/protobuf/compiler/subprocess.h"
#include "google/protobuf/compiler/plugin.pb.h"
#include "google/protobuf/stubs/strutil.h"
+#include "absl/strings/match.h"
#include "google/protobuf/stubs/stringprintf.h"
#include "absl/strings/str_replace.h"
#include "absl/strings/str_split.h"
@@ -1065,9 +1066,9 @@
if (mode_ == MODE_COMPILE) {
for (int i = 0; i < output_directives_.size(); i++) {
std::string output_location = output_directives_[i].output_location;
- if (!HasSuffixString(output_location, ".zip") &&
- !HasSuffixString(output_location, ".jar") &&
- !HasSuffixString(output_location, ".srcjar")) {
+ if (!absl::EndsWith(output_location, ".zip") &&
+ !absl::EndsWith(output_location, ".jar") &&
+ !absl::EndsWith(output_location, ".srcjar")) {
AddTrailingSlash(&output_location);
}
@@ -1088,12 +1089,12 @@
for (const auto& pair : output_directories) {
const std::string& location = pair.first;
GeneratorContextImpl* directory = pair.second.get();
- if (HasSuffixString(location, "/")) {
+ if (absl::EndsWith(location, "/")) {
if (!directory->WriteAllToDisk(location)) {
return 1;
}
} else {
- if (HasSuffixString(location, ".jar")) {
+ if (absl::EndsWith(location, ".jar")) {
directory->AddJarManifest();
}
@@ -1971,7 +1972,7 @@
// Some other flag. Look it up in the generators list.
const GeneratorInfo* generator_info = FindGeneratorByFlag(name);
if (generator_info == nullptr &&
- (plugin_prefix_.empty() || !HasSuffixString(name, "_out"))) {
+ (plugin_prefix_.empty() || !absl::EndsWith(name, "_out"))) {
// Check if it's a generator option flag.
generator_info = FindGeneratorByOption(name);
if (generator_info != nullptr) {
@@ -1981,7 +1982,7 @@
parameters->append(",");
}
parameters->append(value);
- } else if (HasPrefixString(name, "--") && HasSuffixString(name, "_opt")) {
+ } else if (absl::StartsWith(name, "--") && absl::EndsWith(name, "_opt")) {
std::string* parameters =
&plugin_parameters_[PluginName(plugin_prefix_, name)];
if (!parameters->empty()) {
@@ -2165,8 +2166,8 @@
std::string error;
if (output_directive.generator == nullptr) {
// This is a plugin.
- GOOGLE_CHECK(HasPrefixString(output_directive.name, "--") &&
- HasSuffixString(output_directive.name, "_out"))
+ GOOGLE_CHECK(absl::StartsWith(output_directive.name, "--") &&
+ absl::EndsWith(output_directive.name, "_out"))
<< "Bad name for plugin generator: " << output_directive.name;
std::string plugin_name = PluginName(plugin_prefix_, output_directive.name);
diff --git a/src/google/protobuf/compiler/command_line_interface_unittest.cc b/src/google/protobuf/compiler/command_line_interface_unittest.cc
index 6b330b8..1ac81e6 100644
--- a/src/google/protobuf/compiler/command_line_interface_unittest.cc
+++ b/src/google/protobuf/compiler/command_line_interface_unittest.cc
@@ -794,6 +794,7 @@
"bar.proto", "Bar");
}
+
TEST_F(CommandLineInterfaceTest, MultipleInputsWithImport_DescriptorSetIn) {
// Test parsing multiple input files with an import of a separate file.
FileDescriptorSet file_descriptor_set;
diff --git a/src/google/protobuf/compiler/cpp/BUILD.bazel b/src/google/protobuf/compiler/cpp/BUILD.bazel
index 8d6657d..4463a09 100644
--- a/src/google/protobuf/compiler/cpp/BUILD.bazel
+++ b/src/google/protobuf/compiler/cpp/BUILD.bazel
@@ -56,6 +56,7 @@
"//src/google/protobuf:protobuf_nowkt",
"//src/google/protobuf/compiler:code_generator",
"@com_google_absl//absl/base:core_headers",
+ "@com_google_absl//absl/container:btree",
"@com_google_absl//absl/container:flat_hash_map",
"@com_google_absl//absl/container:flat_hash_set",
"@com_google_absl//absl/container:layout",
diff --git a/src/google/protobuf/compiler/cpp/file.cc b/src/google/protobuf/compiler/cpp/file.cc
index dff09a8..729e66e 100644
--- a/src/google/protobuf/compiler/cpp/file.cc
+++ b/src/google/protobuf/compiler/cpp/file.cc
@@ -38,21 +38,32 @@
#include <map>
#include <memory>
#include <set>
+#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include "google/protobuf/compiler/scc.h"
+#include "absl/container/btree_map.h"
+#include "absl/container/btree_set.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/flat_hash_set.h"
#include "absl/strings/escaping.h"
+#include "absl/strings/match.h"
#include "absl/strings/str_cat.h"
+#include "google/protobuf/stubs/stringprintf.h"
#include "absl/strings/str_replace.h"
+#include "absl/strings/string_view.h"
+#include "absl/strings/strip.h"
#include "google/protobuf/compiler/cpp/enum.h"
#include "google/protobuf/compiler/cpp/extension.h"
#include "google/protobuf/compiler/cpp/helpers.h"
#include "google/protobuf/compiler/cpp/message.h"
+#include "google/protobuf/compiler/cpp/names.h"
#include "google/protobuf/compiler/cpp/service.h"
#include "google/protobuf/descriptor.h"
#include "google/protobuf/descriptor.pb.h"
+#include "google/protobuf/io/printer.h"
// Must be last.
#include "google/protobuf/port_def.inc"
@@ -61,103 +72,101 @@
namespace protobuf {
namespace compiler {
namespace cpp {
-
namespace {
-
-// When we forward-declare things, we want to create a sorted order so our
-// output is deterministic and minimizes namespace changes.
-template <class T>
-std::string GetSortKey(const T& val) {
- return val.full_name();
-}
-
-template <>
-std::string GetSortKey<FileDescriptor>(const FileDescriptor& val) {
- return val.name();
-}
-
-template <class T>
-bool CompareSortKeys(const T* a, const T* b) {
- return GetSortKey(*a) < GetSortKey(*b);
-}
-
-template <class T>
-std::vector<const T*> Sorted(const std::unordered_set<const T*>& vals) {
- std::vector<const T*> sorted(vals.begin(), vals.end());
- std::sort(sorted.begin(), sorted.end(), CompareSortKeys<T>);
- return sorted;
+absl::flat_hash_map<std::string, std::string> FileVars(
+ const FileDescriptor* file, const Options& options) {
+ return {
+ {"filename", file->name()},
+ {"package_ns", Namespace(file, options)},
+ {"tablename", UniqueName("TableStruct", file, options)},
+ {"desc_table", DescriptorTableName(file, options)},
+ {"dllexport_decl", options.dllexport_decl},
+ {"file_level_metadata", UniqueName("file_level_metadata", file, options)},
+ {"file_level_enum_descriptors",
+ UniqueName("file_level_enum_descriptors", file, options)},
+ {"file_level_service_descriptors",
+ UniqueName("file_level_service_descriptors", file, options)},
+ };
}
// TODO(b/203101078): remove pragmas that suppresses uninitialized warnings when
// clang bug is fixed.
-inline void MuteWuninitialized(Formatter& format) {
- format(
- "#if defined(__llvm__)\n"
- " #pragma clang diagnostic push\n"
- " #pragma clang diagnostic ignored \"-Wuninitialized\"\n"
- "#endif // __llvm__\n");
+void MuteWuninitialized(io::Printer* p) {
+ p->Emit(R"(
+ #if defined(__llvm__)
+ #pragma clang diagnostic push
+ #pragma clang diagnostic ignored "-Wuninitialized"
+ #endif // __llvm__
+ )");
}
-inline void UnmuteWuninitialized(Formatter& format) {
- format(
- "#if defined(__llvm__)\n"
- " #pragma clang diagnostic pop\n"
- "#endif // __llvm__\n");
+void UnmuteWuninitialized(io::Printer* p) {
+ p->Emit(R"(
+ #if defined(__llvm__)
+ #pragma clang diagnostic pop
+ #endif // __llvm__
+ )");
}
-
} // namespace
FileGenerator::FileGenerator(const FileDescriptor* file, const Options& options)
: file_(file), options_(options), scc_analyzer_(options) {
- // These variables are the same on a file level
- variables_["dllexport_decl"] = options.dllexport_decl;
- variables_["tablename"] = UniqueName("TableStruct", file_, options_);
- variables_["file_level_metadata"] =
- UniqueName("file_level_metadata", file_, options_);
- variables_["desc_table"] = DescriptorTableName(file_, options_);
- variables_["file_level_enum_descriptors"] =
- UniqueName("file_level_enum_descriptors", file_, options_);
- variables_["file_level_service_descriptors"] =
- UniqueName("file_level_service_descriptors", file_, options_);
- variables_["filename"] = file_->name();
- variables_["package_ns"] = Namespace(file_, options);
-
std::vector<const Descriptor*> msgs = FlattenMessagesInFile(file);
- for (int i = 0; i < msgs.size(); i++) {
- // Deleted in destructor
- MessageGenerator* msg_gen =
- new MessageGenerator(msgs[i], variables_, i, options, &scc_analyzer_);
- message_generators_.emplace_back(msg_gen);
- msg_gen->AddGenerators(&enum_generators_, &extension_generators_);
+
+ for (int i = 0; i < msgs.size(); ++i) {
+ message_generators_.push_back(absl::make_unique<MessageGenerator>(
+ msgs[i], variables_, i, options, &scc_analyzer_));
+ message_generators_.back()->AddGenerators(&enum_generators_,
+ &extension_generators_);
}
- for (int i = 0; i < file->enum_type_count(); i++) {
- enum_generators_.emplace_back(
- new EnumGenerator(file->enum_type(i), variables_, options));
+ for (int i = 0; i < file->enum_type_count(); ++i) {
+ enum_generators_.push_back(absl::make_unique<EnumGenerator>(
+ file->enum_type(i), variables_, options));
}
- for (int i = 0; i < file->service_count(); i++) {
- service_generators_.emplace_back(
- new ServiceGenerator(file->service(i), variables_, options));
+ for (int i = 0; i < file->service_count(); ++i) {
+ service_generators_.push_back(absl::make_unique<ServiceGenerator>(
+ file->service(i), variables_, options));
}
if (HasGenericServices(file_, options_)) {
- for (int i = 0; i < service_generators_.size(); i++) {
+ for (int i = 0; i < service_generators_.size(); ++i) {
service_generators_[i]->index_in_metadata_ = i;
}
}
- for (int i = 0; i < file->extension_count(); i++) {
- extension_generators_.emplace_back(
- new ExtensionGenerator(file->extension(i), options, &scc_analyzer_));
+
+ for (int i = 0; i < file->extension_count(); ++i) {
+ extension_generators_.push_back(absl::make_unique<ExtensionGenerator>(
+ file->extension(i), options, &scc_analyzer_));
}
+
for (int i = 0; i < file->weak_dependency_count(); ++i) {
weak_deps_.insert(file->weak_dependency(i));
}
}
-FileGenerator::~FileGenerator() = default;
+void FileGenerator::GenerateFile(io::Printer* p, GeneratedFileType file_type,
+ std::function<void()> cb) {
+ auto v = p->WithVars(FileVars(file_, options_));
+ auto guard = IncludeGuard(file_, file_type, options_);
+ p->Emit({{"cb", cb}, {"guard", guard}}, R"(
+ // Generated by the protocol buffer compiler. DO NOT EDIT!
+ // source: $filename$
-void FileGenerator::GenerateMacroUndefs(io::Printer* printer) {
- Formatter format(printer, variables_);
+ #ifndef $guard$
+ #define $guard$
+
+ #include <limits>
+ #include <string>
+ #include <type_traits>
+
+ $cb$;
+
+ #endif // $guard$
+ )");
+}
+
+void FileGenerator::GenerateMacroUndefs(io::Printer* p) {
// Only do this for protobuf's own types. There are some google3 protos using
// macros as field names and the generated code compiles after the macro
// expansion. Undefing these macros actually breaks such code.
@@ -165,412 +174,471 @@
file_->name() != "google/protobuf/compiler/plugin.proto") {
return;
}
- std::vector<std::string> names_to_undef;
+
std::vector<const FieldDescriptor*> fields;
ListAllFields(file_, &fields);
- for (int i = 0; i < fields.size(); i++) {
- const std::string& name = fields[i]->name();
- static const char* kMacroNames[] = {"major", "minor"};
- for (int j = 0; j < ABSL_ARRAYSIZE(kMacroNames); ++j) {
- if (name == kMacroNames[j]) {
- names_to_undef.push_back(name);
- break;
- }
+
+ absl::flat_hash_set<absl::string_view> all_fields;
+ for (const FieldDescriptor* field : fields) {
+ all_fields.insert(field->name());
+ }
+
+ for (absl::string_view name : {"major", "minor"}) {
+ if (!all_fields.contains(name)) {
+ continue;
}
- }
- for (int i = 0; i < names_to_undef.size(); ++i) {
- format(
- "#ifdef $1$\n"
- "#undef $1$\n"
- "#endif\n",
- names_to_undef[i]);
+
+ p->Emit({{"name", std::string(name)}}, R"(
+ #ifdef $name$
+ #undef $name$
+ #endif // $name$
+ )");
}
}
-void FileGenerator::GenerateHeader(io::Printer* printer) {
- Formatter format(printer, variables_);
- // port_def.inc must be included after all other includes.
- IncludeFile("net/proto2/public/port_def.inc", printer);
- format("#define $1$$ dllexport_decl$\n", FileDllExport(file_, options_));
- GenerateMacroUndefs(printer);
+void FileGenerator::GenerateSharedHeaderCode(io::Printer* p) {
+ p->Emit(
+ {
+ {"port_def",
+ [&] { IncludeFile("net/proto2/public/port_def.inc", p); }},
+ {"port_undef",
+ [&] { IncludeFile("net/proto2/public/port_undef.inc", p); }},
+ {"dllexport_macro", FileDllExport(file_, options_)},
+ {"undefs", [&] { GenerateMacroUndefs(p); }},
+ {"global_state_decls",
+ [&] { GenerateGlobalStateFunctionDeclarations(p); }},
+ {"fwd_decls", [&] { GenerateForwardDeclarations(p); }},
+ {"proto2_ns_enums",
+ [&] { GenerateProto2NamespaceEnumSpecializations(p); }},
+ {"main_decls",
+ [&] {
+ NamespaceOpener ns(Namespace(file_, options_), p);
+ p->Emit(
+ {
+ {"enums", [&] { GenerateEnumDefinitions(p); }},
+ {"messages", [&] { GenerateMessageDefinitions(p); }},
+ {"services", [&] { GenerateServiceDefinitions(p); }},
+ {"extensions", [&] { GenerateExtensionIdentifiers(p); }},
+ {"inline_fns",
+ [&] { GenerateInlineFunctionDefinitions(p); }},
+ },
+ R"(
+ $enums$
- // For Any support with lite protos, we need to friend AnyMetadata, so we
- // forward-declare it here.
- format(
- "PROTOBUF_NAMESPACE_OPEN\n"
- "namespace internal {\n"
- "class AnyMetadata;\n"
- "} // namespace internal\n"
- "PROTOBUF_NAMESPACE_CLOSE\n");
+ $hrule_thick$
- GenerateGlobalStateFunctionDeclarations(printer);
+ $messages$
- GenerateForwardDeclarations(printer);
+ $hrule_thick$
- {
- NamespaceOpener ns(Namespace(file_, options_), format);
+ $services$
- format("\n");
+ $extensions$
- GenerateEnumDefinitions(printer);
+ $hrule_thick$
- format(kThickSeparator);
- format("\n");
+ $inline_fns$
- GenerateMessageDefinitions(printer);
+ // @@protoc_insertion_point(namespace_scope)
+ )");
+ }},
+ },
+ R"(
+ // Must be included last.
+ $port_def$
- format("\n");
- format(kThickSeparator);
- format("\n");
+ #define $dllexport_macro$$ dllexport_decl$
+ $undefs$
- GenerateServiceDefinitions(printer);
+ PROTOBUF_NAMESPACE_OPEN
+ namespace internal {
+ class AnyMetadata;
+ } // namespace internal
+ PROTOBUF_NAMESPACE_CLOSE
- GenerateExtensionIdentifiers(printer);
+ $global_state_decls$;
+ $fwd_decls$
- format("\n");
- format(kThickSeparator);
- format("\n");
+ $main_decls$
- GenerateInlineFunctionDefinitions(printer);
+ $proto2_ns_enums$
- format(
- "\n"
- "// @@protoc_insertion_point(namespace_scope)\n"
- "\n");
- }
+ // @@protoc_insertion_point(global_scope)
- // We need to specialize some templates in the ::google::protobuf namespace:
- GenerateProto2NamespaceEnumSpecializations(printer);
-
- format(
- "\n"
- "// @@protoc_insertion_point(global_scope)\n"
- "\n");
- IncludeFile("net/proto2/public/port_undef.inc", printer);
+ $port_undef$
+ )");
}
-void FileGenerator::GenerateProtoHeader(io::Printer* printer,
- const std::string& info_path) {
- Formatter format(printer, variables_);
+void FileGenerator::GenerateProtoHeader(io::Printer* p,
+ absl::string_view info_path) {
if (!options_.proto_h) {
return;
}
- GenerateTopHeaderGuard(printer,
- google::protobuf::compiler::cpp::GeneratedFileType::kProtoH);
-
- if (!options_.opensource_runtime) {
- format(
- "#ifdef SWIG\n"
- "#error \"Do not SWIG-wrap protobufs.\"\n"
- "#endif // SWIG\n"
- "\n");
- }
-
- if (IsBootstrapProto(options_, file_)) {
- format("// IWYU pragma: private, include \"$1$.proto.h\"\n\n",
- StripProto(file_->name()));
- }
-
- GenerateLibraryIncludes(printer);
-
- for (int i = 0; i < file_->public_dependency_count(); i++) {
- const FileDescriptor* dep = file_->public_dependency(i);
- format("#include \"$1$.proto.h\"\n", StripProto(dep->name()));
- }
-
- format("// @@protoc_insertion_point(includes)\n");
-
- GenerateMetadataPragma(printer, info_path);
-
- GenerateHeader(printer);
-
- GenerateBottomHeaderGuard(printer,
- google::protobuf::compiler::cpp::GeneratedFileType::kProtoH);
-}
-
-void FileGenerator::GeneratePBHeader(io::Printer* printer,
- const std::string& info_path) {
- Formatter format(printer, variables_);
- GenerateTopHeaderGuard(printer,
- google::protobuf::compiler::cpp::GeneratedFileType::kPbH);
-
- if (options_.proto_h) {
- std::string target_basename = StripProto(file_->name());
+ GenerateFile(p, GeneratedFileType::kProtoH, [&] {
if (!options_.opensource_runtime) {
- GetBootstrapBasename(options_, target_basename, &target_basename);
+ p->Emit(R"(
+ #ifdef SWIG
+ #error "Do not SWIG-wrap protobufs."
+ #endif // SWIG
+ )");
}
- format("#include \"$1$.proto.h\" // IWYU pragma: export\n",
- target_basename);
- } else {
- GenerateLibraryIncludes(printer);
- }
-
- if (options_.transitive_pb_h) {
- GenerateDependencyIncludes(printer);
- }
-
- // This is unfortunately necessary for some plugins. I don't see why we
- // need two of the same insertion points.
- // TODO(gerbens) remove this.
- format("// @@protoc_insertion_point(includes)\n");
-
- GenerateMetadataPragma(printer, info_path);
-
- if (!options_.proto_h) {
- GenerateHeader(printer);
- } else {
- {
- NamespaceOpener ns(Namespace(file_, options_), format);
- format(
- "\n"
- "// @@protoc_insertion_point(namespace_scope)\n");
+ if (IsBootstrapProto(options_, file_)) {
+ p->Emit({{"name", StripProto(file_->name())}}, R"cc(
+ // IWYU pragma: private, include "$name$.proto.h"
+ )cc");
}
- format(
- "\n"
- "// @@protoc_insertion_point(global_scope)\n"
- "\n");
- }
- GenerateBottomHeaderGuard(printer,
- google::protobuf::compiler::cpp::GeneratedFileType::kPbH);
+ p->Emit(
+ {
+ {"library_includes", [&] { GenerateLibraryIncludes(p); }},
+ {"proto_includes",
+ [&] {
+ for (int i = 0; i < file_->public_dependency_count(); ++i) {
+ const FileDescriptor* dep = file_->public_dependency(i);
+ p->Emit({{"name", StripProto(dep->name())}}, R"(
+ #include "$name$.proto.h"
+ )");
+ }
+ }},
+ {"metadata_pragma", [&] { GenerateMetadataPragma(p, info_path); }},
+ {"header_main", [&] { GenerateSharedHeaderCode(p); }},
+ },
+ R"cc(
+ $library_includes$;
+ $proto_includes$;
+ // @@protoc_insertion_point(includes)
+
+ $metadata_pragma$;
+ $header_main$;
+ )cc");
+ });
}
-void FileGenerator::DoIncludeFile(const std::string& google3_name,
- bool do_export, io::Printer* printer) {
- Formatter format(printer, variables_);
- const std::string prefix = "net/proto2/";
- GOOGLE_CHECK(google3_name.find(prefix) == 0) << google3_name;
+void FileGenerator::GeneratePBHeader(io::Printer* p,
+ absl::string_view info_path) {
+ GenerateFile(p, GeneratedFileType::kPbH, [&] {
+ p->Emit(
+ {
+ {"library_includes",
+ [&] {
+ if (options_.proto_h) {
+ std::string target_basename = StripProto(file_->name());
+ if (!options_.opensource_runtime) {
+ GetBootstrapBasename(options_, target_basename,
+ &target_basename);
+ }
+ p->Emit({{"name", target_basename}}, R"(
+ #include "$name$.proto.h" // IWYU pragma: export
+ )");
+ } else {
+ GenerateLibraryIncludes(p);
+ }
+ }},
+ {"proto_includes",
+ [&] {
+ if (options_.transitive_pb_h) {
+ GenerateDependencyIncludes(p);
+ }
+ }},
+ {"metadata_pragma", [&] { GenerateMetadataPragma(p, info_path); }},
+ {"header_main",
+ [&] {
+ if (!options_.proto_h) {
+ GenerateSharedHeaderCode(p);
+ return;
+ }
+
+ {
+ NamespaceOpener ns(Namespace(file_, options_), p);
+ p->Emit(R"cc(
+
+ // @@protoc_insertion_point(namespace_scope)
+ )cc");
+ }
+ p->Emit(R"cc(
+
+ // @@protoc_insertion_point(global_scope)
+ )cc");
+ }},
+ },
+ R"cc(
+ $library_includes$;
+ $proto_includes$;
+ // @@protoc_insertion_point(includes)
+
+ $metadata_pragma$;
+ $header_main$;
+ )cc");
+ });
+}
+
+void FileGenerator::DoIncludeFile(absl::string_view google3_name,
+ bool do_export, io::Printer* p) {
+ absl::string_view prefix = "net/proto2/";
+ GOOGLE_CHECK(absl::StartsWith(google3_name, prefix)) << google3_name;
+
+ auto v = p->WithVars(
+ {{"export_suffix", do_export ? "// IWYU pragma: export" : ""}});
if (options_.opensource_runtime) {
- std::string path = google3_name.substr(prefix.size());
+ absl::ConsumePrefix(&google3_name, prefix);
+ std::string path(google3_name);
path = StringReplace(path, "internal/", "", false);
path = StringReplace(path, "proto/", "", false);
path = StringReplace(path, "public/", "", false);
+
if (options_.runtime_include_base.empty()) {
- format("#include \"google/protobuf/$1$\"", path);
+ p->Emit({{"path", path}}, R"(
+ #include "google/protobuf/$path$"$ export_suffix$
+ )");
} else {
- format("#include \"$1$google/protobuf/$2$\"",
- options_.runtime_include_base, path);
+ p->Emit({{"base", options_.runtime_include_base}, {"path", path}}, R"(
+ #include "$base$google/protobuf/$path$"$ export_suffix$
+ )");
}
} else {
- std::string path = google3_name;
+ std::string path(google3_name);
// The bootstrapped proto generated code needs to use the
// third_party/protobuf header paths to avoid circular dependencies.
if (options_.bootstrap) {
- path = StringReplace(google3_name, "net/proto2/public",
- "third_party/protobuf", false);
+ path = StringReplace(path, "net/proto2/public", "third_party/protobuf",
+ false);
}
- format("#include \"$1$\"", path);
- }
- if (do_export) {
- format(" // IWYU pragma: export");
+ p->Emit({{"path", path}}, R"(
+ #include "$path$"$ export_suffix$
+ )");
}
-
- format("\n");
}
-std::string FileGenerator::CreateHeaderInclude(const std::string& basename,
+std::string FileGenerator::CreateHeaderInclude(absl::string_view basename,
const FileDescriptor* file) {
- bool use_system_include = false;
- std::string name = basename;
-
- if (options_.opensource_runtime) {
- if (IsWellKnownMessage(file)) {
- if (options_.runtime_include_base.empty()) {
- use_system_include = true;
- } else {
- name = options_.runtime_include_base + basename;
- }
- }
+ if (options_.opensource_runtime && IsWellKnownMessage(file) &&
+ !options_.runtime_include_base.empty()) {
+ return absl::StrCat("\"", options_.runtime_include_base, basename, "\"");
}
- std::string left = "\"";
- std::string right = "\"";
- if (use_system_include) {
- left = "<";
- right = ">";
- }
- return left + name + right;
+ return absl::StrCat("\"", basename, "\"");
}
-void FileGenerator::GenerateSourceIncludes(io::Printer* printer) {
- Formatter format(printer, variables_);
+void FileGenerator::GenerateSourceIncludes(io::Printer* p) {
std::string target_basename = StripProto(file_->name());
if (!options_.opensource_runtime) {
GetBootstrapBasename(options_, target_basename, &target_basename);
}
- target_basename += options_.proto_h ? ".proto.h" : ".pb.h";
- format(
- "// Generated by the protocol buffer compiler. DO NOT EDIT!\n"
- "// source: $filename$\n"
- "\n"
- "#include $1$\n"
- "\n"
- "#include <algorithm>\n" // for swap()
- "\n",
- CreateHeaderInclude(target_basename, file_));
- IncludeFile("net/proto2/io/public/coded_stream.h", printer);
+ absl::StrAppend(&target_basename, options_.proto_h ? ".proto.h" : ".pb.h");
+ p->Emit({{"h_include", CreateHeaderInclude(target_basename, file_)}},
+ R"(
+ // Generated by the protocol buffer compiler. DO NOT EDIT!
+ // source: $filename$
+
+ #include $h_include$
+
+ #include <algorithm>
+ )");
+
+ IncludeFile("net/proto2/io/public/coded_stream.h", p);
// TODO(gerbens) This is to include parse_context.h, we need a better way
- IncludeFile("net/proto2/public/extension_set.h", printer);
- IncludeFile("net/proto2/public/wire_format_lite.h", printer);
+ IncludeFile("net/proto2/public/extension_set.h", p);
+ IncludeFile("net/proto2/public/wire_format_lite.h", p);
// Unknown fields implementation in lite mode uses StringOutputStream
if (!UseUnknownFieldSet(file_, options_) && !message_generators_.empty()) {
- IncludeFile("net/proto2/io/public/zero_copy_stream_impl_lite.h", printer);
+ IncludeFile("net/proto2/io/public/zero_copy_stream_impl_lite.h", p);
}
if (HasDescriptorMethods(file_, options_)) {
- IncludeFile("net/proto2/public/descriptor.h", printer);
- IncludeFile("net/proto2/public/generated_message_reflection.h", printer);
- IncludeFile("net/proto2/public/reflection_ops.h", printer);
- IncludeFile("net/proto2/public/wire_format.h", printer);
+ IncludeFile("net/proto2/public/descriptor.h", p);
+ IncludeFile("net/proto2/public/generated_message_reflection.h", p);
+ IncludeFile("net/proto2/public/reflection_ops.h", p);
+ IncludeFile("net/proto2/public/wire_format.h", p);
}
if (HasGeneratedMethods(file_, options_) &&
options_.tctable_mode != Options::kTCTableNever) {
- IncludeFile("net/proto2/public/generated_message_tctable_impl.h", printer);
+ IncludeFile("net/proto2/public/generated_message_tctable_impl.h", p);
}
if (options_.proto_h) {
// Use the smaller .proto.h files.
- for (int i = 0; i < file_->dependency_count(); i++) {
+ for (int i = 0; i < file_->dependency_count(); ++i) {
const FileDescriptor* dep = file_->dependency(i);
- // Do not import weak deps.
- if (!options_.opensource_runtime && IsDepWeak(dep)) continue;
+
+ if (!options_.opensource_runtime &&
+ IsDepWeak(dep)) { // Do not import weak deps.
+ continue;
+ }
+
std::string basename = StripProto(dep->name());
if (IsBootstrapProto(options_, file_)) {
GetBootstrapBasename(options_, basename, &basename);
}
- format("#include \"$1$.proto.h\"\n", basename);
+ p->Emit({{"name", basename}}, R"(
+ #include "$name$.proto.h"
+ )");
}
}
+
if (HasCordFields(file_, options_)) {
- format(
- "#include \"third_party/absl/strings/internal/string_constant.h\"\n");
+ p->Emit(R"(
+ #include "third_party/absl/strings/internal/string_constant.h"
+ )");
}
- format("// @@protoc_insertion_point(includes)\n");
- IncludeFile("net/proto2/public/port_def.inc", printer);
+ p->Emit(R"cc(
+ // @@protoc_insertion_point(includes)
+
+ // Must be included last.
+ )cc");
+ IncludeFile("net/proto2/public/port_def.inc", p);
}
-void FileGenerator::GenerateSourcePrelude(io::Printer* printer) {
- Formatter format(printer, variables_);
-
+void FileGenerator::GenerateSourcePrelude(io::Printer* p) {
// For MSVC builds, we use #pragma init_seg to move the initialization of our
// libraries to happen before the user code.
// This worksaround the fact that MSVC does not do constant initializers when
// required by the standard.
- format("\nPROTOBUF_PRAGMA_INIT_SEG\n");
+ p->Emit(R"cc(
+ PROTOBUF_PRAGMA_INIT_SEG
+ namespace _pb = ::$proto_ns$;
+ namespace _pbi = ::$proto_ns$::internal;
+ )cc");
- // Generate convenience aliases.
- format(
- "\n"
- "namespace _pb = ::$1$;\n"
- "namespace _pbi = _pb::internal;\n",
- ProtobufNamespace(options_));
if (HasGeneratedMethods(file_, options_) &&
options_.tctable_mode != Options::kTCTableNever) {
- format("namespace _fl = _pbi::field_layout;\n");
+ p->Emit(R"cc(
+ namespace _fl = ::$proto_ns$::internal::field_layout;
+ )cc");
}
- format("\n");
}
-void FileGenerator::GenerateSourceDefaultInstance(int idx,
- io::Printer* printer) {
- Formatter format(printer, variables_);
+void FileGenerator::GenerateSourceDefaultInstance(int idx, io::Printer* p) {
MessageGenerator* generator = message_generators_[idx].get();
+
// Generate the split instance first because it's needed in the constexpr
// constructor.
if (ShouldSplit(generator->descriptor_, options_)) {
// Use a union to disable the destructor of the _instance member.
// We can constant initialize, but the object will still have a non-trivial
// destructor that we need to elide.
- format(
- "struct $1$ {\n"
- " PROTOBUF_CONSTEXPR $1$()\n"
- " : _instance{",
- DefaultInstanceType(generator->descriptor_, options_,
- /*split=*/true));
- generator->GenerateInitDefaultSplitInstance(printer);
- format(
- "} {}\n"
- " union {\n"
- " $1$ _instance;\n"
- " };\n"
- "};\n",
- absl::StrCat(generator->classname_, "::Impl_::Split"));
+ //
// NO_DESTROY is not necessary for correctness. The empty destructor is
// enough. However, the empty destructor fails to be elided in some
// configurations (like non-opt or with certain sanitizers). NO_DESTROY is
// there just to improve performance and binary size in these builds.
- format(
- "PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT "
- "PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const $1$ $2$;\n",
- DefaultInstanceType(generator->descriptor_, options_, /*split=*/true),
- DefaultInstanceName(generator->descriptor_, options_, /*split=*/true));
+ p->Emit(
+ {
+ {"type", DefaultInstanceType(generator->descriptor_, options_,
+ /*split=*/true)},
+ {"name", DefaultInstanceName(generator->descriptor_, options_,
+ /*split=*/true)},
+ {"default",
+ [&] { generator->GenerateInitDefaultSplitInstance(p); }},
+ {"class", absl::StrCat(generator->classname_, "::Impl_::Split")},
+ },
+ R"cc(
+ struct $type$ {
+ PROTOBUF_CONSTEXPR $type$() : _instance{$default$} {}
+ union {
+ $class$ _instance;
+ };
+ };
+
+ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const $type$ $name$;
+ )cc");
}
- generator->GenerateConstexprConstructor(printer);
- format(
- "struct $1$ {\n"
- " PROTOBUF_CONSTEXPR $1$()\n"
- " : _instance(::_pbi::ConstantInitialized{}) {}\n"
- " ~$1$() {}\n"
- " union {\n"
- " $2$ _instance;\n"
- " };\n"
- "};\n",
- DefaultInstanceType(generator->descriptor_, options_),
- generator->classname_);
- format(
- "PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT "
- "PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 $1$ $2$;\n",
- DefaultInstanceType(generator->descriptor_, options_),
- DefaultInstanceName(generator->descriptor_, options_));
+ generator->GenerateConstexprConstructor(p);
- for (int i = 0; i < generator->descriptor_->field_count(); i++) {
+ p->Emit(
+ {
+ {"type", DefaultInstanceType(generator->descriptor_, options_)},
+ {"name", DefaultInstanceName(generator->descriptor_, options_)},
+ {"default", [&] { generator->GenerateInitDefaultSplitInstance(p); }},
+ {"class", generator->classname_},
+ },
+ R"cc(
+ struct $type$ {
+ PROTOBUF_CONSTEXPR $type$() : _instance(::_pbi::ConstantInitialized{}) {}
+ ~$type$() {}
+ union {
+ $class$ _instance;
+ };
+ };
+
+ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 $type$ $name$;
+ )cc");
+
+ for (int i = 0; i < generator->descriptor_->field_count(); ++i) {
const FieldDescriptor* field = generator->descriptor_->field(i);
- if (IsStringInlined(field, options_)) {
- // Force the initialization of the inlined string in the default instance.
- format(
- "PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 std::true_type "
- "$1$::Impl_::_init_inline_$2$_ = "
- "($3$._instance.$4$.Init(), std::true_type{});\n",
- ClassName(generator->descriptor_), FieldName(field),
- DefaultInstanceName(generator->descriptor_, options_),
- FieldMemberName(field, ShouldSplit(field, options_)));
+ if (!IsStringInlined(field, options_)) {
+ continue;
}
+
+ // Force the initialization of the inlined string in the default instance.
+ p->Emit(
+ {
+ {"class", ClassName(generator->descriptor_)},
+ {"field", FieldName(field)},
+ {"default", DefaultInstanceName(generator->descriptor_, options_)},
+ {"member", FieldMemberName(field, ShouldSplit(field, options_))},
+ },
+ R"cc(
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 std::true_type
+ $class$::Impl_::_init_inline_$field$_ =
+ ($default$._instance.$member$.Init(), std::true_type{});
+ )cc");
}
if (options_.lite_implicit_weak_fields) {
- format(
- "PROTOBUF_CONSTINIT const void* $1$ =\n"
- " &$2$;\n",
- DefaultInstancePtr(generator->descriptor_, options_),
- DefaultInstanceName(generator->descriptor_, options_));
+ p->Emit(
+ {
+ {"ptr", DefaultInstancePtr(generator->descriptor_, options_)},
+ {"name", DefaultInstanceName(generator->descriptor_, options_)},
+ },
+ R"cc(
+ PROTOBUF_CONSTINIT const void* $ptr$ = &$name$;
+ )cc");
}
}
// A list of things defined in one .pb.cc file that we need to reference from
// another .pb.cc file.
struct FileGenerator::CrossFileReferences {
+ // When we forward-declare things, we want to create a sorted order so our
+ // output is deterministic and minimizes namespace changes.
+ struct DescCompare {
+ template <typename T>
+ bool operator()(const T* const& a, const T* const& b) const {
+ return a->full_name() < b->full_name();
+ }
+
+ bool operator()(const FileDescriptor* const& a,
+ const FileDescriptor* const& b) const {
+ return a->name() < b->name();
+ }
+ };
+
// Populated if we are referencing from messages or files.
- std::unordered_set<const Descriptor*> weak_default_instances;
+ absl::btree_set<const Descriptor*, DescCompare> weak_default_instances;
// Only if we are referencing from files.
- std::unordered_set<const FileDescriptor*> strong_reflection_files;
- std::unordered_set<const FileDescriptor*> weak_reflection_files;
+ absl::btree_set<const FileDescriptor*, DescCompare> strong_reflection_files;
+ absl::btree_set<const FileDescriptor*, DescCompare> weak_reflection_files;
};
void FileGenerator::GetCrossFileReferencesForField(const FieldDescriptor* field,
CrossFileReferences* refs) {
const Descriptor* msg = field->message_type();
- if (msg == nullptr) return;
+ if (msg == nullptr) {
+ return;
+ }
if (IsImplicitWeakField(field, options_, &scc_analyzer_) ||
IsWeak(field, options_)) {
@@ -584,10 +652,13 @@
GetCrossFileReferencesForField(field, refs);
});
- if (!HasDescriptorMethods(file, options_)) return;
+ if (!HasDescriptorMethods(file, options_)) {
+ return;
+ }
- for (int i = 0; i < file->dependency_count(); i++) {
+ for (int i = 0; i < file->dependency_count(); ++i) {
const FileDescriptor* dep = file->dependency(i);
+
if (IsDepWeak(dep)) {
refs->weak_reflection_files.insert(dep);
} else {
@@ -598,119 +669,128 @@
// Generates references to variables defined in other files.
void FileGenerator::GenerateInternalForwardDeclarations(
- const CrossFileReferences& refs, io::Printer* printer) {
- Formatter format(printer, variables_);
-
+ const CrossFileReferences& refs, io::Printer* p) {
{
- NamespaceOpener ns(format);
- for (auto instance : Sorted(refs.weak_default_instances)) {
+ NamespaceOpener ns(p);
+ for (auto instance : refs.weak_default_instances) {
ns.ChangeTo(Namespace(instance, options_));
+
if (options_.lite_implicit_weak_fields) {
- format(
- "PROTOBUF_CONSTINIT __attribute__((weak)) const void* $1$ =\n"
- " &::_pbi::implicit_weak_message_default_instance;\n",
- DefaultInstancePtr(instance, options_));
+ p->Emit({{"ptr", DefaultInstancePtr(instance, options_)}}, R"cc(
+ PROTOBUF_CONSTINIT __attribute__((weak)) const void* $ptr$ =
+ &::_pbi::implicit_weak_message_default_instance;
+ )cc");
} else {
- format("extern __attribute__((weak)) $1$ $2$;\n",
- DefaultInstanceType(instance, options_),
- DefaultInstanceName(instance, options_));
+ p->Emit({{"type", DefaultInstanceType(instance, options_)},
+ {"name", DefaultInstanceName(instance, options_)}},
+ R"cc(
+ extern __attribute__((weak)) $type$ $name$;
+ )cc");
}
}
}
- for (auto file : Sorted(refs.weak_reflection_files)) {
- format(
- "extern __attribute__((weak)) const ::_pbi::DescriptorTable $1$;\n",
- DescriptorTableName(file, options_));
+ for (auto file : refs.weak_reflection_files) {
+ p->Emit({{"table", DescriptorTableName(file, options_)}}, R"cc(
+ extern __attribute__((weak)) const ::_pbi::DescriptorTable $table$;
+ )cc");
}
}
-void FileGenerator::GenerateSourceForMessage(int idx, io::Printer* printer) {
- Formatter format(printer, variables_);
- GenerateSourceIncludes(printer);
- GenerateSourcePrelude(printer);
+void FileGenerator::GenerateSourceForMessage(int idx, io::Printer* p) {
+ auto v = p->WithVars(FileVars(file_, options_));
- if (IsAnyMessage(file_, options_)) MuteWuninitialized(format);
+ GenerateSourceIncludes(p);
+ GenerateSourcePrelude(p);
+
+ if (IsAnyMessage(file_, options_)) {
+ MuteWuninitialized(p);
+ }
CrossFileReferences refs;
ForEachField(message_generators_[idx]->descriptor_,
[this, &refs](const FieldDescriptor* field) {
GetCrossFileReferencesForField(field, &refs);
});
- GenerateInternalForwardDeclarations(refs, printer);
- { // package namespace
- NamespaceOpener ns(Namespace(file_, options_), format);
-
- // Define default instances
- GenerateSourceDefaultInstance(idx, printer);
-
- // Generate classes.
- format("\n");
- message_generators_[idx]->GenerateClassMethods(printer);
-
- format(
- "\n"
- "// @@protoc_insertion_point(namespace_scope)\n");
- } // end package namespace
+ GenerateInternalForwardDeclarations(refs, p);
{
- NamespaceOpener proto_ns(ProtobufNamespace(options_), format);
- message_generators_[idx]->GenerateSourceInProto2Namespace(printer);
+ NamespaceOpener ns(Namespace(file_, options_), p);
+ p->Emit(
+ {
+ {"defaults", [&] { GenerateSourceDefaultInstance(idx, p); }},
+ {"class_methods",
+ [&] { message_generators_[idx]->GenerateClassMethods(p); }},
+ },
+ R"cc(
+ $defaults$;
+
+ $class_methods$;
+
+ // @@protoc_insertion_point(namespace_scope)
+ )cc");
}
- if (IsAnyMessage(file_, options_)) UnmuteWuninitialized(format);
+ {
+ NamespaceOpener proto_ns(ProtobufNamespace(options_), p);
+ message_generators_[idx]->GenerateSourceInProto2Namespace(p);
+ }
- format(
- "\n"
- "// @@protoc_insertion_point(global_scope)\n");
+ if (IsAnyMessage(file_, options_)) {
+ UnmuteWuninitialized(p);
+ }
+
+ p->Emit(R"cc(
+ // @@protoc_insertion_point(global_scope)
+ )cc");
}
-void FileGenerator::GenerateSourceForExtension(int idx, io::Printer* printer) {
- Formatter format(printer, variables_);
- GenerateSourceIncludes(printer);
- GenerateSourcePrelude(printer);
- NamespaceOpener ns(Namespace(file_, options_), format);
- extension_generators_[idx]->GenerateDefinition(printer);
+void FileGenerator::GenerateSourceForExtension(int idx, io::Printer* p) {
+ auto v = p->WithVars(FileVars(file_, options_));
+ GenerateSourceIncludes(p);
+ GenerateSourcePrelude(p);
+
+ NamespaceOpener ns(Namespace(file_, options_), p);
+ extension_generators_[idx]->GenerateDefinition(p);
}
-void FileGenerator::GenerateGlobalSource(io::Printer* printer) {
- Formatter format(printer, variables_);
- GenerateSourceIncludes(printer);
- GenerateSourcePrelude(printer);
+void FileGenerator::GenerateGlobalSource(io::Printer* p) {
+ auto v = p->WithVars(FileVars(file_, options_));
+ GenerateSourceIncludes(p);
+ GenerateSourcePrelude(p);
{
// Define the code to initialize reflection. This code uses a global
// constructor to register reflection data with the runtime pre-main.
if (HasDescriptorMethods(file_, options_)) {
- GenerateReflectionInitializationCode(printer);
+ GenerateReflectionInitializationCode(p);
}
}
- NamespaceOpener ns(Namespace(file_, options_), format);
-
- // Generate enums.
- for (int i = 0; i < enum_generators_.size(); i++) {
- enum_generators_[i]->GenerateMethods(i, printer);
+ NamespaceOpener ns(Namespace(file_, options_), p);
+ for (int i = 0; i < enum_generators_.size(); ++i) {
+ enum_generators_[i]->GenerateMethods(i, p);
}
}
-void FileGenerator::GenerateSource(io::Printer* printer) {
- Formatter format(printer, variables_);
- GenerateSourceIncludes(printer);
- GenerateSourcePrelude(printer);
+void FileGenerator::GenerateSource(io::Printer* p) {
+ auto v = p->WithVars(FileVars(file_, options_));
+
+ GenerateSourceIncludes(p);
+ GenerateSourcePrelude(p);
CrossFileReferences refs;
GetCrossFileReferencesForFile(file_, &refs);
- GenerateInternalForwardDeclarations(refs, printer);
+ GenerateInternalForwardDeclarations(refs, p);
- if (IsAnyMessage(file_, options_)) MuteWuninitialized(format);
+ if (IsAnyMessage(file_, options_)) {
+ MuteWuninitialized(p);
+ }
{
- NamespaceOpener ns(Namespace(file_, options_), format);
-
- // Define default instances
- for (int i = 0; i < message_generators_.size(); i++) {
- GenerateSourceDefaultInstance(i, printer);
+ NamespaceOpener ns(Namespace(file_, options_), p);
+ for (int i = 0; i < message_generators_.size(); ++i) {
+ GenerateSourceDefaultInstance(i, p);
}
}
@@ -718,144 +798,155 @@
if (HasDescriptorMethods(file_, options_)) {
// Define the code to initialize reflection. This code uses a global
// constructor to register reflection data with the runtime pre-main.
- GenerateReflectionInitializationCode(printer);
+ GenerateReflectionInitializationCode(p);
}
}
{
- NamespaceOpener ns(Namespace(file_, options_), format);
+ NamespaceOpener ns(Namespace(file_, options_), p);
// Actually implement the protos
// Generate enums.
- for (int i = 0; i < enum_generators_.size(); i++) {
- enum_generators_[i]->GenerateMethods(i, printer);
+ for (int i = 0; i < enum_generators_.size(); ++i) {
+ enum_generators_[i]->GenerateMethods(i, p);
}
// Generate classes.
- for (int i = 0; i < message_generators_.size(); i++) {
- format("\n");
- format(kThickSeparator);
- format("\n");
- message_generators_[i]->GenerateClassMethods(printer);
+ for (int i = 0; i < message_generators_.size(); ++i) {
+ p->Emit(R"(
+ $hrule_thick$
+ )");
+ message_generators_[i]->GenerateClassMethods(p);
}
if (HasGenericServices(file_, options_)) {
// Generate services.
- for (int i = 0; i < service_generators_.size(); i++) {
- if (i == 0) format("\n");
- format(kThickSeparator);
- format("\n");
- service_generators_[i]->GenerateImplementation(printer);
+ for (int i = 0; i < service_generators_.size(); ++i) {
+ p->Emit(R"(
+ $hrule_thick$
+ )");
+ service_generators_[i]->GenerateImplementation(p);
}
}
// Define extensions.
- for (int i = 0; i < extension_generators_.size(); i++) {
- extension_generators_[i]->GenerateDefinition(printer);
+ for (int i = 0; i < extension_generators_.size(); ++i) {
+ extension_generators_[i]->GenerateDefinition(p);
}
- format(
- "\n"
- "// @@protoc_insertion_point(namespace_scope)\n");
+ p->Emit(R"cc(
+ // @@protoc_insertion_point(namespace_scope)
+ )cc");
}
{
- NamespaceOpener proto_ns(ProtobufNamespace(options_), format);
- for (int i = 0; i < message_generators_.size(); i++) {
- message_generators_[i]->GenerateSourceInProto2Namespace(printer);
+ NamespaceOpener proto_ns(ProtobufNamespace(options_), p);
+ for (int i = 0; i < message_generators_.size(); ++i) {
+ message_generators_[i]->GenerateSourceInProto2Namespace(p);
}
}
- format(
- "\n"
- "// @@protoc_insertion_point(global_scope)\n");
+ p->Emit(R"cc(
+ // @@protoc_insertion_point(global_scope)
+ )cc");
- if (IsAnyMessage(file_, options_)) UnmuteWuninitialized(format);
+ if (IsAnyMessage(file_, options_)) {
+ UnmuteWuninitialized(p);
+ }
- IncludeFile("net/proto2/public/port_undef.inc", printer);
+ IncludeFile("net/proto2/public/port_undef.inc", p);
}
-void FileGenerator::GenerateReflectionInitializationCode(io::Printer* printer) {
- Formatter format(printer, variables_);
-
+void FileGenerator::GenerateReflectionInitializationCode(io::Printer* p) {
if (!message_generators_.empty()) {
- format("static ::_pb::Metadata $file_level_metadata$[$1$];\n",
- message_generators_.size());
+ p->Emit({{"len", absl::StrCat(message_generators_.size())}}, R"cc(
+ static ::_pb::Metadata $file_level_metadata$[$len$];
+ )cc");
}
+
if (!enum_generators_.empty()) {
- format(
- "static const ::_pb::EnumDescriptor* "
- "$file_level_enum_descriptors$[$1$];\n",
- enum_generators_.size());
+ p->Emit({{"len", absl::StrCat(enum_generators_.size())}}, R"cc(
+ static const ::_pb::EnumDescriptor* $file_level_enum_descriptors$[$len$];
+ )cc");
} else {
- format(
- "static "
- "constexpr ::_pb::EnumDescriptor const** "
- "$file_level_enum_descriptors$ = nullptr;\n");
+ p->Emit(R"cc(
+ static constexpr const ::_pb::EnumDescriptor**
+ $file_level_enum_descriptors$ = nullptr;
+ )cc");
}
+
if (HasGenericServices(file_, options_) && file_->service_count() > 0) {
- format(
- "static "
- "const ::_pb::ServiceDescriptor* "
- "$file_level_service_descriptors$[$1$];\n",
- file_->service_count());
+ p->Emit({{"len", absl::StrCat(file_->service_count())}}, R"cc(
+ static const ::_pb::ServiceDescriptor*
+ $file_level_service_descriptors$[$len$];
+ )cc");
} else {
- format(
- "static "
- "constexpr ::_pb::ServiceDescriptor const** "
- "$file_level_service_descriptors$ = nullptr;\n");
+ p->Emit(R"cc(
+ static constexpr const ::_pb::ServiceDescriptor**
+ $file_level_service_descriptors$ = nullptr;
+ )cc");
}
if (!message_generators_.empty()) {
- format(
- "\n"
- "const $uint32$ $tablename$::offsets[] "
- "PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {\n");
- format.Indent();
- std::vector<std::pair<size_t, size_t> > pairs;
- pairs.reserve(message_generators_.size());
- for (int i = 0; i < message_generators_.size(); i++) {
- pairs.push_back(message_generators_[i]->GenerateOffsets(printer));
- }
- format.Outdent();
- format(
- "};\n"
- "static const ::_pbi::MigrationSchema schemas[] "
- "PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {\n");
- format.Indent();
- {
- int offset = 0;
- for (int i = 0; i < message_generators_.size(); i++) {
- message_generators_[i]->GenerateSchema(printer, offset,
- pairs[i].second);
- offset += pairs[i].first;
- }
- }
- format.Outdent();
- format(
- "};\n"
- "\nstatic const ::_pb::Message* const file_default_instances[] = {\n");
- format.Indent();
- for (int i = 0; i < message_generators_.size(); i++) {
- const Descriptor* descriptor = message_generators_[i]->descriptor_;
- format("&$1$::_$2$_default_instance_._instance,\n",
- Namespace(descriptor, options_), // 1
- ClassName(descriptor)); // 2
- }
- format.Outdent();
- format(
- "};\n"
- "\n");
+ std::vector<std::pair<size_t, size_t>> offsets;
+ offsets.reserve(message_generators_.size());
+
+ p->Emit(
+ {
+ {"offsets",
+ [&] {
+ for (int i = 0; i < message_generators_.size(); ++i) {
+ offsets.push_back(message_generators_[i]->GenerateOffsets(p));
+ }
+ }},
+ {"schemas",
+ [&] {
+ int offset = 0;
+ for (int i = 0; i < message_generators_.size(); ++i) {
+ message_generators_[i]->GenerateSchema(p, offset,
+ offsets[i].second);
+ offset += offsets[i].first;
+ }
+ }},
+ {"defaults",
+ [&] {
+ for (auto& gen : message_generators_) {
+ p->Emit(
+ {
+ {"ns", Namespace(gen->descriptor_, options_)},
+ {"class", ClassName(gen->descriptor_)},
+ },
+ R"cc(
+ &$ns$::_$class$_default_instance_._instance,
+ )cc");
+ }
+ }},
+ },
+ R"cc(
+ const uint32_t $tablename$::offsets[] PROTOBUF_SECTION_VARIABLE(
+ protodesc_cold) = {
+ $offsets$,
+ };
+
+ static const ::_pbi::MigrationSchema
+ schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+ $schemas$,
+ };
+
+ static const ::_pb::Message* const file_default_instances[] = {
+ $defaults$,
+ };
+ )cc");
} else {
- // we still need these symbols to exist
- format(
- // MSVC doesn't like empty arrays, so we add a dummy.
- "const $uint32$ $tablename$::offsets[1] = {};\n"
- "static constexpr ::_pbi::MigrationSchema* schemas = nullptr;\n"
- "static constexpr ::_pb::Message* const* "
- "file_default_instances = nullptr;\n"
- "\n");
+ // Ee still need these symbols to exist.
+ //
+ // MSVC doesn't like empty arrays, so we add a dummy.
+ p->Emit(R"cc(
+ const uint32_t $tablename$::offsets[1] = {};
+ static constexpr ::_pbi::MigrationSchema* schemas = nullptr;
+ static constexpr ::_pb::Message* const* file_default_instances = nullptr;
+ )cc");
}
// ---------------------------------------------------------------
@@ -863,63 +954,88 @@
// Embed the descriptor. We simply serialize the entire
// FileDescriptorProto/ and embed it as a string literal, which is parsed and
// built into real descriptors at initialization time.
- const std::string protodef_name =
- UniqueName("descriptor_table_protodef", file_, options_);
- format("const char $1$[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =\n",
- protodef_name);
- format.Indent();
+
FileDescriptorProto file_proto;
file_->CopyTo(&file_proto);
std::string file_data;
file_proto.SerializeToString(&file_data);
- {
- if (file_data.size() > 65535) {
- // Workaround for MSVC: "Error C1091: compiler limit: string exceeds
- // 65535 bytes in length". Declare a static array of chars rather than
- // use a string literal. Only write 25 bytes per line.
- static const int kBytesPerLine = 25;
- format("{ ");
- for (int i = 0; i < file_data.size();) {
- for (int j = 0; j < kBytesPerLine && i < file_data.size(); ++i, ++j) {
- format("'$1$', ", absl::CEscape(file_data.substr(i, 1)));
- }
- format("\n");
- }
- format("'\\0' }"); // null-terminate
- } else {
- // Only write 40 bytes per line.
- static const int kBytesPerLine = 40;
- for (int i = 0; i < file_data.size(); i += kBytesPerLine) {
- format(
- "\"$1$\"\n",
- EscapeTrigraphs(absl::CEscape(file_data.substr(i, kBytesPerLine))));
- }
- }
- format(";\n");
- }
- format.Outdent();
+ auto desc_name = UniqueName("descriptor_table_protodef", file_, options_);
+ p->Emit(
+ {{"desc_name", desc_name},
+ {"encoded_file_proto",
+ [&] {
+ absl::string_view data = file_data;
+ if (data.size() <= 65535) {
+ static constexpr size_t kBytesPerLine = 40;
+ while (!data.empty()) {
+ auto to_write = std::min(kBytesPerLine, data.size());
+ auto chunk = data.substr(0, to_write);
+ data = data.substr(to_write);
+
+ p->Emit({{"text", EscapeTrigraphs(absl::CEscape(chunk))}}, R"cc(
+ "$text$"
+ )cc");
+ }
+ return;
+ }
+
+ // Workaround for MSVC: "Error C1091: compiler limit: string exceeds
+ // 65535 bytes in length". Declare a static array of chars rather than
+ // use a string literal. Only write 25 bytes per line.
+ static constexpr size_t kBytesPerLine = 25;
+ while (!data.empty()) {
+ auto to_write = std::min(kBytesPerLine, data.size());
+ auto chunk = data.substr(0, to_write);
+ data = data.substr(to_write);
+
+ std::string line;
+ for (char c : chunk) {
+ absl::StrAppend(&line, "'",
+ absl::CEscape(absl::string_view(&c, 1)), "', ");
+ }
+
+ p->Emit({{"line", line}}, R"cc(
+ $line$
+ )cc");
+ }
+ }}},
+ R"cc(
+ const char $desc_name$[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+ $encoded_file_proto$,
+ };
+ )cc");
CrossFileReferences refs;
GetCrossFileReferencesForFile(file_, &refs);
- int num_deps =
+ size_t num_deps =
refs.strong_reflection_files.size() + refs.weak_reflection_files.size();
// Build array of DescriptorTable deps.
if (num_deps > 0) {
- format(
- "static const ::_pbi::DescriptorTable* const "
- "$desc_table$_deps[$1$] = {\n",
- num_deps);
-
- for (auto dep : Sorted(refs.strong_reflection_files)) {
- format(" &::$1$,\n", DescriptorTableName(dep, options_));
- }
- for (auto dep : Sorted(refs.weak_reflection_files)) {
- format(" &::$1$,\n", DescriptorTableName(dep, options_));
- }
-
- format("};\n");
+ p->Emit(
+ {
+ {"len", absl::StrCat(num_deps)},
+ {"deps",
+ [&] {
+ for (auto dep : refs.strong_reflection_files) {
+ p->Emit({{"name", DescriptorTableName(dep, options_)}}, R"cc(
+ &::$name$,
+ )cc");
+ }
+ for (auto dep : refs.weak_reflection_files) {
+ p->Emit({{"name", DescriptorTableName(dep, options_)}}, R"cc(
+ &::$name$,
+ )cc");
+ }
+ }},
+ },
+ R"cc(
+ static const ::_pbi::DescriptorTable* const $desc_table$_deps[$len$] =
+ {
+ $deps$,
+ };
+ )cc");
}
// The DescriptorTable itself.
@@ -927,344 +1043,358 @@
// however this might cause a tsan failure in superroot b/148382879,
// so disable for now.
bool eager = false;
- format(
- "static ::absl::once_flag $desc_table$_once;\n"
- "const ::_pbi::DescriptorTable $desc_table$ = {\n"
- " false, $1$, $2$, $3$,\n"
- " \"$filename$\",\n"
- " &$desc_table$_once, $4$, $5$, $6$,\n"
- " schemas, file_default_instances, $tablename$::offsets,\n"
- " $7$, $file_level_enum_descriptors$,\n"
- " $file_level_service_descriptors$,\n"
- "};\n"
- // This function exists to be marked as weak.
- // It can significantly speed up compilation by breaking up LLVM's SCC in
- // the .pb.cc translation units. Large translation units see a reduction
- // of more than 35% of walltime for optimized builds.
- // Without the weak attribute all the messages in the file, including all
- // the vtables and everything they use become part of the same SCC through
- // a cycle like:
- // GetMetadata -> descriptor table -> default instances ->
- // vtables -> GetMetadata
- // By adding a weak function here we break the connection from the
- // individual vtables back into the descriptor table.
- "PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* "
- "$desc_table$_getter() {\n"
- " return &$desc_table$;\n"
- "}\n"
- "\n",
- eager ? "true" : "false", file_data.size(), protodef_name,
- num_deps == 0 ? "nullptr" : variables_["desc_table"] + "_deps", num_deps,
- message_generators_.size(),
- message_generators_.empty() ? "nullptr"
- : variables_["file_level_metadata"]);
+ p->Emit(
+ {
+ {"eager", eager ? "true" : "false"},
+ {"file_proto_len", absl::StrCat(file_data.size())},
+ {"proto_name", desc_name},
+ {"deps_ptr", num_deps == 0
+ ? "nullptr"
+ : absl::StrCat(p->LookupVar("desc_table"), "_deps")},
+ {"num_deps", absl::StrCat(num_deps)},
+ {"num_msgs", absl::StrCat(message_generators_.size())},
+ {"msgs_ptr", message_generators_.empty()
+ ? "nullptr"
+ : std::string(p->LookupVar("file_level_metadata"))},
+ },
+ R"cc(
+ static ::absl::once_flag $desc_table$_once;
+ const ::_pbi::DescriptorTable $desc_table$ = {
+ false,
+ $eager$,
+ $file_proto_len$,
+ $proto_name$,
+ "$filename$",
+ &$desc_table$_once,
+ $deps_ptr$,
+ $num_deps$,
+ $num_msgs$,
+ schemas,
+ file_default_instances,
+ $tablename$::offsets,
+ $msgs_ptr$,
+ $file_level_enum_descriptors$,
+ $file_level_service_descriptors$,
+ };
+
+ // This function exists to be marked as weak.
+ // It can significantly speed up compilation by breaking up LLVM's SCC
+ // in the .pb.cc translation units. Large translation units see a
+ // reduction of more than 35% of walltime for optimized builds. Without
+ // the weak attribute all the messages in the file, including all the
+ // vtables and everything they use become part of the same SCC through
+ // a cycle like:
+ // GetMetadata -> descriptor table -> default instances ->
+ // vtables -> GetMetadata
+ // By adding a weak function here we break the connection from the
+ // individual vtables back into the descriptor table.
+ PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* $desc_table$_getter() {
+ return &$desc_table$;
+ }
+ )cc");
// For descriptor.proto we want to avoid doing any dynamic initialization,
// because in some situations that would otherwise pull in a lot of
// unnecessary code that can't be stripped by --gc-sections. Descriptor
// initialization will still be performed lazily when it's needed.
- if (file_->name() != "net/proto2/proto/descriptor.proto") {
- format(
- "// Force running AddDescriptors() at dynamic initialization time.\n"
- "PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 "
- "static ::_pbi::AddDescriptorsRunner $1$(&$desc_table$);\n",
- UniqueName("dynamic_init_dummy", file_, options_));
+ if (file_->name() == "net/proto2/proto/descriptor.proto") {
+ return;
}
+
+ p->Emit({{"dummy", UniqueName("dynamic_init_dummy", file_, options_)}}, R"cc(
+ // Force running AddDescriptors() at dynamic initialization time.
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY2
+ static ::_pbi::AddDescriptorsRunner $dummy$(&$desc_table$);
+ )cc");
}
class FileGenerator::ForwardDeclarations {
public:
- void AddMessage(const Descriptor* d) { classes_[ClassName(d)] = d; }
- void AddEnum(const EnumDescriptor* d) { enums_[ClassName(d)] = d; }
- void AddSplit(const Descriptor* d) { splits_[ClassName(d)] = d; }
+ void AddMessage(const Descriptor* d) { classes_.emplace(ClassName(d), d); }
+ void AddEnum(const EnumDescriptor* d) { enums_.emplace(ClassName(d), d); }
+ void AddSplit(const Descriptor* d) { splits_.emplace(ClassName(d), d); }
- void Print(const Formatter& format, const Options& options) const {
- for (const auto& p : enums_) {
- const std::string& enumname = p.first;
- const EnumDescriptor* enum_desc = p.second;
- format(
- "enum ${1$$2$$}$ : int;\n"
- "bool $2$_IsValid(int value);\n",
- enum_desc, enumname);
+ void Print(io::Printer* p, const Options& options) const {
+ for (const auto& e : enums_) {
+ auto a = p->WithAnnotations({{"enum", e.second}});
+ p->Emit({{"enum", e.first}}, R"cc(
+ enum $enum$ : int;
+ bool $enum$_IsValid(int value);
+ )cc");
}
- for (const auto& p : classes_) {
- const std::string& classname = p.first;
- const Descriptor* class_desc = p.second;
- format(
- "class ${1$$2$$}$;\n"
- "struct $3$;\n"
- "$dllexport_decl $extern $3$ $4$;\n",
- class_desc, classname, DefaultInstanceType(class_desc, options),
- DefaultInstanceName(class_desc, options));
+
+ for (const auto& c : classes_) {
+ const Descriptor* desc = c.second;
+ auto a = p->WithAnnotations({{"class", desc}});
+ p->Emit(
+ {
+ {"class", c.first},
+ {"default_type", DefaultInstanceType(desc, options)},
+ {"default_name", DefaultInstanceName(desc, options)},
+ },
+ R"cc(
+ class $class$;
+ struct $default_type$;
+ $dllexport_decl $extern $default_type$ $default_name$;
+ )cc");
}
- for (const auto& p : splits_) {
- const Descriptor* class_desc = p.second;
- format(
- "struct $1$;\n"
- "$dllexport_decl $extern const $1$ $2$;\n",
- DefaultInstanceType(class_desc, options, /*split=*/true),
- DefaultInstanceName(class_desc, options, /*split=*/true));
+
+ for (const auto& s : splits_) {
+ const Descriptor* desc = s.second;
+ p->Emit(
+ {
+ {"default_type",
+ DefaultInstanceType(desc, options, /*split=*/true)},
+ {"default_name",
+ DefaultInstanceName(desc, options, /*split=*/true)},
+ },
+ R"cc(
+ struct $default_type$;
+ $dllexport_decl $extern const $default_type$ $default_name$;
+ )cc");
}
}
- void PrintTopLevelDecl(const Formatter& format,
- const Options& options) const {
- for (const auto& pair : classes_) {
- format(
- "template<> $dllexport_decl $"
- "$1$* Arena::CreateMaybeMessage<$1$>(Arena*);\n",
- QualifiedClassName(pair.second, options));
+ void PrintTopLevelDecl(io::Printer* p, const Options& options) const {
+ for (const auto& c : classes_) {
+ p->Emit({{"class", QualifiedClassName(c.second, options)}}, R"cc(
+ template <>
+ $dllexport_decl $$class$* Arena::CreateMaybeMessage<$class$>(Arena*);
+ )cc");
}
}
private:
- std::map<std::string, const Descriptor*> classes_;
- std::map<std::string, const EnumDescriptor*> enums_;
- std::map<std::string, const Descriptor*> splits_;
+ absl::btree_map<std::string, const Descriptor*> classes_;
+ absl::btree_map<std::string, const EnumDescriptor*> enums_;
+ absl::btree_map<std::string, const Descriptor*> splits_;
};
-static void PublicImportDFS(const FileDescriptor* fd,
- std::unordered_set<const FileDescriptor*>* fd_set) {
- for (int i = 0; i < fd->public_dependency_count(); i++) {
+static void PublicImportDFS(
+ const FileDescriptor* fd,
+ absl::flat_hash_set<const FileDescriptor*>& fd_set) {
+ for (int i = 0; i < fd->public_dependency_count(); ++i) {
const FileDescriptor* dep = fd->public_dependency(i);
- if (fd_set->insert(dep).second) PublicImportDFS(dep, fd_set);
+ if (fd_set.insert(dep).second) {
+ PublicImportDFS(dep, fd_set);
+ }
}
}
-void FileGenerator::GenerateForwardDeclarations(io::Printer* printer) {
- Formatter format(printer, variables_);
+void FileGenerator::GenerateForwardDeclarations(io::Printer* p) {
std::vector<const Descriptor*> classes;
- std::vector<const EnumDescriptor*> enums;
-
FlattenMessagesInFile(file_, &classes); // All messages need forward decls.
+ std::vector<const EnumDescriptor*> enums;
if (options_.proto_h) { // proto.h needs extra forward declarations.
// All classes / enums referred to as field members
std::vector<const FieldDescriptor*> fields;
ListAllFields(file_, &fields);
- for (int i = 0; i < fields.size(); i++) {
- classes.push_back(fields[i]->containing_type());
- classes.push_back(fields[i]->message_type());
- enums.push_back(fields[i]->enum_type());
+ for (const auto* field : fields) {
+ classes.push_back(field->containing_type());
+ classes.push_back(field->message_type());
+ enums.push_back(field->enum_type());
}
+
ListAllTypesForServices(file_, &classes);
}
// Calculate the set of files whose definitions we get through include.
// No need to forward declare types that are defined in these.
- std::unordered_set<const FileDescriptor*> public_set;
- PublicImportDFS(file_, &public_set);
+ absl::flat_hash_set<const FileDescriptor*> public_set;
+ PublicImportDFS(file_, public_set);
- std::map<std::string, ForwardDeclarations> decls;
- for (int i = 0; i < classes.size(); i++) {
- const Descriptor* d = classes[i];
- if (d && !public_set.count(d->file()))
+ absl::btree_map<std::string, ForwardDeclarations> decls;
+ for (const auto* d : classes) {
+ if (d != nullptr && !public_set.count(d->file()))
decls[Namespace(d, options_)].AddMessage(d);
}
- for (int i = 0; i < enums.size(); i++) {
- const EnumDescriptor* d = enums[i];
- if (d && !public_set.count(d->file()))
- decls[Namespace(d, options_)].AddEnum(d);
+ for (const auto* e : enums) {
+ if (e != nullptr && !public_set.count(e->file()))
+ decls[Namespace(e, options_)].AddEnum(e);
}
for (const auto& mg : message_generators_) {
const Descriptor* d = mg->descriptor_;
- if ((d != nullptr) && (public_set.count(d->file()) == 0u) &&
+ if (d != nullptr && public_set.count(d->file()) == 0u &&
ShouldSplit(mg->descriptor_, options_))
decls[Namespace(d, options_)].AddSplit(d);
}
- {
- NamespaceOpener ns(format);
- for (const auto& pair : decls) {
- ns.ChangeTo(pair.first);
- pair.second.Print(format, options_);
- }
+ NamespaceOpener ns(p);
+ for (const auto& decl : decls) {
+ ns.ChangeTo(decl.first);
+ decl.second.Print(p, options_);
}
- format("PROTOBUF_NAMESPACE_OPEN\n");
- for (const auto& pair : decls) {
- pair.second.PrintTopLevelDecl(format, options_);
+
+ ns.ChangeTo("PROTOBUF_NAMESPACE_ID");
+ for (const auto& decl : decls) {
+ decl.second.PrintTopLevelDecl(p, options_);
}
- format("PROTOBUF_NAMESPACE_CLOSE\n");
}
-void FileGenerator::GenerateTopHeaderGuard(
- io::Printer* printer, google::protobuf::compiler::cpp::GeneratedFileType file_type) {
- Formatter format(printer, variables_);
- // Generate top of header.
- format(
- "// Generated by the protocol buffer compiler. DO NOT EDIT!\n"
- "// source: $filename$\n"
- "\n"
- "#ifndef $1$\n"
- "#define $1$\n"
- "\n"
- "#include <limits>\n"
- "#include <string>\n",
- IncludeGuard(file_, file_type, options_));
- if (!options_.opensource_runtime && !enum_generators_.empty()) {
- // Add header to provide std::is_integral for safe Enum_Name() function.
- format("#include <type_traits>\n");
- }
- format("\n");
-}
-
-void FileGenerator::GenerateBottomHeaderGuard(
- io::Printer* printer, google::protobuf::compiler::cpp::GeneratedFileType file_type) {
- Formatter format(printer, variables_);
- format("#endif // $GOOGLE_PROTOBUF$_INCLUDED_$1$\n",
- IncludeGuard(file_, file_type, options_));
-}
-
-void FileGenerator::GenerateLibraryIncludes(io::Printer* printer) {
- Formatter format(printer, variables_);
+void FileGenerator::GenerateLibraryIncludes(io::Printer* p) {
if (UsingImplicitWeakFields(file_, options_)) {
- IncludeFile("net/proto2/public/implicit_weak_message.h", printer);
+ IncludeFile("net/proto2/public/implicit_weak_message.h", p);
}
if (HasWeakFields(file_, options_)) {
GOOGLE_CHECK(!options_.opensource_runtime);
- IncludeFile("net/proto2/public/weak_field_map.h", printer);
+ IncludeFile("net/proto2/public/weak_field_map.h", p);
}
if (HasLazyFields(file_, options_, &scc_analyzer_)) {
GOOGLE_CHECK(!options_.opensource_runtime);
- IncludeFile("net/proto2/public/lazy_field.h", printer);
+ IncludeFile("net/proto2/public/lazy_field.h", p);
}
if (ShouldVerify(file_, options_, &scc_analyzer_)) {
- IncludeFile("net/proto2/public/wire_format_verify.h", printer);
+ IncludeFile("net/proto2/public/wire_format_verify.h", p);
}
if (options_.opensource_runtime) {
// Verify the protobuf library header version is compatible with the protoc
// version before going any further.
- IncludeFile("net/proto2/public/port_def.inc", printer);
- format(
- "#if PROTOBUF_VERSION < $1$\n"
- "#error This file was generated by a newer version of protoc which is\n"
- "#error incompatible with your Protocol Buffer headers. Please update\n"
- "#error your headers.\n"
- "#endif\n"
- "#if $2$ < PROTOBUF_MIN_PROTOC_VERSION\n"
- "#error This file was generated by an older version of protoc which "
- "is\n"
- "#error incompatible with your Protocol Buffer headers. Please\n"
- "#error regenerate this file with a newer version of protoc.\n"
- "#endif\n"
- "\n",
- PROTOBUF_MIN_HEADER_VERSION_FOR_PROTOC, // 1
- PROTOBUF_VERSION); // 2
- IncludeFile("net/proto2/public/port_undef.inc", printer);
+ IncludeFile("net/proto2/public/port_def.inc", p);
+ p->Emit(
+ {
+ {"min_version",
+ absl::StrCat(PROTOBUF_MIN_HEADER_VERSION_FOR_PROTOC)},
+ {"version", absl::StrCat(PROTOBUF_VERSION)},
+ },
+ R"(
+ #if PROTOBUF_VERSION < $min_version$
+ #error "This file was generated by a newer version of protoc which is"
+ #error "incompatible with your Protocol Buffer headers. Please update"
+ #error "your headers."
+ #endif // PROTOBUF_VERSION
+
+ #if $version$ < PROTOBUF_MIN_PROTOC_VERSION
+ #error "This file was generated by an older version of protoc which is"
+ #error "incompatible with your Protocol Buffer headers. Please"
+ #error "regenerate this file with a newer version of protoc."
+ #endif // PROTOBUF_MIN_PROTOC_VERSION
+ )");
+ IncludeFile("net/proto2/public/port_undef.inc", p);
}
// OK, it's now safe to #include other files.
- IncludeFile("net/proto2/io/public/coded_stream.h", printer);
- IncludeFile("net/proto2/public/arena.h", printer);
- IncludeFile("net/proto2/public/arenastring.h", printer);
+ IncludeFile("net/proto2/io/public/coded_stream.h", p);
+ IncludeFile("net/proto2/public/arena.h", p);
+ IncludeFile("net/proto2/public/arenastring.h", p);
if ((options_.force_inline_string || options_.profile_driven_inline_string) &&
!options_.opensource_runtime) {
- IncludeFile("net/proto2/public/inlined_string_field.h", printer);
+ IncludeFile("net/proto2/public/inlined_string_field.h", p);
}
if (HasSimpleBaseClasses(file_, options_)) {
- IncludeFile("net/proto2/public/generated_message_bases.h", printer);
+ IncludeFile("net/proto2/public/generated_message_bases.h", p);
}
if (HasGeneratedMethods(file_, options_) &&
options_.tctable_mode != Options::kTCTableNever) {
- IncludeFile("net/proto2/public/generated_message_tctable_decl.h", printer);
+ IncludeFile("net/proto2/public/generated_message_tctable_decl.h", p);
}
- IncludeFile("net/proto2/public/generated_message_util.h", printer);
- IncludeFile("net/proto2/public/metadata_lite.h", printer);
+ IncludeFile("net/proto2/public/generated_message_util.h", p);
+ IncludeFile("net/proto2/public/metadata_lite.h", p);
if (HasDescriptorMethods(file_, options_)) {
- IncludeFile("net/proto2/public/generated_message_reflection.h", printer);
+ IncludeFile("net/proto2/public/generated_message_reflection.h", p);
}
if (!message_generators_.empty()) {
if (HasDescriptorMethods(file_, options_)) {
- IncludeFile("net/proto2/public/message.h", printer);
+ IncludeFile("net/proto2/public/message.h", p);
} else {
- IncludeFile("net/proto2/public/message_lite.h", printer);
+ IncludeFile("net/proto2/public/message_lite.h", p);
}
}
if (options_.opensource_runtime) {
// Open-source relies on unconditional includes of these.
- IncludeFileAndExport("net/proto2/public/repeated_field.h", printer);
- IncludeFileAndExport("net/proto2/public/extension_set.h", printer);
+ IncludeFileAndExport("net/proto2/public/repeated_field.h", p);
+ IncludeFileAndExport("net/proto2/public/extension_set.h", p);
} else {
// Google3 includes these files only when they are necessary.
if (HasExtensionsOrExtendableMessage(file_)) {
- IncludeFileAndExport("net/proto2/public/extension_set.h", printer);
+ IncludeFileAndExport("net/proto2/public/extension_set.h", p);
}
if (HasRepeatedFields(file_)) {
- IncludeFileAndExport("net/proto2/public/repeated_field.h", printer);
+ IncludeFileAndExport("net/proto2/public/repeated_field.h", p);
}
if (HasStringPieceFields(file_, options_)) {
- IncludeFile("net/proto2/public/string_piece_field_support.h", printer);
+ IncludeFile("net/proto2/public/string_piece_field_support.h", p);
}
if (HasCordFields(file_, options_)) {
- format("#include \"third_party/absl/strings/cord.h\"\n");
+ p->Emit(R"(
+ #include "third_party/absl/strings/cord.h"
+ )");
}
}
if (HasMapFields(file_)) {
- IncludeFileAndExport("net/proto2/public/map.h", printer);
+ IncludeFileAndExport("net/proto2/public/map.h", p);
if (HasDescriptorMethods(file_, options_)) {
- IncludeFile("net/proto2/public/map_entry.h", printer);
- IncludeFile("net/proto2/public/map_field_inl.h", printer);
+ IncludeFile("net/proto2/public/map_entry.h", p);
+ IncludeFile("net/proto2/public/map_field_inl.h", p);
} else {
- IncludeFile("net/proto2/public/map_entry_lite.h", printer);
- IncludeFile("net/proto2/public/map_field_lite.h", printer);
+ IncludeFile("net/proto2/public/map_entry_lite.h", p);
+ IncludeFile("net/proto2/public/map_field_lite.h", p);
}
}
if (HasEnumDefinitions(file_)) {
if (HasDescriptorMethods(file_, options_)) {
- IncludeFile("net/proto2/public/generated_enum_reflection.h", printer);
+ IncludeFile("net/proto2/public/generated_enum_reflection.h", p);
} else {
- IncludeFile("net/proto2/public/generated_enum_util.h", printer);
+ IncludeFile("net/proto2/public/generated_enum_util.h", p);
}
}
if (HasGenericServices(file_, options_)) {
- IncludeFile("net/proto2/public/service.h", printer);
+ IncludeFile("net/proto2/public/service.h", p);
}
if (UseUnknownFieldSet(file_, options_) && !message_generators_.empty()) {
- IncludeFile("net/proto2/public/unknown_field_set.h", printer);
+ IncludeFile("net/proto2/public/unknown_field_set.h", p);
}
}
-void FileGenerator::GenerateMetadataPragma(io::Printer* printer,
- const std::string& info_path) {
- Formatter format(printer, variables_);
- if (!info_path.empty() && !options_.annotation_pragma_name.empty() &&
- !options_.annotation_guard_name.empty()) {
- format.Set("guard", options_.annotation_guard_name);
- format.Set("pragma", options_.annotation_pragma_name);
- format.Set("info_path", info_path);
- format(
- "#ifdef $guard$\n"
- "#pragma $pragma$ \"$info_path$\"\n"
- "#endif // $guard$\n");
+void FileGenerator::GenerateMetadataPragma(io::Printer* p,
+ absl::string_view info_path) {
+ if (info_path.empty() || options_.annotation_pragma_name.empty() ||
+ options_.annotation_guard_name.empty()) {
+ return;
}
+
+ p->Emit(
+ {
+ {"guard", options_.annotation_guard_name},
+ {"pragma", options_.annotation_pragma_name},
+ {"info_path", std::string(info_path)},
+ },
+ R"(
+ #ifdef $guard$
+ #pragma $pragma$ "$info_path$"
+ #endif // $guard$
+ )");
}
-void FileGenerator::GenerateDependencyIncludes(io::Printer* printer) {
- Formatter format(printer, variables_);
- for (int i = 0; i < file_->dependency_count(); i++) {
- std::string basename = StripProto(file_->dependency(i)->name());
+void FileGenerator::GenerateDependencyIncludes(io::Printer* p) {
+ for (int i = 0; i < file_->dependency_count(); ++i) {
+ const FileDescriptor* dep = file_->dependency(i);
// Do not import weak deps.
- if (IsDepWeak(file_->dependency(i))) continue;
+ if (IsDepWeak(dep)) {
+ continue;
+ }
+ std::string basename = StripProto(dep->name());
if (IsBootstrapProto(options_, file_)) {
GetBootstrapBasename(options_, basename, &basename);
}
- format("#include $1$\n",
- CreateHeaderInclude(basename + ".pb.h", file_->dependency(i)));
+ p->Emit(
+ {{"name", CreateHeaderInclude(absl::StrCat(basename, ".pb.h"), dep)}},
+ R"(
+ #include $name$
+ )");
}
}
-void FileGenerator::GenerateGlobalStateFunctionDeclarations(
- io::Printer* printer) {
- Formatter format(printer, variables_);
+void FileGenerator::GenerateGlobalStateFunctionDeclarations(io::Printer* p) {
// Forward-declare the DescriptorTable because this is referenced by .pb.cc
// files depending on this file.
//
@@ -1272,114 +1402,102 @@
// weak fields must refer to table struct but cannot include the header.
// Also it annotates extra weak attributes.
// TODO(gerbens) make sure this situation is handled better.
- format(
- "\n"
- "// Internal implementation detail -- do not use these members.\n"
- "struct $dllexport_decl $$tablename$ {\n"
- " static const $uint32$ offsets[];\n"
- "};\n");
+ p->Emit(R"cc(
+ // Internal implementation detail -- do not use these members.
+ struct $dllexport_decl $$tablename$ {
+ static const uint32_t offsets[];
+ };
+ )cc");
+
if (HasDescriptorMethods(file_, options_)) {
- format(
- "$dllexport_decl $extern const ::$proto_ns$::internal::DescriptorTable "
- "$desc_table$;\n");
+ p->Emit(R"cc(
+ $dllexport_decl $extern const ::$proto_ns$::internal::DescriptorTable
+ $desc_table$;
+ )cc");
}
}
-void FileGenerator::GenerateMessageDefinitions(io::Printer* printer) {
- Formatter format(printer, variables_);
- // Generate class definitions.
- for (int i = 0; i < message_generators_.size(); i++) {
- if (i > 0) {
- format("\n");
- format(kThinSeparator);
- format("\n");
- }
- message_generators_[i]->GenerateClassDefinition(printer);
+void FileGenerator::GenerateMessageDefinitions(io::Printer* p) {
+ for (int i = 0; i < message_generators_.size(); ++i) {
+ p->Emit(R"cc(
+ $hrule_thin$
+ )cc");
+ message_generators_[i]->GenerateClassDefinition(p);
}
}
-void FileGenerator::GenerateEnumDefinitions(io::Printer* printer) {
- // Generate enum definitions.
- for (int i = 0; i < enum_generators_.size(); i++) {
- enum_generators_[i]->GenerateDefinition(printer);
+void FileGenerator::GenerateEnumDefinitions(io::Printer* p) {
+ for (int i = 0; i < enum_generators_.size(); ++i) {
+ enum_generators_[i]->GenerateDefinition(p);
}
}
-void FileGenerator::GenerateServiceDefinitions(io::Printer* printer) {
- Formatter format(printer, variables_);
- if (HasGenericServices(file_, options_)) {
- // Generate service definitions.
- for (int i = 0; i < service_generators_.size(); i++) {
- if (i > 0) {
- format("\n");
- format(kThinSeparator);
- format("\n");
- }
- service_generators_[i]->GenerateDeclarations(printer);
- }
-
- format("\n");
- format(kThickSeparator);
- format("\n");
+void FileGenerator::GenerateServiceDefinitions(io::Printer* p) {
+ if (!HasGenericServices(file_, options_)) {
+ return;
}
+
+ for (int i = 0; i < service_generators_.size(); ++i) {
+ p->Emit(R"cc(
+ $hrule_thin$
+ )cc");
+ service_generators_[i]->GenerateDeclarations(p);
+ }
+
+ p->Emit(R"cc(
+ $hrule_thick$
+ )cc");
}
-void FileGenerator::GenerateExtensionIdentifiers(io::Printer* printer) {
+void FileGenerator::GenerateExtensionIdentifiers(io::Printer* p) {
// Declare extension identifiers. These are in global scope and so only
// the global scope extensions.
for (auto& extension_generator : extension_generators_) {
- if (extension_generator->IsScoped()) continue;
- extension_generator->GenerateDeclaration(printer);
+ if (extension_generator->IsScoped()) {
+ continue;
+ }
+ extension_generator->GenerateDeclaration(p);
}
}
-void FileGenerator::GenerateInlineFunctionDefinitions(io::Printer* printer) {
- Formatter format(printer, variables_);
+void FileGenerator::GenerateInlineFunctionDefinitions(io::Printer* p) {
// TODO(gerbens) remove pragmas when gcc is no longer used. Current version
// of gcc fires a bogus error when compiled with strict-aliasing.
- format(
- "#ifdef __GNUC__\n"
- " #pragma GCC diagnostic push\n"
- " #pragma GCC diagnostic ignored \"-Wstrict-aliasing\"\n"
- "#endif // __GNUC__\n");
- // Generate class inline methods.
- for (int i = 0; i < message_generators_.size(); i++) {
- if (i > 0) {
- format(kThinSeparator);
- format("\n");
- }
- message_generators_[i]->GenerateInlineMethods(printer);
- }
- format(
- "#ifdef __GNUC__\n"
- " #pragma GCC diagnostic pop\n"
- "#endif // __GNUC__\n");
+ p->Emit(R"(
+ #ifdef __GNUC__
+ #pragma GCC diagnostic push
+ #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+ #endif // __GNUC__
+ )");
- for (int i = 0; i < message_generators_.size(); i++) {
- if (i > 0) {
- format(kThinSeparator);
- format("\n");
- }
+ for (int i = 0; i < message_generators_.size(); ++i) {
+ p->Emit(R"cc(
+ $hrule_thin$
+ )cc");
+ message_generators_[i]->GenerateInlineMethods(p);
}
+
+ p->Emit(R"(
+ #ifdef __GNUC__
+ #pragma GCC diagnostic pop
+ #endif // __GNUC__
+ )");
}
-void FileGenerator::GenerateProto2NamespaceEnumSpecializations(
- io::Printer* printer) {
- Formatter format(printer, variables_);
- // Emit GetEnumDescriptor specializations into google::protobuf namespace:
- if (HasEnumDefinitions(file_)) {
- format("\n");
- {
- NamespaceOpener proto_ns(ProtobufNamespace(options_), format);
- format("\n");
- for (int i = 0; i < enum_generators_.size(); i++) {
- enum_generators_[i]->GenerateGetEnumDescriptorSpecializations(printer);
- }
- format("\n");
- }
+void FileGenerator::GenerateProto2NamespaceEnumSpecializations(io::Printer* p) {
+ // Emit GetEnumDescriptor specializations into google::protobuf namespace.
+ if (!HasEnumDefinitions(file_)) {
+ return;
}
-}
+ p->PrintRaw("\n");
+ NamespaceOpener ns(ProtobufNamespace(options_), p);
+ p->PrintRaw("\n");
+ for (auto& gen : enum_generators_) {
+ gen->GenerateGetEnumDescriptorSpecializations(p);
+ }
+ p->PrintRaw("\n");
+}
} // namespace cpp
} // namespace compiler
} // namespace protobuf
diff --git a/src/google/protobuf/compiler/cpp/file.h b/src/google/protobuf/compiler/cpp/file.h
index 072b913..cd38345 100644
--- a/src/google/protobuf/compiler/cpp/file.h
+++ b/src/google/protobuf/compiler/cpp/file.h
@@ -36,55 +36,47 @@
#define GOOGLE_PROTOBUF_COMPILER_CPP_FILE_H__
#include <algorithm>
+#include <functional>
#include <memory>
#include <set>
#include <string>
#include <vector>
#include "google/protobuf/stubs/common.h"
+#include "google/protobuf/compiler/scc.h"
+#include "absl/container/flat_hash_set.h"
+#include "google/protobuf/compiler/cpp/enum.h"
+#include "google/protobuf/compiler/cpp/extension.h"
#include "google/protobuf/compiler/cpp/field.h"
#include "google/protobuf/compiler/cpp/helpers.h"
-#include "google/protobuf/port.h"
-#include "google/protobuf/compiler/scc.h"
+#include "google/protobuf/compiler/cpp/message.h"
#include "google/protobuf/compiler/cpp/options.h"
+#include "google/protobuf/compiler/cpp/service.h"
+#include "google/protobuf/descriptor.h"
+#include "google/protobuf/io/printer.h"
+#include "google/protobuf/port.h"
-namespace google {
-namespace protobuf {
-class FileDescriptor; // descriptor.h
-namespace io {
-class Printer; // printer.h
-}
-} // namespace protobuf
-} // namespace google
namespace google {
namespace protobuf {
namespace compiler {
namespace cpp {
-
-class EnumGenerator; // enum.h
-class MessageGenerator; // message.h
-class ServiceGenerator; // service.h
-class ExtensionGenerator; // extension.h
-
class FileGenerator {
public:
- // See generator.cc for the meaning of dllexport_decl.
FileGenerator(const FileDescriptor* file, const Options& options);
+
FileGenerator(const FileGenerator&) = delete;
FileGenerator& operator=(const FileGenerator&) = delete;
- ~FileGenerator();
- // Shared code between the two header generators below.
- void GenerateHeader(io::Printer* printer);
+ ~FileGenerator() = default;
// info_path, if non-empty, should be the path (relative to printer's
// output) to the metadata file describing this proto header.
- void GenerateProtoHeader(io::Printer* printer, const std::string& info_path);
+ void GenerateProtoHeader(io::Printer* p, absl::string_view info_path);
// info_path, if non-empty, should be the path (relative to printer's
// output) to the metadata file describing this PB header.
- void GeneratePBHeader(io::Printer* printer, const std::string& info_path);
- void GenerateSource(io::Printer* printer);
+ void GeneratePBHeader(io::Printer* p, absl::string_view info_path);
+ void GenerateSource(io::Printer* p);
// The following member functions are used when the lite_implicit_weak_fields
// option is set. In this mode the code is organized a bit differently to
@@ -95,80 +87,86 @@
int NumMessages() const { return message_generators_.size(); }
int NumExtensions() const { return extension_generators_.size(); }
// Generates the source file for one message.
- void GenerateSourceForMessage(int idx, io::Printer* printer);
+ void GenerateSourceForMessage(int idx, io::Printer* p);
// Generates the source file for one extension.
- void GenerateSourceForExtension(int idx, io::Printer* printer);
+ void GenerateSourceForExtension(int idx, io::Printer* p);
// Generates a source file containing everything except messages and
// extensions.
- void GenerateGlobalSource(io::Printer* printer);
+ void GenerateGlobalSource(io::Printer* p);
private:
+ // Generates a file, setting up the necessary accoutrements that start and
+ // end the file, calling `cb` in between.
+ //
+ // This includes header guards and file-global variables.
+ void GenerateFile(io::Printer* p, GeneratedFileType file_type,
+ std::function<void()> cb);
+
+ // Shared code between the two header generators.
+ void GenerateSharedHeaderCode(io::Printer* p);
+
// Internal type used by GenerateForwardDeclarations (defined in file.cc).
class ForwardDeclarations;
struct CrossFileReferences;
- void IncludeFile(const std::string& google3_name, io::Printer* printer) {
- DoIncludeFile(google3_name, false, printer);
+ void IncludeFile(absl::string_view google3_name, io::Printer* p) {
+ DoIncludeFile(google3_name, false, p);
}
- void IncludeFileAndExport(const std::string& google3_name,
- io::Printer* printer) {
- DoIncludeFile(google3_name, true, printer);
+ void IncludeFileAndExport(absl::string_view google3_name, io::Printer* p) {
+ DoIncludeFile(google3_name, true, p);
}
- void DoIncludeFile(const std::string& google3_name, bool do_export,
- io::Printer* printer);
+ void DoIncludeFile(absl::string_view google3_name, bool do_export,
+ io::Printer* p);
- std::string CreateHeaderInclude(const std::string& basename,
+ std::string CreateHeaderInclude(absl::string_view basename,
const FileDescriptor* file);
void GetCrossFileReferencesForField(const FieldDescriptor* field,
CrossFileReferences* refs);
void GetCrossFileReferencesForFile(const FileDescriptor* file,
CrossFileReferences* refs);
void GenerateInternalForwardDeclarations(const CrossFileReferences& refs,
- io::Printer* printer);
- void GenerateSourceIncludes(io::Printer* printer);
- void GenerateSourcePrelude(io::Printer* printer);
- void GenerateSourceDefaultInstance(int idx, io::Printer* printer);
+ io::Printer* p);
+ void GenerateSourceIncludes(io::Printer* p);
+ void GenerateSourcePrelude(io::Printer* p);
+ void GenerateSourceDefaultInstance(int idx, io::Printer* p);
void GenerateInitForSCC(const SCC* scc, const CrossFileReferences& refs,
- io::Printer* printer);
- void GenerateReflectionInitializationCode(io::Printer* printer);
+ io::Printer* p);
+ void GenerateReflectionInitializationCode(io::Printer* p);
// For other imports, generates their forward-declarations.
- void GenerateForwardDeclarations(io::Printer* printer);
+ void GenerateForwardDeclarations(io::Printer* p);
// Generates top or bottom of a header file.
- void GenerateTopHeaderGuard(
- io::Printer* printer, google::protobuf::compiler::cpp::GeneratedFileType file_type);
- void GenerateBottomHeaderGuard(
- io::Printer* printer, google::protobuf::compiler::cpp::GeneratedFileType file_type);
+ void GenerateTopHeaderGuard(io::Printer* p, GeneratedFileType file_type);
+ void GenerateBottomHeaderGuard(io::Printer* p, GeneratedFileType file_type);
// Generates #include directives.
- void GenerateLibraryIncludes(io::Printer* printer);
- void GenerateDependencyIncludes(io::Printer* printer);
+ void GenerateLibraryIncludes(io::Printer* p);
+ void GenerateDependencyIncludes(io::Printer* p);
// Generate a pragma to pull in metadata using the given info_path (if
// non-empty). info_path should be relative to printer's output.
- void GenerateMetadataPragma(io::Printer* printer,
- const std::string& info_path);
+ void GenerateMetadataPragma(io::Printer* p, absl::string_view info_path);
// Generates a couple of different pieces before definitions:
- void GenerateGlobalStateFunctionDeclarations(io::Printer* printer);
+ void GenerateGlobalStateFunctionDeclarations(io::Printer* p);
// Generates types for classes.
- void GenerateMessageDefinitions(io::Printer* printer);
+ void GenerateMessageDefinitions(io::Printer* p);
- void GenerateEnumDefinitions(io::Printer* printer);
+ void GenerateEnumDefinitions(io::Printer* p);
// Generates generic service definitions.
- void GenerateServiceDefinitions(io::Printer* printer);
+ void GenerateServiceDefinitions(io::Printer* p);
// Generates extension identifiers.
- void GenerateExtensionIdentifiers(io::Printer* printer);
+ void GenerateExtensionIdentifiers(io::Printer* p);
// Generates inline function definitions.
- void GenerateInlineFunctionDefinitions(io::Printer* printer);
+ void GenerateInlineFunctionDefinitions(io::Printer* p);
- void GenerateProto2NamespaceEnumSpecializations(io::Printer* printer);
+ void GenerateProto2NamespaceEnumSpecializations(io::Printer* p);
// Sometimes the names we use in a .proto file happen to be defined as
// macros on some platforms (e.g., macro/minor used in plugin.proto are
@@ -177,7 +175,7 @@
// undef the macro for these few platforms, or rename the field name for all
// platforms. Since these names are part of protobuf public API, renaming is
// generally a breaking change so we prefer the #undef approach.
- void GenerateMacroUndefs(io::Printer* printer);
+ void GenerateMacroUndefs(io::Printer* p);
bool IsDepWeak(const FileDescriptor* dep) const {
if (weak_deps_.count(dep) != 0) {
@@ -187,13 +185,16 @@
return false;
}
- std::set<const FileDescriptor*> weak_deps_;
+ absl::flat_hash_set<const FileDescriptor*> weak_deps_;
const FileDescriptor* file_;
- const Options options_;
+ Options options_;
MessageSCCAnalyzer scc_analyzer_;
+ // This member is unused and should be deleted once all old-style variable
+ // maps are gone.
+ // TODO(b/245791219)
std::map<std::string, std::string> variables_;
// Contains the post-order walk of all the messages (and child messages) in
diff --git a/src/google/protobuf/compiler/cpp/generator.cc b/src/google/protobuf/compiler/cpp/generator.cc
index 3c25ec8..8403312 100644
--- a/src/google/protobuf/compiler/cpp/generator.cc
+++ b/src/google/protobuf/compiler/cpp/generator.cc
@@ -70,6 +70,9 @@
{"uint32", "uint32_t"},
{"uint64", "uint64_t"},
+ {"hrule_thick", kThickSeparator},
+ {"hrule_thin", kThinSeparator},
+
// Warning: there is some clever naming/splitting here to avoid extract
// script rewrites. The names of these variables must not be things that
// the extract script will rewrite. That's why we use "CHK" (for example)
@@ -83,9 +86,11 @@
: "GOOGLE3_PROTOBU"
"F"},
{"CHK", is_oss ? "GOOGLE_CHECK"
- : "CHECK"},
+ : "CHEC"
+ "K"},
{"DCHK", is_oss ? "GOOGLE_DCHECK"
- : "DCHECK"},
+ : "DCHEC"
+ "K"},
};
}
} // namespace
diff --git a/src/google/protobuf/compiler/cpp/helpers.cc b/src/google/protobuf/compiler/cpp/helpers.cc
index bba2ff5..c89a48d 100644
--- a/src/google/protobuf/compiler/cpp/helpers.cc
+++ b/src/google/protobuf/compiler/cpp/helpers.cc
@@ -43,6 +43,7 @@
#include <queue>
#include <set>
#include <string>
+#include <utility>
#include <vector>
#include "google/protobuf/stubs/common.h"
@@ -1087,6 +1088,46 @@
return well_known_files->find(file->name()) != well_known_files->end();
}
+void NamespaceOpener::ChangeTo(absl::string_view name) {
+ std::vector<std::string> new_stack =
+ absl::StrSplit(name, "::", absl::SkipEmpty());
+ size_t len = std::min(name_stack_.size(), new_stack.size());
+ size_t common_idx = 0;
+ while (common_idx < len) {
+ if (name_stack_[common_idx] != new_stack[common_idx]) {
+ break;
+ }
+ ++common_idx;
+ }
+
+ for (size_t i = name_stack_.size(); i > common_idx; i--) {
+ const auto& ns = name_stack_[i - 1];
+ if (ns == "PROTOBUF_NAMESPACE_ID") {
+ p_->Emit(R"cc(
+ PROTOBUF_NAMESPACE_CLOSE
+ )cc");
+ } else {
+ p_->Emit({{"ns", ns}}, R"(
+ } // namespace $ns$
+ )");
+ }
+ }
+ for (size_t i = common_idx; i < new_stack.size(); ++i) {
+ const auto& ns = new_stack[i];
+ if (ns == "PROTOBUF_NAMESPACE_ID") {
+ p_->Emit(R"cc(
+ PROTOBUF_NAMESPACE_OPEN
+ )cc");
+ } else {
+ p_->Emit({{"ns", ns}}, R"(
+ namespace $ns$ {
+ )");
+ }
+ }
+
+ name_stack_ = std::move(new_stack);
+}
+
static void GenerateUtf8CheckCode(const FieldDescriptor* field,
const Options& options, bool for_parse,
const char* parameters,
diff --git a/src/google/protobuf/compiler/cpp/helpers.h b/src/google/protobuf/compiler/cpp/helpers.h
index 19120e3..251214f 100644
--- a/src/google/protobuf/compiler/cpp/helpers.h
+++ b/src/google/protobuf/compiler/cpp/helpers.h
@@ -44,7 +44,7 @@
#include "google/protobuf/compiler/scc.h"
#include "google/protobuf/compiler/code_generator.h"
#include "absl/container/flat_hash_map.h"
-#include "google/protobuf/stubs/strutil.h"
+#include "absl/strings/match.h"
#include "absl/strings/str_split.h"
#include "google/protobuf/compiler/cpp/names.h"
#include "google/protobuf/compiler/cpp/options.h"
@@ -52,6 +52,7 @@
#include "google/protobuf/io/printer.h"
#include "google/protobuf/descriptor.h"
#include "google/protobuf/port.h"
+#include "google/protobuf/stubs/strutil.h"
#include "absl/strings/str_cat.h"
// Must be included last.
@@ -887,43 +888,21 @@
class PROTOC_EXPORT NamespaceOpener {
public:
- explicit NamespaceOpener(const Formatter& format)
- : printer_(format.printer()) {}
- NamespaceOpener(const std::string& name, const Formatter& format)
+ explicit NamespaceOpener(io::Printer* p) : p_(p) {}
+ explicit NamespaceOpener(const Formatter& format) : p_(format.printer()) {}
+ NamespaceOpener(absl::string_view name, const Formatter& format)
: NamespaceOpener(format) {
ChangeTo(name);
}
+ NamespaceOpener(absl::string_view name, io::Printer* p) : NamespaceOpener(p) {
+ ChangeTo(name);
+ }
~NamespaceOpener() { ChangeTo(""); }
- void ChangeTo(const std::string& name) {
- std::vector<std::string> new_stack_ =
- absl::StrSplit(name, "::", absl::SkipEmpty());
- size_t len = std::min(name_stack_.size(), new_stack_.size());
- size_t common_idx = 0;
- while (common_idx < len) {
- if (name_stack_[common_idx] != new_stack_[common_idx]) break;
- common_idx++;
- }
- for (auto it = name_stack_.crbegin();
- it != name_stack_.crend() - common_idx; ++it) {
- if (*it == "PROTOBUF_NAMESPACE_ID") {
- printer_->Print("PROTOBUF_NAMESPACE_CLOSE\n");
- } else {
- printer_->Print("} // namespace $ns$\n", "ns", *it);
- }
- }
- name_stack_.swap(new_stack_);
- for (size_t i = common_idx; i < name_stack_.size(); ++i) {
- if (name_stack_[i] == "PROTOBUF_NAMESPACE_ID") {
- printer_->Print("PROTOBUF_NAMESPACE_OPEN\n");
- } else {
- printer_->Print("namespace $ns$ {\n", "ns", name_stack_[i]);
- }
- }
- }
+ void ChangeTo(absl::string_view name);
private:
- io::Printer* printer_;
+ io::Printer* p_;
std::vector<std::string> name_stack_;
};
diff --git a/src/google/protobuf/compiler/cpp/parse_function_generator.cc b/src/google/protobuf/compiler/cpp/parse_function_generator.cc
index e4f057f..00f4823 100644
--- a/src/google/protobuf/compiler/cpp/parse_function_generator.cc
+++ b/src/google/protobuf/compiler/cpp/parse_function_generator.cc
@@ -630,11 +630,11 @@
std::string func_name = info.func_name;
// For 1-byte tags we have a more optimized version of the varint parser
// that can hardcode the offset and has bit.
- if (HasSuffixString(func_name, "V8S1") ||
- HasSuffixString(func_name, "V32S1") ||
- HasSuffixString(func_name, "V64S1")) {
- std::string field_type = HasSuffixString(func_name, "V8S1") ? "bool"
- : HasSuffixString(func_name, "V32S1")
+ if (absl::EndsWith(func_name, "V8S1") ||
+ absl::EndsWith(func_name, "V32S1") ||
+ absl::EndsWith(func_name, "V64S1")) {
+ std::string field_type = absl::EndsWith(func_name, "V8S1") ? "bool"
+ : absl::EndsWith(func_name, "V32S1")
? "uint32_t"
: "uint64_t";
func_name =
diff --git a/src/google/protobuf/compiler/csharp/csharp_doc_comment.cc b/src/google/protobuf/compiler/csharp/csharp_doc_comment.cc
index 72a4c12..507b826 100644
--- a/src/google/protobuf/compiler/csharp/csharp_doc_comment.cc
+++ b/src/google/protobuf/compiler/csharp/csharp_doc_comment.cc
@@ -33,9 +33,6 @@
// Sanjay Ghemawat, Jeff Dean, and others.
#include "google/protobuf/compiler/csharp/csharp_doc_comment.h"
-#include "google/protobuf/stubs/strutil.h"
-#include "absl/strings/ascii.h"
-#include "absl/strings/escaping.h"
#include "absl/strings/str_replace.h"
#include "absl/strings/str_split.h"
#include "google/protobuf/descriptor.h"
diff --git a/src/google/protobuf/compiler/csharp/csharp_enum.cc b/src/google/protobuf/compiler/csharp/csharp_enum.cc
index 2b2bcf8..846da9b 100644
--- a/src/google/protobuf/compiler/csharp/csharp_enum.cc
+++ b/src/google/protobuf/compiler/csharp/csharp_enum.cc
@@ -33,22 +33,13 @@
#include <sstream>
#include "google/protobuf/compiler/code_generator.h"
-#include "google/protobuf/descriptor.h"
-#include "google/protobuf/stubs/strutil.h"
-#include "absl/strings/ascii.h"
-#include "absl/strings/escaping.h"
-#include "absl/strings/str_split.h"
-#include "absl/strings/str_replace.h"
-#include "absl/strings/ascii.h"
-#include "absl/strings/escaping.h"
-#include "absl/strings/str_replace.h"
-#include "absl/strings/str_split.h"
+#include "absl/strings/str_cat.h"
#include "google/protobuf/compiler/csharp/csharp_doc_comment.h"
#include "google/protobuf/compiler/csharp/csharp_helpers.h"
#include "google/protobuf/compiler/csharp/csharp_options.h"
+#include "google/protobuf/descriptor.h"
#include "google/protobuf/descriptor.pb.h"
#include "google/protobuf/io/printer.h"
-#include "google/protobuf/io/zero_copy_stream.h"
namespace google {
namespace protobuf {
diff --git a/src/google/protobuf/compiler/csharp/csharp_field_base.cc b/src/google/protobuf/compiler/csharp/csharp_field_base.cc
index e808b7d..da205df 100644
--- a/src/google/protobuf/compiler/csharp/csharp_field_base.cc
+++ b/src/google/protobuf/compiler/csharp/csharp_field_base.cc
@@ -37,21 +37,11 @@
#include "google/protobuf/compiler/code_generator.h"
#include "google/protobuf/descriptor.h"
#include "google/protobuf/wire_format.h"
-#include "google/protobuf/stubs/strutil.h"
-#include "absl/strings/ascii.h"
-#include "absl/strings/escaping.h"
-#include "absl/strings/str_split.h"
-#include "absl/strings/str_replace.h"
-#include "absl/strings/ascii.h"
-#include "absl/strings/escaping.h"
-#include "absl/strings/str_replace.h"
-#include "absl/strings/str_split.h"
#include "google/protobuf/compiler/csharp/csharp_helpers.h"
#include "google/protobuf/compiler/csharp/csharp_names.h"
#include "google/protobuf/descriptor.pb.h"
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/io/printer.h"
-#include "google/protobuf/io/zero_copy_stream.h"
// Must be last.
#include "google/protobuf/port_def.inc"
diff --git a/src/google/protobuf/compiler/csharp/csharp_field_base.h b/src/google/protobuf/compiler/csharp/csharp_field_base.h
index 9eecde9..b2ad2c2 100644
--- a/src/google/protobuf/compiler/csharp/csharp_field_base.h
+++ b/src/google/protobuf/compiler/csharp/csharp_field_base.h
@@ -32,17 +32,13 @@
#define GOOGLE_PROTOBUF_COMPILER_CSHARP_FIELD_BASE_H__
#include <string>
+
+#include "google/protobuf/compiler/code_generator.h"
#include "google/protobuf/stubs/strutil.h"
#include "absl/strings/ascii.h"
#include "absl/strings/escaping.h"
-#include "absl/strings/str_split.h"
#include "absl/strings/str_replace.h"
-#include "absl/strings/ascii.h"
-#include "absl/strings/escaping.h"
#include "absl/strings/str_split.h"
-#include "absl/strings/str_replace.h"
-
-#include "google/protobuf/compiler/code_generator.h"
#include "google/protobuf/compiler/csharp/csharp_source_generator_base.h"
#include "google/protobuf/descriptor.h"
#include "google/protobuf/io/printer.h"
diff --git a/src/google/protobuf/compiler/csharp/csharp_generator.cc b/src/google/protobuf/compiler/csharp/csharp_generator.cc
index 8a3286e..0dab071 100644
--- a/src/google/protobuf/compiler/csharp/csharp_generator.cc
+++ b/src/google/protobuf/compiler/csharp/csharp_generator.cc
@@ -34,16 +34,6 @@
#include "google/protobuf/compiler/code_generator.h"
#include "google/protobuf/descriptor.h"
-#include "google/protobuf/stubs/strutil.h"
-#include "absl/strings/ascii.h"
-#include "absl/strings/escaping.h"
-#include "absl/strings/str_split.h"
-#include "absl/strings/str_replace.h"
-#include "absl/strings/ascii.h"
-#include "absl/strings/escaping.h"
-#include "absl/strings/str_replace.h"
-#include "absl/strings/str_split.h"
-#include "google/protobuf/compiler/csharp/csharp_helpers.h"
#include "google/protobuf/compiler/csharp/csharp_names.h"
#include "google/protobuf/compiler/csharp/csharp_options.h"
#include "google/protobuf/compiler/csharp/csharp_reflection_class.h"
diff --git a/src/google/protobuf/compiler/csharp/csharp_helpers.cc b/src/google/protobuf/compiler/csharp/csharp_helpers.cc
index dd60eb7..b917d8f 100644
--- a/src/google/protobuf/compiler/csharp/csharp_helpers.cc
+++ b/src/google/protobuf/compiler/csharp/csharp_helpers.cc
@@ -41,9 +41,7 @@
#include "absl/container/flat_hash_set.h"
#include "absl/strings/ascii.h"
-#include "absl/strings/escaping.h"
#include "absl/strings/str_replace.h"
-#include "absl/strings/str_split.h"
#include "absl/strings/string_view.h"
#include "google/protobuf/compiler/csharp/csharp_enum_field.h"
#include "google/protobuf/compiler/csharp/csharp_field_base.h"
@@ -57,8 +55,6 @@
#include "google/protobuf/compiler/csharp/csharp_repeated_primitive_field.h"
#include "google/protobuf/compiler/csharp/csharp_wrapper_field.h"
#include "google/protobuf/descriptor.pb.h"
-#include "google/protobuf/io/printer.h"
-#include "google/protobuf/wire_format.h"
// Must be last.
#include "google/protobuf/port_def.inc"
diff --git a/src/google/protobuf/compiler/csharp/csharp_helpers.h b/src/google/protobuf/compiler/csharp/csharp_helpers.h
index 55660b7..9c48cc8 100644
--- a/src/google/protobuf/compiler/csharp/csharp_helpers.h
+++ b/src/google/protobuf/compiler/csharp/csharp_helpers.h
@@ -39,11 +39,11 @@
#include "google/protobuf/compiler/code_generator.h"
#include "google/protobuf/descriptor.h"
+#include "google/protobuf/port.h"
#include "google/protobuf/stubs/common.h"
#include "google/protobuf/descriptor.pb.h"
#include "google/protobuf/io/printer.h"
#include "google/protobuf/port_def.inc"
-#include "google/protobuf/port.h"
namespace google {
namespace protobuf {
diff --git a/src/google/protobuf/compiler/csharp/csharp_map_field.cc b/src/google/protobuf/compiler/csharp/csharp_map_field.cc
index 34ea3e9..efe87f2 100644
--- a/src/google/protobuf/compiler/csharp/csharp_map_field.cc
+++ b/src/google/protobuf/compiler/csharp/csharp_map_field.cc
@@ -34,20 +34,10 @@
#include "google/protobuf/compiler/code_generator.h"
#include "google/protobuf/descriptor.h"
-#include "google/protobuf/stubs/strutil.h"
-#include "absl/strings/ascii.h"
-#include "absl/strings/escaping.h"
-#include "absl/strings/str_split.h"
-#include "absl/strings/str_replace.h"
-#include "absl/strings/ascii.h"
-#include "absl/strings/escaping.h"
-#include "absl/strings/str_replace.h"
-#include "absl/strings/str_split.h"
#include "google/protobuf/compiler/csharp/csharp_doc_comment.h"
#include "google/protobuf/compiler/csharp/csharp_helpers.h"
#include "google/protobuf/descriptor.pb.h"
#include "google/protobuf/io/printer.h"
-#include "google/protobuf/io/zero_copy_stream.h"
namespace google {
namespace protobuf {
@@ -98,7 +88,7 @@
void MapFieldGenerator::GenerateMergingCode(io::Printer* printer) {
printer->Print(
variables_,
- "$name$_.MergeFrom(other.$name$_);\n");
+ "$name$_.Add(other.$name$_);\n");
}
void MapFieldGenerator::GenerateParsingCode(io::Printer* printer) {
diff --git a/src/google/protobuf/compiler/csharp/csharp_message.cc b/src/google/protobuf/compiler/csharp/csharp_message.cc
index 993e9d6..92fe55d 100644
--- a/src/google/protobuf/compiler/csharp/csharp_message.cc
+++ b/src/google/protobuf/compiler/csharp/csharp_message.cc
@@ -35,27 +35,18 @@
#include <sstream>
#include "google/protobuf/compiler/code_generator.h"
-#include "google/protobuf/descriptor.h"
-#include "google/protobuf/wire_format.h"
-#include "google/protobuf/wire_format_lite.h"
-#include "google/protobuf/stubs/strutil.h"
-#include "absl/strings/ascii.h"
-#include "absl/strings/escaping.h"
-#include "absl/strings/str_split.h"
-#include "absl/strings/str_replace.h"
-#include "absl/strings/ascii.h"
-#include "absl/strings/escaping.h"
-#include "absl/strings/str_replace.h"
-#include "absl/strings/str_split.h"
+#include "absl/strings/str_cat.h"
#include "google/protobuf/compiler/csharp/csharp_doc_comment.h"
#include "google/protobuf/compiler/csharp/csharp_enum.h"
#include "google/protobuf/compiler/csharp/csharp_field_base.h"
#include "google/protobuf/compiler/csharp/csharp_helpers.h"
#include "google/protobuf/compiler/csharp/csharp_names.h"
#include "google/protobuf/compiler/csharp/csharp_options.h"
+#include "google/protobuf/descriptor.h"
#include "google/protobuf/descriptor.pb.h"
#include "google/protobuf/io/printer.h"
-#include "google/protobuf/io/zero_copy_stream.h"
+#include "google/protobuf/wire_format.h"
+#include "google/protobuf/wire_format_lite.h"
// Must be last.
#include "google/protobuf/port_def.inc"
diff --git a/src/google/protobuf/compiler/csharp/csharp_message_field.cc b/src/google/protobuf/compiler/csharp/csharp_message_field.cc
index 9d70bd0..1f30bdc 100644
--- a/src/google/protobuf/compiler/csharp/csharp_message_field.cc
+++ b/src/google/protobuf/compiler/csharp/csharp_message_field.cc
@@ -34,23 +34,11 @@
#include "google/protobuf/compiler/code_generator.h"
#include "google/protobuf/descriptor.h"
-#include "google/protobuf/wire_format.h"
-#include "google/protobuf/wire_format_lite.h"
-#include "google/protobuf/stubs/strutil.h"
-#include "absl/strings/ascii.h"
-#include "absl/strings/escaping.h"
-#include "absl/strings/str_split.h"
-#include "absl/strings/str_replace.h"
-#include "absl/strings/ascii.h"
-#include "absl/strings/escaping.h"
-#include "absl/strings/str_replace.h"
-#include "absl/strings/str_split.h"
#include "google/protobuf/compiler/csharp/csharp_doc_comment.h"
#include "google/protobuf/compiler/csharp/csharp_helpers.h"
#include "google/protobuf/compiler/csharp/csharp_options.h"
#include "google/protobuf/descriptor.pb.h"
#include "google/protobuf/io/printer.h"
-#include "google/protobuf/io/zero_copy_stream.h"
namespace google {
namespace protobuf {
diff --git a/src/google/protobuf/compiler/csharp/csharp_names.h b/src/google/protobuf/compiler/csharp/csharp_names.h
index 61f4b7b..e768811 100644
--- a/src/google/protobuf/compiler/csharp/csharp_names.h
+++ b/src/google/protobuf/compiler/csharp/csharp_names.h
@@ -39,8 +39,6 @@
#define GOOGLE_PROTOBUF_COMPILER_CSHARP_NAMES_H__
#include <string>
-#include "google/protobuf/port.h"
-#include "google/protobuf/stubs/common.h"
#include "google/protobuf/port_def.inc"
diff --git a/src/google/protobuf/compiler/csharp/csharp_primitive_field.cc b/src/google/protobuf/compiler/csharp/csharp_primitive_field.cc
index f42ff90..1467bd3 100644
--- a/src/google/protobuf/compiler/csharp/csharp_primitive_field.cc
+++ b/src/google/protobuf/compiler/csharp/csharp_primitive_field.cc
@@ -33,22 +33,13 @@
#include <sstream>
#include "google/protobuf/compiler/code_generator.h"
-#include "google/protobuf/descriptor.h"
-#include "google/protobuf/stubs/strutil.h"
-#include "absl/strings/ascii.h"
-#include "absl/strings/escaping.h"
-#include "absl/strings/str_split.h"
-#include "absl/strings/str_replace.h"
-#include "absl/strings/ascii.h"
-#include "absl/strings/escaping.h"
-#include "absl/strings/str_replace.h"
-#include "absl/strings/str_split.h"
+#include "absl/strings/str_cat.h"
#include "google/protobuf/compiler/csharp/csharp_doc_comment.h"
#include "google/protobuf/compiler/csharp/csharp_helpers.h"
#include "google/protobuf/compiler/csharp/csharp_options.h"
+#include "google/protobuf/descriptor.h"
#include "google/protobuf/descriptor.pb.h"
#include "google/protobuf/io/printer.h"
-#include "google/protobuf/io/zero_copy_stream.h"
namespace google {
namespace protobuf {
diff --git a/src/google/protobuf/compiler/csharp/csharp_reflection_class.cc b/src/google/protobuf/compiler/csharp/csharp_reflection_class.cc
index b767c9d..95a0056 100644
--- a/src/google/protobuf/compiler/csharp/csharp_reflection_class.cc
+++ b/src/google/protobuf/compiler/csharp/csharp_reflection_class.cc
@@ -33,25 +33,16 @@
#include <sstream>
#include "google/protobuf/compiler/code_generator.h"
-#include "google/protobuf/descriptor.h"
-#include "google/protobuf/stubs/strutil.h"
-#include "absl/strings/ascii.h"
-#include "absl/strings/escaping.h"
-#include "absl/strings/str_split.h"
-#include "absl/strings/str_replace.h"
-#include "absl/strings/ascii.h"
-#include "absl/strings/escaping.h"
-#include "absl/strings/str_replace.h"
-#include "absl/strings/str_split.h"
+#include "absl/strings/str_join.h"
#include "google/protobuf/compiler/csharp/csharp_enum.h"
#include "google/protobuf/compiler/csharp/csharp_field_base.h"
#include "google/protobuf/compiler/csharp/csharp_helpers.h"
#include "google/protobuf/compiler/csharp/csharp_message.h"
#include "google/protobuf/compiler/csharp/csharp_names.h"
#include "google/protobuf/compiler/csharp/csharp_options.h"
+#include "google/protobuf/descriptor.h"
#include "google/protobuf/descriptor.pb.h"
#include "google/protobuf/io/printer.h"
-#include "google/protobuf/io/zero_copy_stream.h"
// Must be last.
#include "google/protobuf/port_def.inc"
diff --git a/src/google/protobuf/compiler/importer.cc b/src/google/protobuf/compiler/importer.cc
index 287b22e..a2de7e5 100644
--- a/src/google/protobuf/compiler/importer.cc
+++ b/src/google/protobuf/compiler/importer.cc
@@ -48,7 +48,7 @@
#include <memory>
#include <vector>
-#include "google/protobuf/stubs/strutil.h"
+#include "absl/strings/match.h"
#include "absl/strings/str_join.h"
#include "absl/strings/str_replace.h"
#include "absl/strings/str_split.h"
@@ -282,7 +282,7 @@
// backslashes are standard. Let's avoid confusion and use only forward
// slashes.
std::string path_str;
- if (HasPrefixString(path, "\\\\")) {
+ if (absl::StartsWith(path, "\\\\")) {
// Avoid converting two leading backslashes.
path_str = "\\\\" + absl::StrReplaceAll(path.substr(2), {{"\\", "/"}});
} else {
@@ -306,8 +306,8 @@
}
static inline bool ContainsParentReference(absl::string_view path) {
- return path == ".." || HasPrefixString(path, "../") ||
- HasSuffixString(path, "/..") || absl::StrContains(path, "/../");
+ return path == ".." || absl::StartsWith(path, "../") ||
+ absl::EndsWith(path, "/..") || absl::StrContains(path, "/../");
}
// Maps a file from an old location to a new one. Typically, old_prefix is
@@ -336,7 +336,7 @@
// We do not allow the file name to use "..".
return false;
}
- if (HasPrefixString(filename, "/") || IsWindowsAbsolutePath(filename)) {
+ if (absl::StartsWith(filename, "/") || IsWindowsAbsolutePath(filename)) {
// This is an absolute path, so it isn't matched by the empty string.
return false;
}
@@ -344,7 +344,7 @@
if (!result->empty()) result->push_back('/');
result->append(std::string(filename));
return true;
- } else if (HasPrefixString(filename, old_prefix)) {
+ } else if (absl::StartsWith(filename, old_prefix)) {
// old_prefix is a prefix of the filename. Is it the whole filename?
if (filename.size() == old_prefix.size()) {
// Yep, it's an exact match.
diff --git a/src/google/protobuf/compiler/java/helpers.cc b/src/google/protobuf/compiler/java/helpers.cc
index 625ff18..680a750 100644
--- a/src/google/protobuf/compiler/java/helpers.cc
+++ b/src/google/protobuf/compiler/java/helpers.cc
@@ -221,7 +221,7 @@
if (i == '_') {
capitalize_next = true;
} else if (capitalize_next) {
- result.push_back(ToUpperCh(i));
+ result.push_back(absl::ascii_toupper(i));
capitalize_next = false;
} else {
result.push_back(i);
@@ -230,20 +230,12 @@
// Lower-case the first letter.
if (lower_first && !result.empty()) {
- result[0] = ToLowerCh(result[0]);
+ result[0] = absl::ascii_tolower(result[0]);
}
return result;
}
-char ToUpperCh(char ch) {
- return (ch >= 'a' && ch <= 'z') ? (ch - 'a' + 'A') : ch;
-}
-
-char ToLowerCh(char ch) {
- return (ch >= 'A' && ch <= 'Z') ? (ch - 'A' + 'a') : ch;
-}
-
std::string UnderscoresToCamelCase(const FieldDescriptor* field) {
return UnderscoresToCamelCase(FieldName(field), false);
}
diff --git a/src/google/protobuf/compiler/java/helpers.h b/src/google/protobuf/compiler/java/helpers.h
index eb16096..6fe43ae 100644
--- a/src/google/protobuf/compiler/java/helpers.h
+++ b/src/google/protobuf/compiler/java/helpers.h
@@ -84,9 +84,6 @@
// first letter.
std::string ToCamelCase(const std::string& input, bool lower_first);
-char ToUpperCh(char ch);
-char ToLowerCh(char ch);
-
// Converts a name to camel-case. If cap_first_letter is true, capitalize the
// first letter.
std::string UnderscoresToCamelCase(const std::string& name,
diff --git a/src/google/protobuf/compiler/mock_code_generator.cc b/src/google/protobuf/compiler/mock_code_generator.cc
index f19cbf5..a4cc9e6 100644
--- a/src/google/protobuf/compiler/mock_code_generator.cc
+++ b/src/google/protobuf/compiler/mock_code_generator.cc
@@ -39,19 +39,18 @@
#include <memory>
#include <vector>
-#include "google/protobuf/stubs/strutil.h"
-
#include "google/protobuf/stubs/logging.h"
#include "google/protobuf/stubs/common.h"
#include "google/protobuf/testing/file.h"
#include "google/protobuf/testing/file.h"
-#include "google/protobuf/testing/file.h"
#include "google/protobuf/compiler/plugin.pb.h"
#include "google/protobuf/descriptor.pb.h"
#include <gtest/gtest.h>
#include "absl/strings/str_join.h"
#include "absl/strings/str_replace.h"
#include "absl/strings/str_split.h"
+#include "absl/strings/string_view.h"
+#include "absl/strings/strip.h"
#include "absl/strings/substitute.h"
#include "google/protobuf/descriptor.h"
#include "google/protobuf/io/printer.h"
@@ -208,8 +207,8 @@
std::string* error) const {
bool annotate = false;
for (int i = 0; i < file->message_type_count(); i++) {
- if (HasPrefixString(file->message_type(i)->name(), "MockCodeGenerator_")) {
- std::string command = StripPrefixString(
+ if (absl::StartsWith(file->message_type(i)->name(), "MockCodeGenerator_")) {
+ absl::string_view command = absl::StripPrefix(
file->message_type(i)->name(), "MockCodeGenerator_");
if (command == "Error") {
*error = "Saw message type MockCodeGenerator_Error.";
@@ -252,12 +251,12 @@
}
}
- bool insert_endlines = HasPrefixString(parameter, "insert_endlines=");
- if (insert_endlines || HasPrefixString(parameter, "insert=")) {
+ bool insert_endlines = absl::StartsWith(parameter, "insert_endlines=");
+ if (insert_endlines || absl::StartsWith(parameter, "insert=")) {
std::vector<std::string> insert_into = absl::StrSplit(
- StripPrefixString(
- parameter, insert_endlines ? "insert_endlines=" : "insert="),
- ",", absl::SkipEmpty());
+ absl::StripPrefix(parameter,
+ insert_endlines ? "insert_endlines=" : "insert="),
+ ',', absl::SkipEmpty());
for (size_t i = 0; i < insert_into.size(); i++) {
{
@@ -265,7 +264,7 @@
std::string content =
GetOutputFileContent(name_, "first_insert", file, context);
if (insert_endlines) {
- GlobalReplaceSubstring(",", ",\n", &content);
+ absl::StrReplaceAll({{",", ",\n"}}, &content);
}
if (annotate) {
auto* annotation = info.add_annotation();
@@ -290,7 +289,7 @@
std::string content =
GetOutputFileContent(name_, "second_insert", file, context);
if (insert_endlines) {
- GlobalReplaceSubstring(",", ",\n", &content);
+ absl::StrReplaceAll({{",", ",\n"}}, &content);
}
if (annotate) {
auto* annotation = info.add_annotation();
diff --git a/src/google/protobuf/compiler/objectivec/objectivec_enum.cc b/src/google/protobuf/compiler/objectivec/objectivec_enum.cc
index 28ef44c..13954ca 100644
--- a/src/google/protobuf/compiler/objectivec/objectivec_enum.cc
+++ b/src/google/protobuf/compiler/objectivec/objectivec_enum.cc
@@ -28,18 +28,16 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#include "google/protobuf/compiler/objectivec/objectivec_enum.h"
+
#include <algorithm>
#include <map>
#include <string>
-#include "absl/strings/ascii.h"
#include "absl/strings/escaping.h"
-#include "absl/strings/str_replace.h"
-#include "absl/strings/str_split.h"
-#include "google/protobuf/compiler/objectivec/objectivec_enum.h"
+#include "absl/strings/str_cat.h"
#include "google/protobuf/compiler/objectivec/objectivec_helpers.h"
#include "google/protobuf/io/printer.h"
-#include "google/protobuf/stubs/strutil.h"
namespace google {
namespace protobuf {
diff --git a/src/google/protobuf/compiler/objectivec/objectivec_extension.cc b/src/google/protobuf/compiler/objectivec/objectivec_extension.cc
index 3c20a13..8102df2 100644
--- a/src/google/protobuf/compiler/objectivec/objectivec_extension.cc
+++ b/src/google/protobuf/compiler/objectivec/objectivec_extension.cc
@@ -28,13 +28,11 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#include "google/protobuf/compiler/objectivec/objectivec_extension.h"
+
#include <iostream>
-#include "absl/strings/ascii.h"
-#include "absl/strings/escaping.h"
-#include "absl/strings/str_replace.h"
-#include "absl/strings/str_split.h"
-#include "google/protobuf/compiler/objectivec/objectivec_extension.h"
+#include "absl/strings/str_cat.h"
#include "google/protobuf/compiler/objectivec/objectivec_helpers.h"
#include "google/protobuf/descriptor.pb.h"
#include "google/protobuf/io/printer.h"
diff --git a/src/google/protobuf/compiler/objectivec/objectivec_field.cc b/src/google/protobuf/compiler/objectivec/objectivec_field.cc
index 4397231..b98955b 100644
--- a/src/google/protobuf/compiler/objectivec/objectivec_field.cc
+++ b/src/google/protobuf/compiler/objectivec/objectivec_field.cc
@@ -28,20 +28,17 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#include "google/protobuf/compiler/objectivec/objectivec_field.h"
+
#include <iostream>
-#include "absl/strings/ascii.h"
-#include "absl/strings/escaping.h"
-#include "absl/strings/str_replace.h"
-#include "absl/strings/str_split.h"
+#include "absl/strings/str_cat.h"
#include "google/protobuf/compiler/objectivec/objectivec_enum_field.h"
-#include "google/protobuf/compiler/objectivec/objectivec_field.h"
#include "google/protobuf/compiler/objectivec/objectivec_helpers.h"
#include "google/protobuf/compiler/objectivec/objectivec_map_field.h"
#include "google/protobuf/compiler/objectivec/objectivec_message_field.h"
#include "google/protobuf/compiler/objectivec/objectivec_primitive_field.h"
#include "google/protobuf/io/printer.h"
-#include "google/protobuf/stubs/strutil.h"
namespace google {
namespace protobuf {
diff --git a/src/google/protobuf/compiler/objectivec/objectivec_file.cc b/src/google/protobuf/compiler/objectivec/objectivec_file.cc
index 72caa47..496786e 100644
--- a/src/google/protobuf/compiler/objectivec/objectivec_file.cc
+++ b/src/google/protobuf/compiler/objectivec/objectivec_file.cc
@@ -28,24 +28,20 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#include "google/protobuf/compiler/objectivec/objectivec_file.h"
+
#include <algorithm>
#include <iostream>
#include <sstream>
-#include "absl/strings/ascii.h"
-#include "absl/strings/escaping.h"
-#include "absl/strings/str_replace.h"
-#include "absl/strings/str_split.h"
#include "google/protobuf/compiler/code_generator.h"
+#include "absl/strings/str_cat.h"
#include "google/protobuf/compiler/objectivec/objectivec_enum.h"
#include "google/protobuf/compiler/objectivec/objectivec_extension.h"
#include "google/protobuf/compiler/objectivec/objectivec_file.h"
#include "google/protobuf/compiler/objectivec/objectivec_helpers.h"
#include "google/protobuf/compiler/objectivec/objectivec_message.h"
#include "google/protobuf/io/printer.h"
-#include "google/protobuf/io/zero_copy_stream_impl.h"
-#include "google/protobuf/stubs/stl_util.h"
-#include "google/protobuf/stubs/strutil.h"
// NOTE: src/google/protobuf/compiler/plugin.cc makes use of cerr for some
// error cases, so it seems to be ok to use as a back door for errors.
diff --git a/src/google/protobuf/compiler/objectivec/objectivec_generator.cc b/src/google/protobuf/compiler/objectivec/objectivec_generator.cc
index 225a7d2..ec4071b 100644
--- a/src/google/protobuf/compiler/objectivec/objectivec_generator.cc
+++ b/src/google/protobuf/compiler/objectivec/objectivec_generator.cc
@@ -28,21 +28,21 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#include "google/protobuf/compiler/objectivec/objectivec_generator.h"
+
#include <fstream>
#include <iostream>
#include <string>
#include <unordered_set>
#include "absl/strings/ascii.h"
-#include "absl/strings/escaping.h"
-#include "absl/strings/str_replace.h"
#include "absl/strings/str_split.h"
+#include "absl/strings/strip.h"
#include "google/protobuf/compiler/objectivec/objectivec_file.h"
#include "google/protobuf/compiler/objectivec/objectivec_generator.h"
#include "google/protobuf/compiler/objectivec/objectivec_helpers.h"
#include "google/protobuf/io/printer.h"
#include "google/protobuf/io/zero_copy_stream.h"
-#include "google/protobuf/stubs/strutil.h"
namespace google {
namespace protobuf {
@@ -104,7 +104,7 @@
std::vector<std::pair<std::string, std::string> > options;
ParseGeneratorParameter(parameter, &options);
- for (int i = 0; i < options.size(); i++) {
+ for (size_t i = 0; i < options.size(); i++) {
if (options[i].first == "expected_prefixes_path") {
// Path to find a file containing the expected prefixes
// (objc_class_prefix "PREFIX") for proto packages (package NAME). The
@@ -194,7 +194,8 @@
// generated files. When integrating ObjC protos into a build system,
// this can be used to avoid having to add the runtime directory to the
// header search path since the generate #import will be more complete.
- generation_options.runtime_import_prefix = StripSuffixString(options[i].second, "/");
+ generation_options.runtime_import_prefix =
+ std::string(absl::StripSuffix(options[i].second, "/"));
} else if (options[i].first == "package_to_prefix_mappings_path") {
// Path to use for when loading the objc class prefix mappings to use.
// The `objc_class_prefix` file option is always honored first if one is present.
diff --git a/src/google/protobuf/compiler/objectivec/objectivec_helpers.cc b/src/google/protobuf/compiler/objectivec/objectivec_helpers.cc
index f4a3693..a9404ca 100644
--- a/src/google/protobuf/compiler/objectivec/objectivec_helpers.cc
+++ b/src/google/protobuf/compiler/objectivec/objectivec_helpers.cc
@@ -31,21 +31,24 @@
#ifndef _MSC_VER
#include <unistd.h>
#endif
-#include <climits>
#include <errno.h>
#include <fcntl.h>
+#include <stdlib.h>
+
+#include <climits>
#include <fstream>
#include <iostream>
#include <sstream>
-#include <stdlib.h>
#include <unordered_set>
#include <vector>
+#include "google/protobuf/compiler/code_generator.h"
+#include "google/protobuf/stubs/strutil.h"
#include "absl/strings/ascii.h"
#include "absl/strings/escaping.h"
#include "absl/strings/str_replace.h"
#include "absl/strings/str_split.h"
-#include "google/protobuf/compiler/code_generator.h"
+#include "absl/strings/strip.h"
#include "google/protobuf/compiler/objectivec/objectivec_helpers.h"
#include "google/protobuf/compiler/objectivec/objectivec_nsobject_methods.h"
#include "google/protobuf/descriptor.pb.h"
@@ -55,7 +58,6 @@
#include "google/protobuf/io/zero_copy_stream_impl.h"
#include "google/protobuf/port.h"
#include "google/protobuf/stubs/common.h"
-#include "google/protobuf/stubs/strutil.h"
// NOTE: src/google/protobuf/compiler/plugin.cc makes use of cerr for some
// error cases, so it seems to be ok to use as a back door for errors.
@@ -466,7 +468,7 @@
// a) Doesn't start with the prefix or
// b) Isn't equivalent to the prefix or
// c) Has the prefix, but the letter after the prefix is lowercase
- if (HasPrefixString(input, prefix)) {
+ if (absl::StartsWith(input, prefix)) {
if (input.length() == prefix.length() || !absl::ascii_isupper(input[prefix.length()])) {
sanitized = prefix + input;
} else {
@@ -797,7 +799,7 @@
const std::string class_name = EnumName(descriptor->type());
const std::string long_name_prefix = class_name + "_";
const std::string long_name = EnumValueName(descriptor);
- return StripPrefixString(long_name, long_name_prefix);
+ return std::string(absl::StripPrefix(long_name, long_name_prefix));
}
std::string UnCamelCaseEnumShortName(const std::string& name) {
@@ -826,7 +828,7 @@
result += "Array";
} else {
// If it wasn't repeated, but ends in "Array", force on the _p suffix.
- if (HasSuffixString(result, "Array")) {
+ if (absl::EndsWith(result, "Array")) {
result += "_p";
}
}
@@ -876,20 +878,22 @@
}
std::string UnCamelCaseFieldName(const std::string& name, const FieldDescriptor* field) {
- std::string worker(name);
- if (HasSuffixString(worker, "_p")) {
- worker = StripSuffixString(worker, "_p");
+ absl::string_view worker(name);
+ if (absl::EndsWith(worker, "_p")) {
+ worker = absl::StripSuffix(worker, "_p");
}
- if (field->is_repeated() && HasSuffixString(worker, "Array")) {
- worker = StripSuffixString(worker, "Array");
+ if (field->is_repeated() && absl::EndsWith(worker, "Array")) {
+ worker = absl::StripSuffix(worker, "Array");
}
if (field->type() == FieldDescriptor::TYPE_GROUP) {
if (worker.length() > 0) {
if (absl::ascii_islower(worker[0])) {
- worker[0] = absl::ascii_toupper(worker[0]);
+ std::string copy(worker);
+ copy[0] = absl::ascii_toupper(worker[0]);
+ return copy;
}
}
- return worker;
+ return std::string(worker);
} else {
std::string result;
for (int i = 0; i < worker.size(); i++) {
@@ -1252,7 +1256,7 @@
for (size_t i = 0; i < lines.size(); i++) {
std::string line = absl::StrReplaceAll(
- StripPrefixString(lines[i], " "),
+ absl::StripPrefix(lines[i], " "),
{// HeaderDoc and appledoc use '\' and '@' for markers; escape them.
{"\\", "\\\\"},
{"@", "\\@"},
@@ -1260,9 +1264,9 @@
{"/*", "/\\*"},
{"*/", "*\\/"}});
line = prefix + line;
- StripWhitespace(&line);
+ absl::StripAsciiWhitespace(&line);
// If not a one line, need to add the first space before *, as
- // StripWhitespace would have removed it.
+ // absl::StripAsciiWhitespace would have removed it.
line = (add_leading_space ? " " : "") + line;
final_comments += line + suffix;
}
@@ -1425,7 +1429,7 @@
other_package_for_prefix = i->first;
// Stop on the first real package listing, if it was a no_package file
// specific entry, keep looking to try and find a package one.
- if (!HasPrefixString(other_package_for_prefix, no_package_prefix)) {
+ if (!absl::StartsWith(other_package_for_prefix, no_package_prefix)) {
break;
}
}
@@ -1438,16 +1442,19 @@
*out_error =
"error: Found 'option objc_class_prefix = \"" + prefix +
"\";' in '" + file->name() + "'; that prefix is already used for ";
- if (HasPrefixString(other_package_for_prefix, no_package_prefix)) {
- *out_error += "file '" +
- StripPrefixString(other_package_for_prefix, no_package_prefix) +
- "'.";
+ if (absl::StartsWith(other_package_for_prefix, no_package_prefix)) {
+ absl::StrAppend(
+ out_error, "file '",
+ absl::StripPrefix(other_package_for_prefix, no_package_prefix),
+ "'.");
} else {
- *out_error += "'package " + other_package_for_prefix + ";'.";
+ absl::StrAppend(out_error, "'package ",
+ other_package_for_prefix + ";'.");
}
- *out_error +=
- " It can only be reused by adding '" + lookup_key + " = " + prefix +
- "' to the expected prefixes file (" + expected_prefixes_path + ").";
+ absl::StrAppend(out_error, " It can only be reused by adding '",
+ lookup_key, " = ", prefix,
+ "' to the expected prefixes file (",
+ expected_prefixes_path, ").");
return false; // Only report first usage of the prefix.
}
} // !prefix.empty() && have_expected_prefix_file
diff --git a/src/google/protobuf/compiler/objectivec/objectivec_message.cc b/src/google/protobuf/compiler/objectivec/objectivec_message.cc
index dd3eacb..9816149 100644
--- a/src/google/protobuf/compiler/objectivec/objectivec_message.cc
+++ b/src/google/protobuf/compiler/objectivec/objectivec_message.cc
@@ -28,24 +28,19 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#include "google/protobuf/compiler/objectivec/objectivec_message.h"
+
#include <algorithm>
#include <iostream>
#include <sstream>
-#include "absl/strings/ascii.h"
#include "absl/strings/escaping.h"
-#include "absl/strings/str_replace.h"
-#include "absl/strings/str_split.h"
+#include "absl/strings/str_cat.h"
#include "google/protobuf/compiler/objectivec/objectivec_enum.h"
#include "google/protobuf/compiler/objectivec/objectivec_extension.h"
#include "google/protobuf/compiler/objectivec/objectivec_helpers.h"
-#include "google/protobuf/compiler/objectivec/objectivec_message.h"
#include "google/protobuf/descriptor.pb.h"
-#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/io/printer.h"
-#include "google/protobuf/io/zero_copy_stream_impl.h"
-#include "google/protobuf/stubs/stl_util.h"
-#include "google/protobuf/stubs/strutil.h"
namespace google {
namespace protobuf {
diff --git a/src/google/protobuf/compiler/objectivec/objectivec_oneof.cc b/src/google/protobuf/compiler/objectivec/objectivec_oneof.cc
index dc218df..279928b 100644
--- a/src/google/protobuf/compiler/objectivec/objectivec_oneof.cc
+++ b/src/google/protobuf/compiler/objectivec/objectivec_oneof.cc
@@ -28,17 +28,14 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#include "google/protobuf/compiler/objectivec/objectivec_oneof.h"
+
#include <map>
#include <string>
-#include "absl/strings/ascii.h"
-#include "absl/strings/escaping.h"
-#include "absl/strings/str_replace.h"
-#include "absl/strings/str_split.h"
+#include "absl/strings/str_cat.h"
#include "google/protobuf/compiler/objectivec/objectivec_helpers.h"
-#include "google/protobuf/compiler/objectivec/objectivec_oneof.h"
#include "google/protobuf/io/printer.h"
-#include "google/protobuf/stubs/strutil.h"
namespace google {
namespace protobuf {
diff --git a/src/google/protobuf/compiler/objectivec/objectivec_primitive_field.cc b/src/google/protobuf/compiler/objectivec/objectivec_primitive_field.cc
index 824bdbf..c9339a5 100644
--- a/src/google/protobuf/compiler/objectivec/objectivec_primitive_field.cc
+++ b/src/google/protobuf/compiler/objectivec/objectivec_primitive_field.cc
@@ -28,17 +28,14 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#include "google/protobuf/compiler/objectivec/objectivec_primitive_field.h"
+
#include <map>
#include <string>
-#include "absl/strings/ascii.h"
-#include "absl/strings/escaping.h"
-#include "absl/strings/str_replace.h"
-#include "absl/strings/str_split.h"
+#include "absl/strings/str_cat.h"
#include "google/protobuf/compiler/objectivec/objectivec_helpers.h"
-#include "google/protobuf/compiler/objectivec/objectivec_primitive_field.h"
#include "google/protobuf/io/printer.h"
-#include "google/protobuf/stubs/strutil.h"
namespace google {
namespace protobuf {
diff --git a/src/google/protobuf/compiler/php/php_generator.cc b/src/google/protobuf/compiler/php/php_generator.cc
index 7c1daec..7466f74 100644
--- a/src/google/protobuf/compiler/php/php_generator.cc
+++ b/src/google/protobuf/compiler/php/php_generator.cc
@@ -33,13 +33,12 @@
#include <sstream>
#include "google/protobuf/compiler/code_generator.h"
-#include "google/protobuf/compiler/plugin.h"
-#include "google/protobuf/descriptor.h"
#include "google/protobuf/stubs/strutil.h"
#include "absl/strings/ascii.h"
#include "absl/strings/escaping.h"
-#include "absl/strings/str_split.h"
#include "absl/strings/str_replace.h"
+#include "absl/strings/str_split.h"
+#include "google/protobuf/descriptor.h"
#include "google/protobuf/descriptor.pb.h"
#include "google/protobuf/io/printer.h"
#include "google/protobuf/io/zero_copy_stream.h"
@@ -153,8 +152,7 @@
template <typename DescriptorType>
std::string DescriptorFullName(const DescriptorType* desc, bool is_internal) {
if (is_internal) {
- return StringReplace(desc->full_name(),
- "google.protobuf",
+ return StringReplace(desc->full_name(), "google.protobuf",
"google.protobuf.internal", false);
} else {
return desc->full_name();
@@ -1110,7 +1108,7 @@
has_aggregate_metadata_prefix = true;
} else {
for (const auto& prefix : options.aggregate_metadata_prefixes) {
- if (HasPrefixString(file->package(), prefix)) {
+ if (absl::StartsWith(file->package(), prefix)) {
has_aggregate_metadata_prefix = true;
break;
}
@@ -2392,7 +2390,7 @@
for (const auto& option : absl::StrSplit(parameter, ",", absl::SkipEmpty())) {
const std::vector<std::string> option_pair = absl::StrSplit(option, "=", absl::SkipEmpty());
- if (HasPrefixString(option_pair[0], "aggregate_metadata")) {
+ if (absl::StartsWith(option_pair[0], "aggregate_metadata")) {
options.aggregate_metadata = true;
for (const auto& prefix : absl::StrSplit(option_pair[1], "#", absl::AllowEmpty())) {
options.aggregate_metadata_prefixes.emplace(prefix);
diff --git a/src/google/protobuf/compiler/plugin.pb.cc b/src/google/protobuf/compiler/plugin.pb.cc
index bcaf8d5..87d4dda 100644
--- a/src/google/protobuf/compiler/plugin.pb.cc
+++ b/src/google/protobuf/compiler/plugin.pb.cc
@@ -1,10 +1,9 @@
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: google/protobuf/compiler/plugin.proto
-#include <google/protobuf/compiler/plugin.pb.h>
+#include "google/protobuf/compiler/plugin.pb.h"
#include <algorithm>
-
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/extension_set.h"
#include "google/protobuf/wire_format_lite.h"
@@ -13,13 +12,12 @@
#include "google/protobuf/reflection_ops.h"
#include "google/protobuf/wire_format.h"
// @@protoc_insertion_point(includes)
+
+// Must be included last.
#include "google/protobuf/port_def.inc"
-
PROTOBUF_PRAGMA_INIT_SEG
-
namespace _pb = ::PROTOBUF_NAMESPACE_ID;
-namespace _pbi = _pb::internal;
-
+namespace _pbi = ::PROTOBUF_NAMESPACE_ID::internal;
PROTOBUF_NAMESPACE_OPEN
namespace compiler {
PROTOBUF_CONSTEXPR Version::Version(
@@ -31,14 +29,15 @@
, /*decltype(_impl_.minor_)*/0
, /*decltype(_impl_.patch_)*/0} {}
struct VersionDefaultTypeInternal {
- PROTOBUF_CONSTEXPR VersionDefaultTypeInternal()
- : _instance(::_pbi::ConstantInitialized{}) {}
+ PROTOBUF_CONSTEXPR VersionDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
~VersionDefaultTypeInternal() {}
union {
Version _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 VersionDefaultTypeInternal _Version_default_instance_;
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 VersionDefaultTypeInternal _Version_default_instance_;
PROTOBUF_CONSTEXPR CodeGeneratorRequest::CodeGeneratorRequest(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_._has_bits_)*/{}
@@ -48,14 +47,15 @@
, /*decltype(_impl_.parameter_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
, /*decltype(_impl_.compiler_version_)*/nullptr} {}
struct CodeGeneratorRequestDefaultTypeInternal {
- PROTOBUF_CONSTEXPR CodeGeneratorRequestDefaultTypeInternal()
- : _instance(::_pbi::ConstantInitialized{}) {}
+ PROTOBUF_CONSTEXPR CodeGeneratorRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
~CodeGeneratorRequestDefaultTypeInternal() {}
union {
CodeGeneratorRequest _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CodeGeneratorRequestDefaultTypeInternal _CodeGeneratorRequest_default_instance_;
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CodeGeneratorRequestDefaultTypeInternal _CodeGeneratorRequest_default_instance_;
PROTOBUF_CONSTEXPR CodeGeneratorResponse_File::CodeGeneratorResponse_File(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_._has_bits_)*/{}
@@ -65,14 +65,15 @@
, /*decltype(_impl_.content_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
, /*decltype(_impl_.generated_code_info_)*/nullptr} {}
struct CodeGeneratorResponse_FileDefaultTypeInternal {
- PROTOBUF_CONSTEXPR CodeGeneratorResponse_FileDefaultTypeInternal()
- : _instance(::_pbi::ConstantInitialized{}) {}
+ PROTOBUF_CONSTEXPR CodeGeneratorResponse_FileDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
~CodeGeneratorResponse_FileDefaultTypeInternal() {}
union {
CodeGeneratorResponse_File _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CodeGeneratorResponse_FileDefaultTypeInternal _CodeGeneratorResponse_File_default_instance_;
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CodeGeneratorResponse_FileDefaultTypeInternal _CodeGeneratorResponse_File_default_instance_;
PROTOBUF_CONSTEXPR CodeGeneratorResponse::CodeGeneratorResponse(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_._has_bits_)*/{}
@@ -81,138 +82,163 @@
, /*decltype(_impl_.error_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
, /*decltype(_impl_.supported_features_)*/uint64_t{0u}} {}
struct CodeGeneratorResponseDefaultTypeInternal {
- PROTOBUF_CONSTEXPR CodeGeneratorResponseDefaultTypeInternal()
- : _instance(::_pbi::ConstantInitialized{}) {}
+ PROTOBUF_CONSTEXPR CodeGeneratorResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
~CodeGeneratorResponseDefaultTypeInternal() {}
union {
CodeGeneratorResponse _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CodeGeneratorResponseDefaultTypeInternal _CodeGeneratorResponse_default_instance_;
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CodeGeneratorResponseDefaultTypeInternal _CodeGeneratorResponse_default_instance_;
} // namespace compiler
PROTOBUF_NAMESPACE_CLOSE
static ::_pb::Metadata file_level_metadata_google_2fprotobuf_2fcompiler_2fplugin_2eproto[4];
static const ::_pb::EnumDescriptor* file_level_enum_descriptors_google_2fprotobuf_2fcompiler_2fplugin_2eproto[1];
-static constexpr ::_pb::ServiceDescriptor const** file_level_service_descriptors_google_2fprotobuf_2fcompiler_2fplugin_2eproto = nullptr;
-
-const uint32_t TableStruct_google_2fprotobuf_2fcompiler_2fplugin_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::Version, _impl_._has_bits_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::Version, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- ~0u, // no _inlined_string_donated_
- ~0u, // no _split_
- ~0u, // no sizeof(Split)
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::Version, _impl_.major_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::Version, _impl_.minor_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::Version, _impl_.patch_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::Version, _impl_.suffix_),
- 1,
- 2,
- 3,
- 0,
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorRequest, _impl_._has_bits_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorRequest, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- ~0u, // no _inlined_string_donated_
- ~0u, // no _split_
- ~0u, // no sizeof(Split)
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorRequest, _impl_.file_to_generate_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorRequest, _impl_.parameter_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorRequest, _impl_.proto_file_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorRequest, _impl_.compiler_version_),
- ~0u,
- 0,
- ~0u,
- 1,
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File, _impl_._has_bits_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- ~0u, // no _inlined_string_donated_
- ~0u, // no _split_
- ~0u, // no sizeof(Split)
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File, _impl_.name_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File, _impl_.insertion_point_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File, _impl_.content_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File, _impl_.generated_code_info_),
- 0,
- 1,
- 2,
- 3,
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse, _impl_._has_bits_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- ~0u, // no _inlined_string_donated_
- ~0u, // no _split_
- ~0u, // no sizeof(Split)
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse, _impl_.error_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse, _impl_.supported_features_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse, _impl_.file_),
- 0,
- 1,
- ~0u,
+static constexpr const ::_pb::ServiceDescriptor**
+ file_level_service_descriptors_google_2fprotobuf_2fcompiler_2fplugin_2eproto = nullptr;
+const uint32_t TableStruct_google_2fprotobuf_2fcompiler_2fplugin_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(
+ protodesc_cold) = {
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::Version, _impl_._has_bits_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::Version, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ~0u, // no _split_
+ ~0u, // no sizeof(Split)
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::Version, _impl_.major_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::Version, _impl_.minor_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::Version, _impl_.patch_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::Version, _impl_.suffix_),
+ 1,
+ 2,
+ 3,
+ 0,
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorRequest, _impl_._has_bits_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorRequest, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ~0u, // no _split_
+ ~0u, // no sizeof(Split)
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorRequest, _impl_.file_to_generate_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorRequest, _impl_.parameter_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorRequest, _impl_.proto_file_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorRequest, _impl_.compiler_version_),
+ ~0u,
+ 0,
+ ~0u,
+ 1,
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File, _impl_._has_bits_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ~0u, // no _split_
+ ~0u, // no sizeof(Split)
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File, _impl_.name_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File, _impl_.insertion_point_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File, _impl_.content_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File, _impl_.generated_code_info_),
+ 0,
+ 1,
+ 2,
+ 3,
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse, _impl_._has_bits_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ~0u, // no _split_
+ ~0u, // no sizeof(Split)
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse, _impl_.error_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse, _impl_.supported_features_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse, _impl_.file_),
+ 0,
+ 1,
+ ~0u,
};
-static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
- { 0, 12, -1, sizeof(::PROTOBUF_NAMESPACE_ID::compiler::Version)},
- { 16, 28, -1, sizeof(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorRequest)},
- { 32, 44, -1, sizeof(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File)},
- { 48, 59, -1, sizeof(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse)},
+
+static const ::_pbi::MigrationSchema
+ schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+ { 0, 12, -1, sizeof(::PROTOBUF_NAMESPACE_ID::compiler::Version)},
+ { 16, 28, -1, sizeof(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorRequest)},
+ { 32, 44, -1, sizeof(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File)},
+ { 48, 59, -1, sizeof(::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse)},
};
static const ::_pb::Message* const file_default_instances[] = {
- &::PROTOBUF_NAMESPACE_ID::compiler::_Version_default_instance_._instance,
- &::PROTOBUF_NAMESPACE_ID::compiler::_CodeGeneratorRequest_default_instance_._instance,
- &::PROTOBUF_NAMESPACE_ID::compiler::_CodeGeneratorResponse_File_default_instance_._instance,
- &::PROTOBUF_NAMESPACE_ID::compiler::_CodeGeneratorResponse_default_instance_._instance,
+ &::PROTOBUF_NAMESPACE_ID::compiler::_Version_default_instance_._instance,
+ &::PROTOBUF_NAMESPACE_ID::compiler::_CodeGeneratorRequest_default_instance_._instance,
+ &::PROTOBUF_NAMESPACE_ID::compiler::_CodeGeneratorResponse_File_default_instance_._instance,
+ &::PROTOBUF_NAMESPACE_ID::compiler::_CodeGeneratorResponse_default_instance_._instance,
};
-
-const char descriptor_table_protodef_google_2fprotobuf_2fcompiler_2fplugin_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
- "\n%google/protobuf/compiler/plugin.proto\022"
- "\030google.protobuf.compiler\032 google/protob"
- "uf/descriptor.proto\"F\n\007Version\022\r\n\005major\030"
- "\001 \001(\005\022\r\n\005minor\030\002 \001(\005\022\r\n\005patch\030\003 \001(\005\022\016\n\006s"
- "uffix\030\004 \001(\t\"\272\001\n\024CodeGeneratorRequest\022\030\n\020"
- "file_to_generate\030\001 \003(\t\022\021\n\tparameter\030\002 \001("
- "\t\0228\n\nproto_file\030\017 \003(\0132$.google.protobuf."
- "FileDescriptorProto\022;\n\020compiler_version\030"
- "\003 \001(\0132!.google.protobuf.compiler.Version"
- "\"\301\002\n\025CodeGeneratorResponse\022\r\n\005error\030\001 \001("
- "\t\022\032\n\022supported_features\030\002 \001(\004\022B\n\004file\030\017 "
- "\003(\01324.google.protobuf.compiler.CodeGener"
- "atorResponse.File\032\177\n\004File\022\014\n\004name\030\001 \001(\t\022"
- "\027\n\017insertion_point\030\002 \001(\t\022\017\n\007content\030\017 \001("
- "\t\022\?\n\023generated_code_info\030\020 \001(\0132\".google."
- "protobuf.GeneratedCodeInfo\"8\n\007Feature\022\020\n"
- "\014FEATURE_NONE\020\000\022\033\n\027FEATURE_PROTO3_OPTION"
- "AL\020\001BW\n\034com.google.protobuf.compilerB\014Pl"
- "uginProtosZ)google.golang.org/protobuf/t"
- "ypes/pluginpb"
- ;
-static const ::_pbi::DescriptorTable* const descriptor_table_google_2fprotobuf_2fcompiler_2fplugin_2eproto_deps[1] = {
- &::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto,
+const char descriptor_table_protodef_google_2fprotobuf_2fcompiler_2fplugin_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+ "\n%google/protobuf/compiler/plugin.proto\022"
+ "\030google.protobuf.compiler\032 google/protob"
+ "uf/descriptor.proto\"F\n\007Version\022\r\n\005major\030"
+ "\001 \001(\005\022\r\n\005minor\030\002 \001(\005\022\r\n\005patch\030\003 \001(\005\022\016\n\006s"
+ "uffix\030\004 \001(\t\"\272\001\n\024CodeGeneratorRequest\022\030\n\020"
+ "file_to_generate\030\001 \003(\t\022\021\n\tparameter\030\002 \001("
+ "\t\0228\n\nproto_file\030\017 \003(\0132$.google.protobuf."
+ "FileDescriptorProto\022;\n\020compiler_version\030"
+ "\003 \001(\0132!.google.protobuf.compiler.Version"
+ "\"\301\002\n\025CodeGeneratorResponse\022\r\n\005error\030\001 \001("
+ "\t\022\032\n\022supported_features\030\002 \001(\004\022B\n\004file\030\017 "
+ "\003(\01324.google.protobuf.compiler.CodeGener"
+ "atorResponse.File\032\177\n\004File\022\014\n\004name\030\001 \001(\t\022"
+ "\027\n\017insertion_point\030\002 \001(\t\022\017\n\007content\030\017 \001("
+ "\t\022\?\n\023generated_code_info\030\020 \001(\0132\".google."
+ "protobuf.GeneratedCodeInfo\"8\n\007Feature\022\020\n"
+ "\014FEATURE_NONE\020\000\022\033\n\027FEATURE_PROTO3_OPTION"
+ "AL\020\001BW\n\034com.google.protobuf.compilerB\014Pl"
+ "uginProtosZ)google.golang.org/protobuf/t"
+ "ypes/pluginpb"
+};
+static const ::_pbi::DescriptorTable* const descriptor_table_google_2fprotobuf_2fcompiler_2fplugin_2eproto_deps[1] =
+ {
+ &::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto,
};
static ::absl::once_flag descriptor_table_google_2fprotobuf_2fcompiler_2fplugin_2eproto_once;
const ::_pbi::DescriptorTable descriptor_table_google_2fprotobuf_2fcompiler_2fplugin_2eproto = {
- false, false, 773, descriptor_table_protodef_google_2fprotobuf_2fcompiler_2fplugin_2eproto,
+ false,
+ false,
+ 773,
+ descriptor_table_protodef_google_2fprotobuf_2fcompiler_2fplugin_2eproto,
"google/protobuf/compiler/plugin.proto",
- &descriptor_table_google_2fprotobuf_2fcompiler_2fplugin_2eproto_once, descriptor_table_google_2fprotobuf_2fcompiler_2fplugin_2eproto_deps, 1, 4,
- schemas, file_default_instances, TableStruct_google_2fprotobuf_2fcompiler_2fplugin_2eproto::offsets,
- file_level_metadata_google_2fprotobuf_2fcompiler_2fplugin_2eproto, file_level_enum_descriptors_google_2fprotobuf_2fcompiler_2fplugin_2eproto,
+ &descriptor_table_google_2fprotobuf_2fcompiler_2fplugin_2eproto_once,
+ descriptor_table_google_2fprotobuf_2fcompiler_2fplugin_2eproto_deps,
+ 1,
+ 4,
+ schemas,
+ file_default_instances,
+ TableStruct_google_2fprotobuf_2fcompiler_2fplugin_2eproto::offsets,
+ file_level_metadata_google_2fprotobuf_2fcompiler_2fplugin_2eproto,
+ file_level_enum_descriptors_google_2fprotobuf_2fcompiler_2fplugin_2eproto,
file_level_service_descriptors_google_2fprotobuf_2fcompiler_2fplugin_2eproto,
};
+
+// This function exists to be marked as weak.
+// It can significantly speed up compilation by breaking up LLVM's SCC
+// in the .pb.cc translation units. Large translation units see a
+// reduction of more than 35% of walltime for optimized builds. Without
+// the weak attribute all the messages in the file, including all the
+// vtables and everything they use become part of the same SCC through
+// a cycle like:
+// GetMetadata -> descriptor table -> default instances ->
+// vtables -> GetMetadata
+// By adding a weak function here we break the connection from the
+// individual vtables back into the descriptor table.
PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_google_2fprotobuf_2fcompiler_2fplugin_2eproto_getter() {
return &descriptor_table_google_2fprotobuf_2fcompiler_2fplugin_2eproto;
}
-
// Force running AddDescriptors() at dynamic initialization time.
-PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_google_2fprotobuf_2fcompiler_2fplugin_2eproto(&descriptor_table_google_2fprotobuf_2fcompiler_2fplugin_2eproto);
+PROTOBUF_ATTRIBUTE_INIT_PRIORITY2
+static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_google_2fprotobuf_2fcompiler_2fplugin_2eproto(&descriptor_table_google_2fprotobuf_2fcompiler_2fplugin_2eproto);
PROTOBUF_NAMESPACE_OPEN
namespace compiler {
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CodeGeneratorResponse_Feature_descriptor() {
@@ -236,7 +262,6 @@
constexpr CodeGeneratorResponse_Feature CodeGeneratorResponse::Feature_MAX;
constexpr int CodeGeneratorResponse::Feature_ARRAYSIZE;
#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
-
// ===================================================================
class Version::_Internal {
@@ -562,7 +587,6 @@
&descriptor_table_google_2fprotobuf_2fcompiler_2fplugin_2eproto_getter, &descriptor_table_google_2fprotobuf_2fcompiler_2fplugin_2eproto_once,
file_level_metadata_google_2fprotobuf_2fcompiler_2fplugin_2eproto[0]);
}
-
// ===================================================================
class CodeGeneratorRequest::_Internal {
@@ -916,7 +940,6 @@
&descriptor_table_google_2fprotobuf_2fcompiler_2fplugin_2eproto_getter, &descriptor_table_google_2fprotobuf_2fcompiler_2fplugin_2eproto_once,
file_level_metadata_google_2fprotobuf_2fcompiler_2fplugin_2eproto[1]);
}
-
// ===================================================================
class CodeGeneratorResponse_File::_Internal {
@@ -1308,7 +1331,6 @@
&descriptor_table_google_2fprotobuf_2fcompiler_2fplugin_2eproto_getter, &descriptor_table_google_2fprotobuf_2fcompiler_2fplugin_2eproto_once,
file_level_metadata_google_2fprotobuf_2fcompiler_2fplugin_2eproto[2]);
}
-
// ===================================================================
class CodeGeneratorResponse::_Internal {
@@ -1601,7 +1623,6 @@
&descriptor_table_google_2fprotobuf_2fcompiler_2fplugin_2eproto_getter, &descriptor_table_google_2fprotobuf_2fcompiler_2fplugin_2eproto_once,
file_level_metadata_google_2fprotobuf_2fcompiler_2fplugin_2eproto[3]);
}
-
// @@protoc_insertion_point(namespace_scope)
} // namespace compiler
PROTOBUF_NAMESPACE_CLOSE
@@ -1623,6 +1644,5 @@
return Arena::CreateMessageInternal< ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse >(arena);
}
PROTOBUF_NAMESPACE_CLOSE
-
// @@protoc_insertion_point(global_scope)
#include "google/protobuf/port_undef.inc"
diff --git a/src/google/protobuf/compiler/plugin.pb.h b/src/google/protobuf/compiler/plugin.pb.h
index dc3712a..9b8dd81 100644
--- a/src/google/protobuf/compiler/plugin.pb.h
+++ b/src/google/protobuf/compiler/plugin.pb.h
@@ -6,6 +6,7 @@
#include <limits>
#include <string>
+#include <type_traits>
#include "google/protobuf/port_def.inc"
#if PROTOBUF_VERSION < 3021000
@@ -19,6 +20,11 @@
#error regenerate this file with a newer version of protoc.
#endif
+#if 3021005 < PROTOBUF_MIN_PROTOC_VERSION
+#error "This file was generated by an older version of protoc which is"
+#error "incompatible with your Protocol Buffer headers. Please"
+#error "regenerate this file with a newer version of protoc."
+#endif // PROTOBUF_MIN_PROTOC_VERSION
#include "google/protobuf/port_undef.inc"
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/arena.h"
@@ -31,16 +37,20 @@
#include "google/protobuf/extension_set.h" // IWYU pragma: export
#include "google/protobuf/generated_enum_reflection.h"
#include "google/protobuf/unknown_field_set.h"
-#include <google/protobuf/descriptor.pb.h>
+#include "google/protobuf/descriptor.pb.h"
// @@protoc_insertion_point(includes)
+
+// Must be included last.
#include "google/protobuf/port_def.inc"
+
#define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2fcompiler_2fplugin_2eproto PROTOC_EXPORT
#ifdef major
#undef major
-#endif
+#endif // major
#ifdef minor
#undef minor
-#endif
+#endif // minor
+
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
@@ -51,7 +61,8 @@
struct PROTOC_EXPORT TableStruct_google_2fprotobuf_2fcompiler_2fplugin_2eproto {
static const uint32_t offsets[];
};
-PROTOC_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fcompiler_2fplugin_2eproto;
+PROTOC_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable
+ descriptor_table_google_2fprotobuf_2fcompiler_2fplugin_2eproto;
PROTOBUF_NAMESPACE_OPEN
namespace compiler {
class CodeGeneratorRequest;
@@ -67,16 +78,18 @@
struct VersionDefaultTypeInternal;
PROTOC_EXPORT extern VersionDefaultTypeInternal _Version_default_instance_;
} // namespace compiler
+template <>
+PROTOC_EXPORT ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorRequest* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorRequest>(Arena*);
+template <>
+PROTOC_EXPORT ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse>(Arena*);
+template <>
+PROTOC_EXPORT ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File>(Arena*);
+template <>
+PROTOC_EXPORT ::PROTOBUF_NAMESPACE_ID::compiler::Version* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::compiler::Version>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
-PROTOBUF_NAMESPACE_OPEN
-template<> PROTOC_EXPORT ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorRequest* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorRequest>(Arena*);
-template<> PROTOC_EXPORT ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse>(Arena*);
-template<> PROTOC_EXPORT ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File>(Arena*);
-template<> PROTOC_EXPORT ::PROTOBUF_NAMESPACE_ID::compiler::Version* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::compiler::Version>(Arena*);
-PROTOBUF_NAMESPACE_CLOSE
+
PROTOBUF_NAMESPACE_OPEN
namespace compiler {
-
enum CodeGeneratorResponse_Feature : int {
CodeGeneratorResponse_Feature_FEATURE_NONE = 0,
CodeGeneratorResponse_Feature_FEATURE_PROTO3_OPTIONAL = 1
@@ -104,8 +117,12 @@
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CodeGeneratorResponse_Feature>(
CodeGeneratorResponse_Feature_descriptor(), name, value);
}
+
// ===================================================================
+
+// -------------------------------------------------------------------
+
class PROTOC_EXPORT Version final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.compiler.Version) */ {
public:
@@ -313,8 +330,7 @@
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fcompiler_2fplugin_2eproto;
-};
-// -------------------------------------------------------------------
+};// -------------------------------------------------------------------
class PROTOC_EXPORT CodeGeneratorRequest final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.compiler.CodeGeneratorRequest) */ {
@@ -544,8 +560,7 @@
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fcompiler_2fplugin_2eproto;
-};
-// -------------------------------------------------------------------
+};// -------------------------------------------------------------------
class PROTOC_EXPORT CodeGeneratorResponse_File final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.compiler.CodeGeneratorResponse.File) */ {
@@ -769,8 +784,7 @@
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fcompiler_2fplugin_2eproto;
-};
-// -------------------------------------------------------------------
+};// -------------------------------------------------------------------
class PROTOC_EXPORT CodeGeneratorResponse final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.compiler.CodeGeneratorResponse) */ {
@@ -1005,12 +1019,17 @@
// ===================================================================
+
+
// ===================================================================
+
#ifdef __GNUC__
- #pragma GCC diagnostic push
- #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif // __GNUC__
+// -------------------------------------------------------------------
+
// Version
// optional int32 major = 1;
@@ -1861,20 +1880,14 @@
}
#ifdef __GNUC__
- #pragma GCC diagnostic pop
+#pragma GCC diagnostic pop
#endif // __GNUC__
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
// @@protoc_insertion_point(namespace_scope)
-
} // namespace compiler
PROTOBUF_NAMESPACE_CLOSE
+
PROTOBUF_NAMESPACE_OPEN
template <> struct is_proto_enum< ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_Feature> : ::std::true_type {};
@@ -1888,4 +1901,5 @@
// @@protoc_insertion_point(global_scope)
#include "google/protobuf/port_undef.inc"
-#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fcompiler_2fplugin_2eproto_2epb_2eh
+
+#endif // GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fcompiler_2fplugin_2eproto_2epb_2eh
diff --git a/src/google/protobuf/compiler/python/generator.cc b/src/google/protobuf/compiler/python/generator.cc
index 3d580ad..deb5b09 100644
--- a/src/google/protobuf/compiler/python/generator.cc
+++ b/src/google/protobuf/compiler/python/generator.cc
@@ -59,6 +59,8 @@
#include "absl/strings/escaping.h"
#include "absl/strings/str_cat.h"
#include "google/protobuf/stubs/stringprintf.h"
+#include "absl/strings/str_replace.h"
+#include "absl/strings/strip.h"
#include "absl/strings/substitute.h"
#include "google/protobuf/compiler/python/helpers.h"
#include "google/protobuf/compiler/python/pyi_generator.h"
@@ -82,8 +84,8 @@
// We can't have dots in the module name, so we replace each with _dot_.
// But that could lead to a collision between a.b and a_dot_b, so we also
// duplicate each underscore.
- GlobalReplaceSubstring("_", "__", &module_name);
- GlobalReplaceSubstring(".", "_dot_", &module_name);
+ absl::StrReplaceAll({{"_", "__"}}, &module_name);
+ absl::StrReplaceAll({{".", "_dot_"}}, &module_name);
return module_name;
}
@@ -315,7 +317,8 @@
}
std::string module_name = ModuleName(file->name());
if (!opensource_runtime_) {
- module_name = StripPrefixString(module_name, kThirdPartyPrefix);
+ module_name =
+ std::string(absl::StripPrefix(module_name, kThirdPartyPrefix));
}
printer_->Print(
"_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, '$module_name$', "
@@ -386,7 +389,8 @@
std::string module_name = ModuleName(filename);
std::string module_alias = ModuleAlias(filename);
if (!opensource_runtime_) {
- module_name = StripPrefixString(module_name, kThirdPartyPrefix);
+ module_name =
+ std::string(absl::StripPrefix(module_name, kThirdPartyPrefix));
}
if (ContainsPythonKeyword(module_name)) {
// If the module path contains a Python keyword, we have to quote the
@@ -419,7 +423,8 @@
for (int i = 0; i < file_->public_dependency_count(); ++i) {
std::string module_name = ModuleName(file_->public_dependency(i)->name());
if (!opensource_runtime_) {
- module_name = StripPrefixString(module_name, kThirdPartyPrefix);
+ module_name =
+ std::string(absl::StripPrefix(module_name, kThirdPartyPrefix));
}
printer_->Print("from $module$ import *\n", "module", module_name);
}
@@ -592,7 +597,8 @@
kDescriptorKey, "descriptor_name", name);
std::string module_name = ModuleName(file_->name());
if (!opensource_runtime_) {
- module_name = StripPrefixString(module_name, kThirdPartyPrefix);
+ module_name =
+ std::string(absl::StripPrefix(module_name, kThirdPartyPrefix));
}
printer_->Print("__module__ = '$module_name$'\n", "module_name", module_name);
}
@@ -784,7 +790,8 @@
printer_->Print(m, "'$descriptor_key$' : $descriptor_name$,\n");
std::string module_name = ModuleName(file_->name());
if (!opensource_runtime_) {
- module_name = StripPrefixString(module_name, kThirdPartyPrefix);
+ module_name =
+ std::string(absl::StripPrefix(module_name, kThirdPartyPrefix));
}
printer_->Print("'__module__' : '$module_name$'\n", "module_name",
module_name);
diff --git a/src/google/protobuf/compiler/python/helpers.cc b/src/google/protobuf/compiler/python/helpers.cc
index 711d555..e58ed9c 100644
--- a/src/google/protobuf/compiler/python/helpers.cc
+++ b/src/google/protobuf/compiler/python/helpers.cc
@@ -32,9 +32,11 @@
#include <algorithm>
-#include "google/protobuf/stubs/strutil.h"
#include "absl/strings/escaping.h"
+#include "absl/strings/match.h"
+#include "absl/strings/str_replace.h"
#include "absl/strings/str_split.h"
+#include "absl/strings/strip.h"
#include "google/protobuf/compiler/code_generator.h"
#include "google/protobuf/descriptor.h"
#include "google/protobuf/descriptor.pb.h"
@@ -47,8 +49,7 @@
// Returns the Python module name expected for a given .proto filename.
std::string ModuleName(const std::string& filename) {
std::string basename = StripProto(filename);
- ReplaceCharacters(&basename, "-", '_');
- ReplaceCharacters(&basename, "/", '.');
+ absl::StrReplaceAll({{"-", "_"}, {"/", "."}}, &basename);
return basename + "_pb2";
}
@@ -94,7 +95,7 @@
const std::string& suffix) {
std::string module_name = ModuleName(file_des->name());
std::string filename = module_name;
- ReplaceCharacters(&filename, ".", '/');
+ absl::StrReplaceAll({{".", "/"}}, &filename);
filename += suffix;
return filename;
}
diff --git a/src/google/protobuf/compiler/python/helpers.h b/src/google/protobuf/compiler/python/helpers.h
index 1fff3c9..3741fbb 100644
--- a/src/google/protobuf/compiler/python/helpers.h
+++ b/src/google/protobuf/compiler/python/helpers.h
@@ -42,7 +42,6 @@
namespace compiler {
namespace python {
-
std::string ModuleName(const std::string& filename);
std::string StrippedModuleName(const std::string& filename);
bool ContainsPythonKeyword(const std::string& module_name);
diff --git a/src/google/protobuf/compiler/python/pyi_generator.cc b/src/google/protobuf/compiler/python/pyi_generator.cc
index 7c723ef..b09ceb2 100644
--- a/src/google/protobuf/compiler/python/pyi_generator.cc
+++ b/src/google/protobuf/compiler/python/pyi_generator.cc
@@ -34,7 +34,7 @@
#include <utility>
#include "absl/strings/ascii.h"
-#include "google/protobuf/stubs/strutil.h"
+#include "absl/strings/match.h"
#include "absl/strings/str_split.h"
#include "google/protobuf/compiler/python/helpers.h"
#include "google/protobuf/descriptor.h"
@@ -577,7 +577,7 @@
for (const std::pair<std::string, std::string>& option : options) {
if (option.first == "annotate_code") {
annotate_code = true;
- } else if (HasSuffixString(option.first, ".pyi")) {
+ } else if (absl::EndsWith(option.first, ".pyi")) {
filename = option.first;
} else {
*error = "Unknown generator option: " + option.first;
diff --git a/src/google/protobuf/descriptor.cc b/src/google/protobuf/descriptor.cc
index 81412ff..9048cc6 100644
--- a/src/google/protobuf/descriptor.cc
+++ b/src/google/protobuf/descriptor.cc
@@ -2506,12 +2506,7 @@
// CopyTo methods ====================================================
void FileDescriptor::CopyTo(FileDescriptorProto* proto) const {
- proto->set_name(name());
- if (!package().empty()) proto->set_package(package());
- // TODO(liujisi): Also populate when syntax="proto2".
- if (syntax() == SYNTAX_PROTO3
- ) proto->set_syntax(SyntaxName(syntax()));
-
+ CopyHeadingTo(proto);
for (int i = 0; i < dependency_count(); i++) {
proto->add_dependency(dependency(i)->name());
@@ -2543,6 +2538,19 @@
}
}
+void FileDescriptor::CopyHeadingTo(FileDescriptorProto* proto) const {
+ proto->set_name(name());
+ if (!package().empty()) {
+ proto->set_package(package());
+ }
+
+ // TODO(liujisi): Also populate when syntax="proto2".
+ if (syntax() == SYNTAX_PROTO3
+ ) {
+ proto->set_syntax(SyntaxName(syntax()));
+ }
+}
+
void FileDescriptor::CopyJsonNameTo(FileDescriptorProto* proto) const {
if (message_type_count() != proto->message_type_size() ||
extension_count() != proto->extension_size()) {
@@ -2901,7 +2909,7 @@
// the DebugString() output.
std::string FormatComment(const std::string& comment_text) {
std::string stripped_comment = comment_text;
- StripWhitespace(&stripped_comment);
+ absl::StripAsciiWhitespace(&stripped_comment);
std::vector<std::string> lines = absl::StrSplit(stripped_comment, "\n");
std::string output;
for (const std::string& line : lines) {
@@ -4206,7 +4214,7 @@
bool DescriptorBuilder::IsInPackage(const FileDescriptor* file,
const std::string& package_name) {
- return HasPrefixString(file->package(), package_name) &&
+ return absl::StartsWith(file->package(), package_name) &&
(file->package().size() == package_name.size() ||
file->package()[package_name.size()] == '.');
}
diff --git a/src/google/protobuf/descriptor.h b/src/google/protobuf/descriptor.h
index dfe8d42..5a8b5f3 100644
--- a/src/google/protobuf/descriptor.h
+++ b/src/google/protobuf/descriptor.h
@@ -761,6 +761,10 @@
// Reflection::HasField() is semantically meaningful.
bool has_presence() const;
+ // Returns true if this TYPE_STRING-typed field requires UTF-8 validation on
+ // parse.
+ bool requires_utf8_validation() const;
+
// Index of this field within the message's field array, or the file or
// extension scope's extensions array.
int index() const;
@@ -1143,6 +1147,13 @@
// with AllowUnknownDependencies() set.
bool is_placeholder() const;
+ // Returns true whether this is a "closed" enum, meaning that it:
+ // - Has a fixed set of named values.
+ // - Encountering values not in this set causes them to be treated as unknown
+ // fields.
+ // - The first value (i.e., the default) may be nonzero.
+ bool is_closed() const;
+
// Reserved fields -------------------------------------------------
// A range of reserved field numbers.
@@ -1650,6 +1661,9 @@
// Fill the json_name field of FieldDescriptorProto for all fields. Can only
// be called after CopyTo().
void CopyJsonNameTo(FileDescriptorProto* proto) const;
+ // Fills in the file-level settings of this file (e.g. syntax, package,
+ // file options) to `proto`.
+ void CopyHeadingTo(FileDescriptorProto* proto) const;
// See Descriptor::DebugString().
std::string DebugString() const;
@@ -2200,6 +2214,10 @@
const EnumDescriptor::ReservedRange*)
PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, reserved_name_count, int)
+inline bool EnumDescriptor::is_closed() const {
+ return file()->syntax() != FileDescriptor::SYNTAX_PROTO3;
+}
+
PROTOBUF_DEFINE_NAME_ACCESSOR(EnumValueDescriptor)
PROTOBUF_DEFINE_ACCESSOR(EnumValueDescriptor, number, int)
PROTOBUF_DEFINE_ACCESSOR(EnumValueDescriptor, type, const EnumDescriptor*)
@@ -2364,6 +2382,11 @@
file()->syntax() == FileDescriptor::SYNTAX_PROTO2;
}
+inline bool FieldDescriptor::requires_utf8_validation() const {
+ return type() == TYPE_STRING &&
+ file()->syntax() == FileDescriptor::SYNTAX_PROTO3;
+}
+
// To save space, index() is computed by looking at the descriptor's position
// in the parent's array of children.
inline int FieldDescriptor::index() const {
diff --git a/src/google/protobuf/descriptor.pb.cc b/src/google/protobuf/descriptor.pb.cc
index b8a24a9..7d17e6b 100644
--- a/src/google/protobuf/descriptor.pb.cc
+++ b/src/google/protobuf/descriptor.pb.cc
@@ -1,10 +1,9 @@
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: google/protobuf/descriptor.proto
-#include <google/protobuf/descriptor.pb.h>
+#include "google/protobuf/descriptor.pb.h"
#include <algorithm>
-
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/extension_set.h"
#include "google/protobuf/wire_format_lite.h"
@@ -13,27 +12,27 @@
#include "google/protobuf/reflection_ops.h"
#include "google/protobuf/wire_format.h"
// @@protoc_insertion_point(includes)
+
+// Must be included last.
#include "google/protobuf/port_def.inc"
-
PROTOBUF_PRAGMA_INIT_SEG
-
namespace _pb = ::PROTOBUF_NAMESPACE_ID;
-namespace _pbi = _pb::internal;
-
+namespace _pbi = ::PROTOBUF_NAMESPACE_ID::internal;
PROTOBUF_NAMESPACE_OPEN
PROTOBUF_CONSTEXPR FileDescriptorSet::FileDescriptorSet(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_.file_)*/{}
, /*decltype(_impl_._cached_size_)*/{}} {}
struct FileDescriptorSetDefaultTypeInternal {
- PROTOBUF_CONSTEXPR FileDescriptorSetDefaultTypeInternal()
- : _instance(::_pbi::ConstantInitialized{}) {}
+ PROTOBUF_CONSTEXPR FileDescriptorSetDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
~FileDescriptorSetDefaultTypeInternal() {}
union {
FileDescriptorSet _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FileDescriptorSetDefaultTypeInternal _FileDescriptorSet_default_instance_;
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FileDescriptorSetDefaultTypeInternal _FileDescriptorSet_default_instance_;
PROTOBUF_CONSTEXPR FileDescriptorProto::FileDescriptorProto(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_._has_bits_)*/{}
@@ -52,14 +51,15 @@
, /*decltype(_impl_.options_)*/nullptr
, /*decltype(_impl_.source_code_info_)*/nullptr} {}
struct FileDescriptorProtoDefaultTypeInternal {
- PROTOBUF_CONSTEXPR FileDescriptorProtoDefaultTypeInternal()
- : _instance(::_pbi::ConstantInitialized{}) {}
+ PROTOBUF_CONSTEXPR FileDescriptorProtoDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
~FileDescriptorProtoDefaultTypeInternal() {}
union {
FileDescriptorProto _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FileDescriptorProtoDefaultTypeInternal _FileDescriptorProto_default_instance_;
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FileDescriptorProtoDefaultTypeInternal _FileDescriptorProto_default_instance_;
PROTOBUF_CONSTEXPR DescriptorProto_ExtensionRange::DescriptorProto_ExtensionRange(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_._has_bits_)*/{}
@@ -68,14 +68,15 @@
, /*decltype(_impl_.start_)*/0
, /*decltype(_impl_.end_)*/0} {}
struct DescriptorProto_ExtensionRangeDefaultTypeInternal {
- PROTOBUF_CONSTEXPR DescriptorProto_ExtensionRangeDefaultTypeInternal()
- : _instance(::_pbi::ConstantInitialized{}) {}
+ PROTOBUF_CONSTEXPR DescriptorProto_ExtensionRangeDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
~DescriptorProto_ExtensionRangeDefaultTypeInternal() {}
union {
DescriptorProto_ExtensionRange _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DescriptorProto_ExtensionRangeDefaultTypeInternal _DescriptorProto_ExtensionRange_default_instance_;
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DescriptorProto_ExtensionRangeDefaultTypeInternal _DescriptorProto_ExtensionRange_default_instance_;
PROTOBUF_CONSTEXPR DescriptorProto_ReservedRange::DescriptorProto_ReservedRange(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_._has_bits_)*/{}
@@ -83,14 +84,15 @@
, /*decltype(_impl_.start_)*/0
, /*decltype(_impl_.end_)*/0} {}
struct DescriptorProto_ReservedRangeDefaultTypeInternal {
- PROTOBUF_CONSTEXPR DescriptorProto_ReservedRangeDefaultTypeInternal()
- : _instance(::_pbi::ConstantInitialized{}) {}
+ PROTOBUF_CONSTEXPR DescriptorProto_ReservedRangeDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
~DescriptorProto_ReservedRangeDefaultTypeInternal() {}
union {
DescriptorProto_ReservedRange _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DescriptorProto_ReservedRangeDefaultTypeInternal _DescriptorProto_ReservedRange_default_instance_;
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DescriptorProto_ReservedRangeDefaultTypeInternal _DescriptorProto_ReservedRange_default_instance_;
PROTOBUF_CONSTEXPR DescriptorProto::DescriptorProto(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_._has_bits_)*/{}
@@ -106,28 +108,30 @@
, /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
, /*decltype(_impl_.options_)*/nullptr} {}
struct DescriptorProtoDefaultTypeInternal {
- PROTOBUF_CONSTEXPR DescriptorProtoDefaultTypeInternal()
- : _instance(::_pbi::ConstantInitialized{}) {}
+ PROTOBUF_CONSTEXPR DescriptorProtoDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
~DescriptorProtoDefaultTypeInternal() {}
union {
DescriptorProto _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DescriptorProtoDefaultTypeInternal _DescriptorProto_default_instance_;
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DescriptorProtoDefaultTypeInternal _DescriptorProto_default_instance_;
PROTOBUF_CONSTEXPR ExtensionRangeOptions::ExtensionRangeOptions(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_._extensions_)*/{}
, /*decltype(_impl_.uninterpreted_option_)*/{}
, /*decltype(_impl_._cached_size_)*/{}} {}
struct ExtensionRangeOptionsDefaultTypeInternal {
- PROTOBUF_CONSTEXPR ExtensionRangeOptionsDefaultTypeInternal()
- : _instance(::_pbi::ConstantInitialized{}) {}
+ PROTOBUF_CONSTEXPR ExtensionRangeOptionsDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
~ExtensionRangeOptionsDefaultTypeInternal() {}
union {
ExtensionRangeOptions _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ExtensionRangeOptionsDefaultTypeInternal _ExtensionRangeOptions_default_instance_;
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ExtensionRangeOptionsDefaultTypeInternal _ExtensionRangeOptions_default_instance_;
PROTOBUF_CONSTEXPR FieldDescriptorProto::FieldDescriptorProto(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_._has_bits_)*/{}
@@ -144,14 +148,15 @@
, /*decltype(_impl_.label_)*/1
, /*decltype(_impl_.type_)*/1} {}
struct FieldDescriptorProtoDefaultTypeInternal {
- PROTOBUF_CONSTEXPR FieldDescriptorProtoDefaultTypeInternal()
- : _instance(::_pbi::ConstantInitialized{}) {}
+ PROTOBUF_CONSTEXPR FieldDescriptorProtoDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
~FieldDescriptorProtoDefaultTypeInternal() {}
union {
FieldDescriptorProto _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FieldDescriptorProtoDefaultTypeInternal _FieldDescriptorProto_default_instance_;
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FieldDescriptorProtoDefaultTypeInternal _FieldDescriptorProto_default_instance_;
PROTOBUF_CONSTEXPR OneofDescriptorProto::OneofDescriptorProto(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_._has_bits_)*/{}
@@ -159,14 +164,15 @@
, /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
, /*decltype(_impl_.options_)*/nullptr} {}
struct OneofDescriptorProtoDefaultTypeInternal {
- PROTOBUF_CONSTEXPR OneofDescriptorProtoDefaultTypeInternal()
- : _instance(::_pbi::ConstantInitialized{}) {}
+ PROTOBUF_CONSTEXPR OneofDescriptorProtoDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
~OneofDescriptorProtoDefaultTypeInternal() {}
union {
OneofDescriptorProto _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OneofDescriptorProtoDefaultTypeInternal _OneofDescriptorProto_default_instance_;
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OneofDescriptorProtoDefaultTypeInternal _OneofDescriptorProto_default_instance_;
PROTOBUF_CONSTEXPR EnumDescriptorProto_EnumReservedRange::EnumDescriptorProto_EnumReservedRange(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_._has_bits_)*/{}
@@ -174,14 +180,15 @@
, /*decltype(_impl_.start_)*/0
, /*decltype(_impl_.end_)*/0} {}
struct EnumDescriptorProto_EnumReservedRangeDefaultTypeInternal {
- PROTOBUF_CONSTEXPR EnumDescriptorProto_EnumReservedRangeDefaultTypeInternal()
- : _instance(::_pbi::ConstantInitialized{}) {}
+ PROTOBUF_CONSTEXPR EnumDescriptorProto_EnumReservedRangeDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
~EnumDescriptorProto_EnumReservedRangeDefaultTypeInternal() {}
union {
EnumDescriptorProto_EnumReservedRange _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EnumDescriptorProto_EnumReservedRangeDefaultTypeInternal _EnumDescriptorProto_EnumReservedRange_default_instance_;
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EnumDescriptorProto_EnumReservedRangeDefaultTypeInternal _EnumDescriptorProto_EnumReservedRange_default_instance_;
PROTOBUF_CONSTEXPR EnumDescriptorProto::EnumDescriptorProto(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_._has_bits_)*/{}
@@ -192,14 +199,15 @@
, /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
, /*decltype(_impl_.options_)*/nullptr} {}
struct EnumDescriptorProtoDefaultTypeInternal {
- PROTOBUF_CONSTEXPR EnumDescriptorProtoDefaultTypeInternal()
- : _instance(::_pbi::ConstantInitialized{}) {}
+ PROTOBUF_CONSTEXPR EnumDescriptorProtoDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
~EnumDescriptorProtoDefaultTypeInternal() {}
union {
EnumDescriptorProto _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EnumDescriptorProtoDefaultTypeInternal _EnumDescriptorProto_default_instance_;
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EnumDescriptorProtoDefaultTypeInternal _EnumDescriptorProto_default_instance_;
PROTOBUF_CONSTEXPR EnumValueDescriptorProto::EnumValueDescriptorProto(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_._has_bits_)*/{}
@@ -208,14 +216,15 @@
, /*decltype(_impl_.options_)*/nullptr
, /*decltype(_impl_.number_)*/0} {}
struct EnumValueDescriptorProtoDefaultTypeInternal {
- PROTOBUF_CONSTEXPR EnumValueDescriptorProtoDefaultTypeInternal()
- : _instance(::_pbi::ConstantInitialized{}) {}
+ PROTOBUF_CONSTEXPR EnumValueDescriptorProtoDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
~EnumValueDescriptorProtoDefaultTypeInternal() {}
union {
EnumValueDescriptorProto _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EnumValueDescriptorProtoDefaultTypeInternal _EnumValueDescriptorProto_default_instance_;
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EnumValueDescriptorProtoDefaultTypeInternal _EnumValueDescriptorProto_default_instance_;
PROTOBUF_CONSTEXPR ServiceDescriptorProto::ServiceDescriptorProto(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_._has_bits_)*/{}
@@ -224,14 +233,15 @@
, /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
, /*decltype(_impl_.options_)*/nullptr} {}
struct ServiceDescriptorProtoDefaultTypeInternal {
- PROTOBUF_CONSTEXPR ServiceDescriptorProtoDefaultTypeInternal()
- : _instance(::_pbi::ConstantInitialized{}) {}
+ PROTOBUF_CONSTEXPR ServiceDescriptorProtoDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
~ServiceDescriptorProtoDefaultTypeInternal() {}
union {
ServiceDescriptorProto _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ServiceDescriptorProtoDefaultTypeInternal _ServiceDescriptorProto_default_instance_;
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ServiceDescriptorProtoDefaultTypeInternal _ServiceDescriptorProto_default_instance_;
PROTOBUF_CONSTEXPR MethodDescriptorProto::MethodDescriptorProto(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_._has_bits_)*/{}
@@ -243,14 +253,15 @@
, /*decltype(_impl_.client_streaming_)*/false
, /*decltype(_impl_.server_streaming_)*/false} {}
struct MethodDescriptorProtoDefaultTypeInternal {
- PROTOBUF_CONSTEXPR MethodDescriptorProtoDefaultTypeInternal()
- : _instance(::_pbi::ConstantInitialized{}) {}
+ PROTOBUF_CONSTEXPR MethodDescriptorProtoDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
~MethodDescriptorProtoDefaultTypeInternal() {}
union {
MethodDescriptorProto _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MethodDescriptorProtoDefaultTypeInternal _MethodDescriptorProto_default_instance_;
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MethodDescriptorProtoDefaultTypeInternal _MethodDescriptorProto_default_instance_;
PROTOBUF_CONSTEXPR FileOptions::FileOptions(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_._extensions_)*/{}
@@ -278,14 +289,15 @@
, /*decltype(_impl_.optimize_for_)*/1
, /*decltype(_impl_.cc_enable_arenas_)*/true} {}
struct FileOptionsDefaultTypeInternal {
- PROTOBUF_CONSTEXPR FileOptionsDefaultTypeInternal()
- : _instance(::_pbi::ConstantInitialized{}) {}
+ PROTOBUF_CONSTEXPR FileOptionsDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
~FileOptionsDefaultTypeInternal() {}
union {
FileOptions _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FileOptionsDefaultTypeInternal _FileOptions_default_instance_;
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FileOptionsDefaultTypeInternal _FileOptions_default_instance_;
PROTOBUF_CONSTEXPR MessageOptions::MessageOptions(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_._extensions_)*/{}
@@ -297,14 +309,15 @@
, /*decltype(_impl_.deprecated_)*/false
, /*decltype(_impl_.map_entry_)*/false} {}
struct MessageOptionsDefaultTypeInternal {
- PROTOBUF_CONSTEXPR MessageOptionsDefaultTypeInternal()
- : _instance(::_pbi::ConstantInitialized{}) {}
+ PROTOBUF_CONSTEXPR MessageOptionsDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
~MessageOptionsDefaultTypeInternal() {}
union {
MessageOptions _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MessageOptionsDefaultTypeInternal _MessageOptions_default_instance_;
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MessageOptionsDefaultTypeInternal _MessageOptions_default_instance_;
PROTOBUF_CONSTEXPR FieldOptions::FieldOptions(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_._extensions_)*/{}
@@ -319,28 +332,30 @@
, /*decltype(_impl_.deprecated_)*/false
, /*decltype(_impl_.weak_)*/false} {}
struct FieldOptionsDefaultTypeInternal {
- PROTOBUF_CONSTEXPR FieldOptionsDefaultTypeInternal()
- : _instance(::_pbi::ConstantInitialized{}) {}
+ PROTOBUF_CONSTEXPR FieldOptionsDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
~FieldOptionsDefaultTypeInternal() {}
union {
FieldOptions _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FieldOptionsDefaultTypeInternal _FieldOptions_default_instance_;
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FieldOptionsDefaultTypeInternal _FieldOptions_default_instance_;
PROTOBUF_CONSTEXPR OneofOptions::OneofOptions(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_._extensions_)*/{}
, /*decltype(_impl_.uninterpreted_option_)*/{}
, /*decltype(_impl_._cached_size_)*/{}} {}
struct OneofOptionsDefaultTypeInternal {
- PROTOBUF_CONSTEXPR OneofOptionsDefaultTypeInternal()
- : _instance(::_pbi::ConstantInitialized{}) {}
+ PROTOBUF_CONSTEXPR OneofOptionsDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
~OneofOptionsDefaultTypeInternal() {}
union {
OneofOptions _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OneofOptionsDefaultTypeInternal _OneofOptions_default_instance_;
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OneofOptionsDefaultTypeInternal _OneofOptions_default_instance_;
PROTOBUF_CONSTEXPR EnumOptions::EnumOptions(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_._extensions_)*/{}
@@ -350,14 +365,15 @@
, /*decltype(_impl_.allow_alias_)*/false
, /*decltype(_impl_.deprecated_)*/false} {}
struct EnumOptionsDefaultTypeInternal {
- PROTOBUF_CONSTEXPR EnumOptionsDefaultTypeInternal()
- : _instance(::_pbi::ConstantInitialized{}) {}
+ PROTOBUF_CONSTEXPR EnumOptionsDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
~EnumOptionsDefaultTypeInternal() {}
union {
EnumOptions _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EnumOptionsDefaultTypeInternal _EnumOptions_default_instance_;
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EnumOptionsDefaultTypeInternal _EnumOptions_default_instance_;
PROTOBUF_CONSTEXPR EnumValueOptions::EnumValueOptions(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_._extensions_)*/{}
@@ -366,14 +382,15 @@
, /*decltype(_impl_.uninterpreted_option_)*/{}
, /*decltype(_impl_.deprecated_)*/false} {}
struct EnumValueOptionsDefaultTypeInternal {
- PROTOBUF_CONSTEXPR EnumValueOptionsDefaultTypeInternal()
- : _instance(::_pbi::ConstantInitialized{}) {}
+ PROTOBUF_CONSTEXPR EnumValueOptionsDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
~EnumValueOptionsDefaultTypeInternal() {}
union {
EnumValueOptions _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EnumValueOptionsDefaultTypeInternal _EnumValueOptions_default_instance_;
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EnumValueOptionsDefaultTypeInternal _EnumValueOptions_default_instance_;
PROTOBUF_CONSTEXPR ServiceOptions::ServiceOptions(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_._extensions_)*/{}
@@ -382,14 +399,15 @@
, /*decltype(_impl_.uninterpreted_option_)*/{}
, /*decltype(_impl_.deprecated_)*/false} {}
struct ServiceOptionsDefaultTypeInternal {
- PROTOBUF_CONSTEXPR ServiceOptionsDefaultTypeInternal()
- : _instance(::_pbi::ConstantInitialized{}) {}
+ PROTOBUF_CONSTEXPR ServiceOptionsDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
~ServiceOptionsDefaultTypeInternal() {}
union {
ServiceOptions _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ServiceOptionsDefaultTypeInternal _ServiceOptions_default_instance_;
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ServiceOptionsDefaultTypeInternal _ServiceOptions_default_instance_;
PROTOBUF_CONSTEXPR MethodOptions::MethodOptions(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_._extensions_)*/{}
@@ -399,14 +417,15 @@
, /*decltype(_impl_.deprecated_)*/false
, /*decltype(_impl_.idempotency_level_)*/0} {}
struct MethodOptionsDefaultTypeInternal {
- PROTOBUF_CONSTEXPR MethodOptionsDefaultTypeInternal()
- : _instance(::_pbi::ConstantInitialized{}) {}
+ PROTOBUF_CONSTEXPR MethodOptionsDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
~MethodOptionsDefaultTypeInternal() {}
union {
MethodOptions _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MethodOptionsDefaultTypeInternal _MethodOptions_default_instance_;
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MethodOptionsDefaultTypeInternal _MethodOptions_default_instance_;
PROTOBUF_CONSTEXPR UninterpretedOption_NamePart::UninterpretedOption_NamePart(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_._has_bits_)*/{}
@@ -414,14 +433,15 @@
, /*decltype(_impl_.name_part_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
, /*decltype(_impl_.is_extension_)*/false} {}
struct UninterpretedOption_NamePartDefaultTypeInternal {
- PROTOBUF_CONSTEXPR UninterpretedOption_NamePartDefaultTypeInternal()
- : _instance(::_pbi::ConstantInitialized{}) {}
+ PROTOBUF_CONSTEXPR UninterpretedOption_NamePartDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
~UninterpretedOption_NamePartDefaultTypeInternal() {}
union {
UninterpretedOption_NamePart _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UninterpretedOption_NamePartDefaultTypeInternal _UninterpretedOption_NamePart_default_instance_;
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UninterpretedOption_NamePartDefaultTypeInternal _UninterpretedOption_NamePart_default_instance_;
PROTOBUF_CONSTEXPR UninterpretedOption::UninterpretedOption(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_._has_bits_)*/{}
@@ -434,14 +454,15 @@
, /*decltype(_impl_.negative_int_value_)*/int64_t{0}
, /*decltype(_impl_.double_value_)*/0} {}
struct UninterpretedOptionDefaultTypeInternal {
- PROTOBUF_CONSTEXPR UninterpretedOptionDefaultTypeInternal()
- : _instance(::_pbi::ConstantInitialized{}) {}
+ PROTOBUF_CONSTEXPR UninterpretedOptionDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
~UninterpretedOptionDefaultTypeInternal() {}
union {
UninterpretedOption _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UninterpretedOptionDefaultTypeInternal _UninterpretedOption_default_instance_;
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UninterpretedOptionDefaultTypeInternal _UninterpretedOption_default_instance_;
PROTOBUF_CONSTEXPR SourceCodeInfo_Location::SourceCodeInfo_Location(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_._has_bits_)*/{}
@@ -454,27 +475,29 @@
, /*decltype(_impl_.leading_comments_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
, /*decltype(_impl_.trailing_comments_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
struct SourceCodeInfo_LocationDefaultTypeInternal {
- PROTOBUF_CONSTEXPR SourceCodeInfo_LocationDefaultTypeInternal()
- : _instance(::_pbi::ConstantInitialized{}) {}
+ PROTOBUF_CONSTEXPR SourceCodeInfo_LocationDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
~SourceCodeInfo_LocationDefaultTypeInternal() {}
union {
SourceCodeInfo_Location _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SourceCodeInfo_LocationDefaultTypeInternal _SourceCodeInfo_Location_default_instance_;
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SourceCodeInfo_LocationDefaultTypeInternal _SourceCodeInfo_Location_default_instance_;
PROTOBUF_CONSTEXPR SourceCodeInfo::SourceCodeInfo(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_.location_)*/{}
, /*decltype(_impl_._cached_size_)*/{}} {}
struct SourceCodeInfoDefaultTypeInternal {
- PROTOBUF_CONSTEXPR SourceCodeInfoDefaultTypeInternal()
- : _instance(::_pbi::ConstantInitialized{}) {}
+ PROTOBUF_CONSTEXPR SourceCodeInfoDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
~SourceCodeInfoDefaultTypeInternal() {}
union {
SourceCodeInfo _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SourceCodeInfoDefaultTypeInternal _SourceCodeInfo_default_instance_;
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SourceCodeInfoDefaultTypeInternal _SourceCodeInfo_default_instance_;
PROTOBUF_CONSTEXPR GeneratedCodeInfo_Annotation::GeneratedCodeInfo_Annotation(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_._has_bits_)*/{}
@@ -486,734 +509,759 @@
, /*decltype(_impl_.end_)*/0
, /*decltype(_impl_.semantic_)*/0} {}
struct GeneratedCodeInfo_AnnotationDefaultTypeInternal {
- PROTOBUF_CONSTEXPR GeneratedCodeInfo_AnnotationDefaultTypeInternal()
- : _instance(::_pbi::ConstantInitialized{}) {}
+ PROTOBUF_CONSTEXPR GeneratedCodeInfo_AnnotationDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
~GeneratedCodeInfo_AnnotationDefaultTypeInternal() {}
union {
GeneratedCodeInfo_Annotation _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GeneratedCodeInfo_AnnotationDefaultTypeInternal _GeneratedCodeInfo_Annotation_default_instance_;
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GeneratedCodeInfo_AnnotationDefaultTypeInternal _GeneratedCodeInfo_Annotation_default_instance_;
PROTOBUF_CONSTEXPR GeneratedCodeInfo::GeneratedCodeInfo(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_.annotation_)*/{}
, /*decltype(_impl_._cached_size_)*/{}} {}
struct GeneratedCodeInfoDefaultTypeInternal {
- PROTOBUF_CONSTEXPR GeneratedCodeInfoDefaultTypeInternal()
- : _instance(::_pbi::ConstantInitialized{}) {}
+ PROTOBUF_CONSTEXPR GeneratedCodeInfoDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
~GeneratedCodeInfoDefaultTypeInternal() {}
union {
GeneratedCodeInfo _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GeneratedCodeInfoDefaultTypeInternal _GeneratedCodeInfo_default_instance_;
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+ PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GeneratedCodeInfoDefaultTypeInternal _GeneratedCodeInfo_default_instance_;
PROTOBUF_NAMESPACE_CLOSE
static ::_pb::Metadata file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[27];
static const ::_pb::EnumDescriptor* file_level_enum_descriptors_google_2fprotobuf_2fdescriptor_2eproto[7];
-static constexpr ::_pb::ServiceDescriptor const** file_level_service_descriptors_google_2fprotobuf_2fdescriptor_2eproto = nullptr;
-
-const uint32_t TableStruct_google_2fprotobuf_2fdescriptor_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
- ~0u, // no _has_bits_
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorSet, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- ~0u, // no _inlined_string_donated_
- ~0u, // no _split_
- ~0u, // no sizeof(Split)
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorSet, _impl_.file_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto, _impl_._has_bits_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- ~0u, // no _inlined_string_donated_
- ~0u, // no _split_
- ~0u, // no sizeof(Split)
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto, _impl_.name_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto, _impl_.package_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto, _impl_.dependency_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto, _impl_.public_dependency_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto, _impl_.weak_dependency_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto, _impl_.message_type_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto, _impl_.enum_type_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto, _impl_.service_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto, _impl_.extension_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto, _impl_.options_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto, _impl_.source_code_info_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto, _impl_.syntax_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto, _impl_.edition_),
- 0,
- 1,
- ~0u,
- ~0u,
- ~0u,
- ~0u,
- ~0u,
- ~0u,
- ~0u,
- 4,
- 5,
- 2,
- 3,
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange, _impl_._has_bits_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- ~0u, // no _inlined_string_donated_
- ~0u, // no _split_
- ~0u, // no sizeof(Split)
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange, _impl_.start_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange, _impl_.end_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange, _impl_.options_),
- 1,
- 2,
- 0,
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange, _impl_._has_bits_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- ~0u, // no _inlined_string_donated_
- ~0u, // no _split_
- ~0u, // no sizeof(Split)
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange, _impl_.start_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange, _impl_.end_),
- 0,
- 1,
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto, _impl_._has_bits_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- ~0u, // no _inlined_string_donated_
- ~0u, // no _split_
- ~0u, // no sizeof(Split)
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto, _impl_.name_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto, _impl_.field_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto, _impl_.extension_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto, _impl_.nested_type_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto, _impl_.enum_type_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto, _impl_.extension_range_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto, _impl_.oneof_decl_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto, _impl_.options_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto, _impl_.reserved_range_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto, _impl_.reserved_name_),
- 0,
- ~0u,
- ~0u,
- ~0u,
- ~0u,
- ~0u,
- ~0u,
- 1,
- ~0u,
- ~0u,
- ~0u, // no _has_bits_
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions, _internal_metadata_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions, _impl_._extensions_),
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- ~0u, // no _inlined_string_donated_
- ~0u, // no _split_
- ~0u, // no sizeof(Split)
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions, _impl_.uninterpreted_option_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto, _impl_._has_bits_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- ~0u, // no _inlined_string_donated_
- ~0u, // no _split_
- ~0u, // no sizeof(Split)
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto, _impl_.name_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto, _impl_.number_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto, _impl_.label_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto, _impl_.type_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto, _impl_.type_name_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto, _impl_.extendee_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto, _impl_.default_value_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto, _impl_.oneof_index_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto, _impl_.json_name_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto, _impl_.options_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto, _impl_.proto3_optional_),
- 0,
- 6,
- 9,
- 10,
- 2,
- 1,
- 3,
- 7,
- 4,
- 5,
- 8,
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto, _impl_._has_bits_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- ~0u, // no _inlined_string_donated_
- ~0u, // no _split_
- ~0u, // no sizeof(Split)
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto, _impl_.name_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto, _impl_.options_),
- 0,
- 1,
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange, _impl_._has_bits_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- ~0u, // no _inlined_string_donated_
- ~0u, // no _split_
- ~0u, // no sizeof(Split)
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange, _impl_.start_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange, _impl_.end_),
- 0,
- 1,
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto, _impl_._has_bits_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- ~0u, // no _inlined_string_donated_
- ~0u, // no _split_
- ~0u, // no sizeof(Split)
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto, _impl_.name_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto, _impl_.value_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto, _impl_.options_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto, _impl_.reserved_range_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto, _impl_.reserved_name_),
- 0,
- ~0u,
- 1,
- ~0u,
- ~0u,
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto, _impl_._has_bits_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- ~0u, // no _inlined_string_donated_
- ~0u, // no _split_
- ~0u, // no sizeof(Split)
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto, _impl_.name_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto, _impl_.number_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto, _impl_.options_),
- 0,
- 2,
- 1,
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto, _impl_._has_bits_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- ~0u, // no _inlined_string_donated_
- ~0u, // no _split_
- ~0u, // no sizeof(Split)
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto, _impl_.name_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto, _impl_.method_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto, _impl_.options_),
- 0,
- ~0u,
- 1,
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto, _impl_._has_bits_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- ~0u, // no _inlined_string_donated_
- ~0u, // no _split_
- ~0u, // no sizeof(Split)
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto, _impl_.name_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto, _impl_.input_type_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto, _impl_.output_type_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto, _impl_.options_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto, _impl_.client_streaming_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto, _impl_.server_streaming_),
- 0,
- 1,
- 2,
- 3,
- 4,
- 5,
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_._has_bits_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _internal_metadata_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_._extensions_),
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- ~0u, // no _inlined_string_donated_
- ~0u, // no _split_
- ~0u, // no sizeof(Split)
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.java_package_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.java_outer_classname_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.java_multiple_files_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.java_generate_equals_and_hash_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.java_string_check_utf8_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.optimize_for_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.go_package_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.cc_generic_services_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.java_generic_services_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.py_generic_services_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.php_generic_services_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.deprecated_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.cc_enable_arenas_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.objc_class_prefix_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.csharp_namespace_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.swift_prefix_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.php_class_prefix_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.php_namespace_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.php_metadata_namespace_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.ruby_package_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.uninterpreted_option_),
- 0,
- 1,
- 10,
- 11,
- 12,
- 18,
- 2,
- 13,
- 14,
- 15,
- 16,
- 17,
- 19,
- 3,
- 4,
- 5,
- 6,
- 7,
- 8,
- 9,
- ~0u,
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MessageOptions, _impl_._has_bits_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MessageOptions, _internal_metadata_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MessageOptions, _impl_._extensions_),
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- ~0u, // no _inlined_string_donated_
- ~0u, // no _split_
- ~0u, // no sizeof(Split)
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MessageOptions, _impl_.message_set_wire_format_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MessageOptions, _impl_.no_standard_descriptor_accessor_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MessageOptions, _impl_.deprecated_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MessageOptions, _impl_.map_entry_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MessageOptions, _impl_.uninterpreted_option_),
- 0,
- 1,
- 2,
- 3,
- ~0u,
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldOptions, _impl_._has_bits_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldOptions, _internal_metadata_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldOptions, _impl_._extensions_),
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- ~0u, // no _inlined_string_donated_
- ~0u, // no _split_
- ~0u, // no sizeof(Split)
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldOptions, _impl_.ctype_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldOptions, _impl_.packed_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldOptions, _impl_.jstype_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldOptions, _impl_.lazy_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldOptions, _impl_.unverified_lazy_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldOptions, _impl_.deprecated_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldOptions, _impl_.weak_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldOptions, _impl_.uninterpreted_option_),
- 0,
- 2,
- 1,
- 3,
- 4,
- 5,
- 6,
- ~0u,
- ~0u, // no _has_bits_
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::OneofOptions, _internal_metadata_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::OneofOptions, _impl_._extensions_),
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- ~0u, // no _inlined_string_donated_
- ~0u, // no _split_
- ~0u, // no sizeof(Split)
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::OneofOptions, _impl_.uninterpreted_option_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumOptions, _impl_._has_bits_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumOptions, _internal_metadata_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumOptions, _impl_._extensions_),
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- ~0u, // no _inlined_string_donated_
- ~0u, // no _split_
- ~0u, // no sizeof(Split)
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumOptions, _impl_.allow_alias_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumOptions, _impl_.deprecated_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumOptions, _impl_.uninterpreted_option_),
- 0,
- 1,
- ~0u,
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumValueOptions, _impl_._has_bits_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumValueOptions, _internal_metadata_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumValueOptions, _impl_._extensions_),
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- ~0u, // no _inlined_string_donated_
- ~0u, // no _split_
- ~0u, // no sizeof(Split)
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumValueOptions, _impl_.deprecated_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumValueOptions, _impl_.uninterpreted_option_),
- 0,
- ~0u,
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::ServiceOptions, _impl_._has_bits_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::ServiceOptions, _internal_metadata_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::ServiceOptions, _impl_._extensions_),
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- ~0u, // no _inlined_string_donated_
- ~0u, // no _split_
- ~0u, // no sizeof(Split)
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::ServiceOptions, _impl_.deprecated_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::ServiceOptions, _impl_.uninterpreted_option_),
- 0,
- ~0u,
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MethodOptions, _impl_._has_bits_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MethodOptions, _internal_metadata_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MethodOptions, _impl_._extensions_),
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- ~0u, // no _inlined_string_donated_
- ~0u, // no _split_
- ~0u, // no sizeof(Split)
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MethodOptions, _impl_.deprecated_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MethodOptions, _impl_.idempotency_level_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MethodOptions, _impl_.uninterpreted_option_),
- 0,
- 1,
- ~0u,
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart, _impl_._has_bits_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- ~0u, // no _inlined_string_donated_
- ~0u, // no _split_
- ~0u, // no sizeof(Split)
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart, _impl_.name_part_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart, _impl_.is_extension_),
- 0,
- 1,
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::UninterpretedOption, _impl_._has_bits_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::UninterpretedOption, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- ~0u, // no _inlined_string_donated_
- ~0u, // no _split_
- ~0u, // no sizeof(Split)
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::UninterpretedOption, _impl_.name_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::UninterpretedOption, _impl_.identifier_value_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::UninterpretedOption, _impl_.positive_int_value_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::UninterpretedOption, _impl_.negative_int_value_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::UninterpretedOption, _impl_.double_value_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::UninterpretedOption, _impl_.string_value_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::UninterpretedOption, _impl_.aggregate_value_),
- ~0u,
- 0,
- 3,
- 4,
- 5,
- 1,
- 2,
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location, _impl_._has_bits_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- ~0u, // no _inlined_string_donated_
- ~0u, // no _split_
- ~0u, // no sizeof(Split)
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location, _impl_.path_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location, _impl_.span_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location, _impl_.leading_comments_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location, _impl_.trailing_comments_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location, _impl_.leading_detached_comments_),
- ~0u,
- ~0u,
- 0,
- 1,
- ~0u,
- ~0u, // no _has_bits_
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::SourceCodeInfo, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- ~0u, // no _inlined_string_donated_
- ~0u, // no _split_
- ~0u, // no sizeof(Split)
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::SourceCodeInfo, _impl_.location_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation, _impl_._has_bits_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- ~0u, // no _inlined_string_donated_
- ~0u, // no _split_
- ~0u, // no sizeof(Split)
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation, _impl_.path_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation, _impl_.source_file_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation, _impl_.begin_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation, _impl_.end_),
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation, _impl_.semantic_),
- ~0u,
- 0,
- 1,
- 2,
- 3,
- ~0u, // no _has_bits_
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- ~0u, // no _inlined_string_donated_
- ~0u, // no _split_
- ~0u, // no sizeof(Split)
- PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo, _impl_.annotation_),
+static constexpr const ::_pb::ServiceDescriptor**
+ file_level_service_descriptors_google_2fprotobuf_2fdescriptor_2eproto = nullptr;
+const uint32_t TableStruct_google_2fprotobuf_2fdescriptor_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(
+ protodesc_cold) = {
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorSet, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ~0u, // no _split_
+ ~0u, // no sizeof(Split)
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorSet, _impl_.file_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto, _impl_._has_bits_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ~0u, // no _split_
+ ~0u, // no sizeof(Split)
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto, _impl_.name_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto, _impl_.package_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto, _impl_.dependency_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto, _impl_.public_dependency_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto, _impl_.weak_dependency_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto, _impl_.message_type_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto, _impl_.enum_type_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto, _impl_.service_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto, _impl_.extension_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto, _impl_.options_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto, _impl_.source_code_info_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto, _impl_.syntax_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto, _impl_.edition_),
+ 0,
+ 1,
+ ~0u,
+ ~0u,
+ ~0u,
+ ~0u,
+ ~0u,
+ ~0u,
+ ~0u,
+ 4,
+ 5,
+ 2,
+ 3,
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange, _impl_._has_bits_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ~0u, // no _split_
+ ~0u, // no sizeof(Split)
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange, _impl_.start_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange, _impl_.end_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange, _impl_.options_),
+ 1,
+ 2,
+ 0,
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange, _impl_._has_bits_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ~0u, // no _split_
+ ~0u, // no sizeof(Split)
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange, _impl_.start_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange, _impl_.end_),
+ 0,
+ 1,
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto, _impl_._has_bits_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ~0u, // no _split_
+ ~0u, // no sizeof(Split)
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto, _impl_.name_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto, _impl_.field_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto, _impl_.extension_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto, _impl_.nested_type_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto, _impl_.enum_type_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto, _impl_.extension_range_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto, _impl_.oneof_decl_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto, _impl_.options_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto, _impl_.reserved_range_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::DescriptorProto, _impl_.reserved_name_),
+ 0,
+ ~0u,
+ ~0u,
+ ~0u,
+ ~0u,
+ ~0u,
+ ~0u,
+ 1,
+ ~0u,
+ ~0u,
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions, _internal_metadata_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions, _impl_._extensions_),
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ~0u, // no _split_
+ ~0u, // no sizeof(Split)
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions, _impl_.uninterpreted_option_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto, _impl_._has_bits_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ~0u, // no _split_
+ ~0u, // no sizeof(Split)
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto, _impl_.name_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto, _impl_.number_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto, _impl_.label_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto, _impl_.type_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto, _impl_.type_name_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto, _impl_.extendee_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto, _impl_.default_value_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto, _impl_.oneof_index_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto, _impl_.json_name_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto, _impl_.options_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto, _impl_.proto3_optional_),
+ 0,
+ 6,
+ 9,
+ 10,
+ 2,
+ 1,
+ 3,
+ 7,
+ 4,
+ 5,
+ 8,
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto, _impl_._has_bits_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ~0u, // no _split_
+ ~0u, // no sizeof(Split)
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto, _impl_.name_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto, _impl_.options_),
+ 0,
+ 1,
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange, _impl_._has_bits_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ~0u, // no _split_
+ ~0u, // no sizeof(Split)
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange, _impl_.start_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange, _impl_.end_),
+ 0,
+ 1,
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto, _impl_._has_bits_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ~0u, // no _split_
+ ~0u, // no sizeof(Split)
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto, _impl_.name_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto, _impl_.value_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto, _impl_.options_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto, _impl_.reserved_range_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto, _impl_.reserved_name_),
+ 0,
+ ~0u,
+ 1,
+ ~0u,
+ ~0u,
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto, _impl_._has_bits_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ~0u, // no _split_
+ ~0u, // no sizeof(Split)
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto, _impl_.name_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto, _impl_.number_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto, _impl_.options_),
+ 0,
+ 2,
+ 1,
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto, _impl_._has_bits_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ~0u, // no _split_
+ ~0u, // no sizeof(Split)
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto, _impl_.name_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto, _impl_.method_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto, _impl_.options_),
+ 0,
+ ~0u,
+ 1,
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto, _impl_._has_bits_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ~0u, // no _split_
+ ~0u, // no sizeof(Split)
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto, _impl_.name_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto, _impl_.input_type_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto, _impl_.output_type_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto, _impl_.options_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto, _impl_.client_streaming_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto, _impl_.server_streaming_),
+ 0,
+ 1,
+ 2,
+ 3,
+ 4,
+ 5,
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_._has_bits_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _internal_metadata_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_._extensions_),
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ~0u, // no _split_
+ ~0u, // no sizeof(Split)
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.java_package_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.java_outer_classname_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.java_multiple_files_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.java_generate_equals_and_hash_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.java_string_check_utf8_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.optimize_for_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.go_package_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.cc_generic_services_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.java_generic_services_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.py_generic_services_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.php_generic_services_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.deprecated_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.cc_enable_arenas_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.objc_class_prefix_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.csharp_namespace_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.swift_prefix_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.php_class_prefix_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.php_namespace_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.php_metadata_namespace_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.ruby_package_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FileOptions, _impl_.uninterpreted_option_),
+ 0,
+ 1,
+ 10,
+ 11,
+ 12,
+ 18,
+ 2,
+ 13,
+ 14,
+ 15,
+ 16,
+ 17,
+ 19,
+ 3,
+ 4,
+ 5,
+ 6,
+ 7,
+ 8,
+ 9,
+ ~0u,
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MessageOptions, _impl_._has_bits_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MessageOptions, _internal_metadata_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MessageOptions, _impl_._extensions_),
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ~0u, // no _split_
+ ~0u, // no sizeof(Split)
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MessageOptions, _impl_.message_set_wire_format_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MessageOptions, _impl_.no_standard_descriptor_accessor_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MessageOptions, _impl_.deprecated_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MessageOptions, _impl_.map_entry_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MessageOptions, _impl_.uninterpreted_option_),
+ 0,
+ 1,
+ 2,
+ 3,
+ ~0u,
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldOptions, _impl_._has_bits_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldOptions, _internal_metadata_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldOptions, _impl_._extensions_),
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ~0u, // no _split_
+ ~0u, // no sizeof(Split)
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldOptions, _impl_.ctype_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldOptions, _impl_.packed_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldOptions, _impl_.jstype_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldOptions, _impl_.lazy_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldOptions, _impl_.unverified_lazy_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldOptions, _impl_.deprecated_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldOptions, _impl_.weak_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::FieldOptions, _impl_.uninterpreted_option_),
+ 0,
+ 2,
+ 1,
+ 3,
+ 4,
+ 5,
+ 6,
+ ~0u,
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::OneofOptions, _internal_metadata_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::OneofOptions, _impl_._extensions_),
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ~0u, // no _split_
+ ~0u, // no sizeof(Split)
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::OneofOptions, _impl_.uninterpreted_option_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumOptions, _impl_._has_bits_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumOptions, _internal_metadata_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumOptions, _impl_._extensions_),
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ~0u, // no _split_
+ ~0u, // no sizeof(Split)
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumOptions, _impl_.allow_alias_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumOptions, _impl_.deprecated_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumOptions, _impl_.uninterpreted_option_),
+ 0,
+ 1,
+ ~0u,
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumValueOptions, _impl_._has_bits_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumValueOptions, _internal_metadata_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumValueOptions, _impl_._extensions_),
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ~0u, // no _split_
+ ~0u, // no sizeof(Split)
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumValueOptions, _impl_.deprecated_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::EnumValueOptions, _impl_.uninterpreted_option_),
+ 0,
+ ~0u,
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::ServiceOptions, _impl_._has_bits_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::ServiceOptions, _internal_metadata_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::ServiceOptions, _impl_._extensions_),
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ~0u, // no _split_
+ ~0u, // no sizeof(Split)
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::ServiceOptions, _impl_.deprecated_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::ServiceOptions, _impl_.uninterpreted_option_),
+ 0,
+ ~0u,
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MethodOptions, _impl_._has_bits_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MethodOptions, _internal_metadata_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MethodOptions, _impl_._extensions_),
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ~0u, // no _split_
+ ~0u, // no sizeof(Split)
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MethodOptions, _impl_.deprecated_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MethodOptions, _impl_.idempotency_level_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::MethodOptions, _impl_.uninterpreted_option_),
+ 0,
+ 1,
+ ~0u,
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart, _impl_._has_bits_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ~0u, // no _split_
+ ~0u, // no sizeof(Split)
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart, _impl_.name_part_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart, _impl_.is_extension_),
+ 0,
+ 1,
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::UninterpretedOption, _impl_._has_bits_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::UninterpretedOption, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ~0u, // no _split_
+ ~0u, // no sizeof(Split)
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::UninterpretedOption, _impl_.name_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::UninterpretedOption, _impl_.identifier_value_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::UninterpretedOption, _impl_.positive_int_value_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::UninterpretedOption, _impl_.negative_int_value_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::UninterpretedOption, _impl_.double_value_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::UninterpretedOption, _impl_.string_value_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::UninterpretedOption, _impl_.aggregate_value_),
+ ~0u,
+ 0,
+ 3,
+ 4,
+ 5,
+ 1,
+ 2,
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location, _impl_._has_bits_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ~0u, // no _split_
+ ~0u, // no sizeof(Split)
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location, _impl_.path_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location, _impl_.span_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location, _impl_.leading_comments_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location, _impl_.trailing_comments_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location, _impl_.leading_detached_comments_),
+ ~0u,
+ ~0u,
+ 0,
+ 1,
+ ~0u,
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::SourceCodeInfo, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ~0u, // no _split_
+ ~0u, // no sizeof(Split)
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::SourceCodeInfo, _impl_.location_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation, _impl_._has_bits_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ~0u, // no _split_
+ ~0u, // no sizeof(Split)
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation, _impl_.path_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation, _impl_.source_file_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation, _impl_.begin_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation, _impl_.end_),
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation, _impl_.semantic_),
+ ~0u,
+ 0,
+ 1,
+ 2,
+ 3,
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ~0u, // no _split_
+ ~0u, // no sizeof(Split)
+ PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo, _impl_.annotation_),
};
-static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
- { 0, -1, -1, sizeof(::PROTOBUF_NAMESPACE_ID::FileDescriptorSet)},
- { 9, 30, -1, sizeof(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto)},
- { 43, 54, -1, sizeof(::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange)},
- { 57, 67, -1, sizeof(::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange)},
- { 69, 87, -1, sizeof(::PROTOBUF_NAMESPACE_ID::DescriptorProto)},
- { 97, -1, -1, sizeof(::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions)},
- { 106, 125, -1, sizeof(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto)},
- { 136, 146, -1, sizeof(::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto)},
- { 148, 158, -1, sizeof(::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange)},
- { 160, 173, -1, sizeof(::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto)},
- { 178, 189, -1, sizeof(::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto)},
- { 192, 203, -1, sizeof(::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto)},
- { 206, 220, -1, sizeof(::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto)},
- { 226, 255, -1, sizeof(::PROTOBUF_NAMESPACE_ID::FileOptions)},
- { 276, 289, -1, sizeof(::PROTOBUF_NAMESPACE_ID::MessageOptions)},
- { 294, 310, -1, sizeof(::PROTOBUF_NAMESPACE_ID::FieldOptions)},
- { 318, -1, -1, sizeof(::PROTOBUF_NAMESPACE_ID::OneofOptions)},
- { 327, 338, -1, sizeof(::PROTOBUF_NAMESPACE_ID::EnumOptions)},
- { 341, 351, -1, sizeof(::PROTOBUF_NAMESPACE_ID::EnumValueOptions)},
- { 353, 363, -1, sizeof(::PROTOBUF_NAMESPACE_ID::ServiceOptions)},
- { 365, 376, -1, sizeof(::PROTOBUF_NAMESPACE_ID::MethodOptions)},
- { 379, 389, -1, sizeof(::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart)},
- { 391, 406, -1, sizeof(::PROTOBUF_NAMESPACE_ID::UninterpretedOption)},
- { 413, 426, -1, sizeof(::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location)},
- { 431, -1, -1, sizeof(::PROTOBUF_NAMESPACE_ID::SourceCodeInfo)},
- { 440, 453, -1, sizeof(::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation)},
- { 458, -1, -1, sizeof(::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo)},
+
+static const ::_pbi::MigrationSchema
+ schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+ { 0, -1, -1, sizeof(::PROTOBUF_NAMESPACE_ID::FileDescriptorSet)},
+ { 9, 30, -1, sizeof(::PROTOBUF_NAMESPACE_ID::FileDescriptorProto)},
+ { 43, 54, -1, sizeof(::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange)},
+ { 57, 67, -1, sizeof(::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange)},
+ { 69, 87, -1, sizeof(::PROTOBUF_NAMESPACE_ID::DescriptorProto)},
+ { 97, -1, -1, sizeof(::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions)},
+ { 106, 125, -1, sizeof(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto)},
+ { 136, 146, -1, sizeof(::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto)},
+ { 148, 158, -1, sizeof(::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange)},
+ { 160, 173, -1, sizeof(::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto)},
+ { 178, 189, -1, sizeof(::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto)},
+ { 192, 203, -1, sizeof(::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto)},
+ { 206, 220, -1, sizeof(::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto)},
+ { 226, 255, -1, sizeof(::PROTOBUF_NAMESPACE_ID::FileOptions)},
+ { 276, 289, -1, sizeof(::PROTOBUF_NAMESPACE_ID::MessageOptions)},
+ { 294, 310, -1, sizeof(::PROTOBUF_NAMESPACE_ID::FieldOptions)},
+ { 318, -1, -1, sizeof(::PROTOBUF_NAMESPACE_ID::OneofOptions)},
+ { 327, 338, -1, sizeof(::PROTOBUF_NAMESPACE_ID::EnumOptions)},
+ { 341, 351, -1, sizeof(::PROTOBUF_NAMESPACE_ID::EnumValueOptions)},
+ { 353, 363, -1, sizeof(::PROTOBUF_NAMESPACE_ID::ServiceOptions)},
+ { 365, 376, -1, sizeof(::PROTOBUF_NAMESPACE_ID::MethodOptions)},
+ { 379, 389, -1, sizeof(::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart)},
+ { 391, 406, -1, sizeof(::PROTOBUF_NAMESPACE_ID::UninterpretedOption)},
+ { 413, 426, -1, sizeof(::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location)},
+ { 431, -1, -1, sizeof(::PROTOBUF_NAMESPACE_ID::SourceCodeInfo)},
+ { 440, 453, -1, sizeof(::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation)},
+ { 458, -1, -1, sizeof(::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo)},
};
static const ::_pb::Message* const file_default_instances[] = {
- &::PROTOBUF_NAMESPACE_ID::_FileDescriptorSet_default_instance_._instance,
- &::PROTOBUF_NAMESPACE_ID::_FileDescriptorProto_default_instance_._instance,
- &::PROTOBUF_NAMESPACE_ID::_DescriptorProto_ExtensionRange_default_instance_._instance,
- &::PROTOBUF_NAMESPACE_ID::_DescriptorProto_ReservedRange_default_instance_._instance,
- &::PROTOBUF_NAMESPACE_ID::_DescriptorProto_default_instance_._instance,
- &::PROTOBUF_NAMESPACE_ID::_ExtensionRangeOptions_default_instance_._instance,
- &::PROTOBUF_NAMESPACE_ID::_FieldDescriptorProto_default_instance_._instance,
- &::PROTOBUF_NAMESPACE_ID::_OneofDescriptorProto_default_instance_._instance,
- &::PROTOBUF_NAMESPACE_ID::_EnumDescriptorProto_EnumReservedRange_default_instance_._instance,
- &::PROTOBUF_NAMESPACE_ID::_EnumDescriptorProto_default_instance_._instance,
- &::PROTOBUF_NAMESPACE_ID::_EnumValueDescriptorProto_default_instance_._instance,
- &::PROTOBUF_NAMESPACE_ID::_ServiceDescriptorProto_default_instance_._instance,
- &::PROTOBUF_NAMESPACE_ID::_MethodDescriptorProto_default_instance_._instance,
- &::PROTOBUF_NAMESPACE_ID::_FileOptions_default_instance_._instance,
- &::PROTOBUF_NAMESPACE_ID::_MessageOptions_default_instance_._instance,
- &::PROTOBUF_NAMESPACE_ID::_FieldOptions_default_instance_._instance,
- &::PROTOBUF_NAMESPACE_ID::_OneofOptions_default_instance_._instance,
- &::PROTOBUF_NAMESPACE_ID::_EnumOptions_default_instance_._instance,
- &::PROTOBUF_NAMESPACE_ID::_EnumValueOptions_default_instance_._instance,
- &::PROTOBUF_NAMESPACE_ID::_ServiceOptions_default_instance_._instance,
- &::PROTOBUF_NAMESPACE_ID::_MethodOptions_default_instance_._instance,
- &::PROTOBUF_NAMESPACE_ID::_UninterpretedOption_NamePart_default_instance_._instance,
- &::PROTOBUF_NAMESPACE_ID::_UninterpretedOption_default_instance_._instance,
- &::PROTOBUF_NAMESPACE_ID::_SourceCodeInfo_Location_default_instance_._instance,
- &::PROTOBUF_NAMESPACE_ID::_SourceCodeInfo_default_instance_._instance,
- &::PROTOBUF_NAMESPACE_ID::_GeneratedCodeInfo_Annotation_default_instance_._instance,
- &::PROTOBUF_NAMESPACE_ID::_GeneratedCodeInfo_default_instance_._instance,
+ &::PROTOBUF_NAMESPACE_ID::_FileDescriptorSet_default_instance_._instance,
+ &::PROTOBUF_NAMESPACE_ID::_FileDescriptorProto_default_instance_._instance,
+ &::PROTOBUF_NAMESPACE_ID::_DescriptorProto_ExtensionRange_default_instance_._instance,
+ &::PROTOBUF_NAMESPACE_ID::_DescriptorProto_ReservedRange_default_instance_._instance,
+ &::PROTOBUF_NAMESPACE_ID::_DescriptorProto_default_instance_._instance,
+ &::PROTOBUF_NAMESPACE_ID::_ExtensionRangeOptions_default_instance_._instance,
+ &::PROTOBUF_NAMESPACE_ID::_FieldDescriptorProto_default_instance_._instance,
+ &::PROTOBUF_NAMESPACE_ID::_OneofDescriptorProto_default_instance_._instance,
+ &::PROTOBUF_NAMESPACE_ID::_EnumDescriptorProto_EnumReservedRange_default_instance_._instance,
+ &::PROTOBUF_NAMESPACE_ID::_EnumDescriptorProto_default_instance_._instance,
+ &::PROTOBUF_NAMESPACE_ID::_EnumValueDescriptorProto_default_instance_._instance,
+ &::PROTOBUF_NAMESPACE_ID::_ServiceDescriptorProto_default_instance_._instance,
+ &::PROTOBUF_NAMESPACE_ID::_MethodDescriptorProto_default_instance_._instance,
+ &::PROTOBUF_NAMESPACE_ID::_FileOptions_default_instance_._instance,
+ &::PROTOBUF_NAMESPACE_ID::_MessageOptions_default_instance_._instance,
+ &::PROTOBUF_NAMESPACE_ID::_FieldOptions_default_instance_._instance,
+ &::PROTOBUF_NAMESPACE_ID::_OneofOptions_default_instance_._instance,
+ &::PROTOBUF_NAMESPACE_ID::_EnumOptions_default_instance_._instance,
+ &::PROTOBUF_NAMESPACE_ID::_EnumValueOptions_default_instance_._instance,
+ &::PROTOBUF_NAMESPACE_ID::_ServiceOptions_default_instance_._instance,
+ &::PROTOBUF_NAMESPACE_ID::_MethodOptions_default_instance_._instance,
+ &::PROTOBUF_NAMESPACE_ID::_UninterpretedOption_NamePart_default_instance_._instance,
+ &::PROTOBUF_NAMESPACE_ID::_UninterpretedOption_default_instance_._instance,
+ &::PROTOBUF_NAMESPACE_ID::_SourceCodeInfo_Location_default_instance_._instance,
+ &::PROTOBUF_NAMESPACE_ID::_SourceCodeInfo_default_instance_._instance,
+ &::PROTOBUF_NAMESPACE_ID::_GeneratedCodeInfo_Annotation_default_instance_._instance,
+ &::PROTOBUF_NAMESPACE_ID::_GeneratedCodeInfo_default_instance_._instance,
};
-
-const char descriptor_table_protodef_google_2fprotobuf_2fdescriptor_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
- "\n google/protobuf/descriptor.proto\022\017goog"
- "le.protobuf\"G\n\021FileDescriptorSet\0222\n\004file"
- "\030\001 \003(\0132$.google.protobuf.FileDescriptorP"
- "roto\"\354\003\n\023FileDescriptorProto\022\014\n\004name\030\001 \001"
- "(\t\022\017\n\007package\030\002 \001(\t\022\022\n\ndependency\030\003 \003(\t\022"
- "\031\n\021public_dependency\030\n \003(\005\022\027\n\017weak_depen"
- "dency\030\013 \003(\005\0226\n\014message_type\030\004 \003(\0132 .goog"
- "le.protobuf.DescriptorProto\0227\n\tenum_type"
- "\030\005 \003(\0132$.google.protobuf.EnumDescriptorP"
- "roto\0228\n\007service\030\006 \003(\0132\'.google.protobuf."
- "ServiceDescriptorProto\0228\n\textension\030\007 \003("
- "\0132%.google.protobuf.FieldDescriptorProto"
- "\022-\n\007options\030\010 \001(\0132\034.google.protobuf.File"
- "Options\0229\n\020source_code_info\030\t \001(\0132\037.goog"
- "le.protobuf.SourceCodeInfo\022\016\n\006syntax\030\014 \001"
- "(\t\022\017\n\007edition\030\r \001(\t\"\251\005\n\017DescriptorProto\022"
- "\014\n\004name\030\001 \001(\t\0224\n\005field\030\002 \003(\0132%.google.pr"
- "otobuf.FieldDescriptorProto\0228\n\textension"
- "\030\006 \003(\0132%.google.protobuf.FieldDescriptor"
- "Proto\0225\n\013nested_type\030\003 \003(\0132 .google.prot"
- "obuf.DescriptorProto\0227\n\tenum_type\030\004 \003(\0132"
- "$.google.protobuf.EnumDescriptorProto\022H\n"
- "\017extension_range\030\005 \003(\0132/.google.protobuf"
- ".DescriptorProto.ExtensionRange\0229\n\noneof"
- "_decl\030\010 \003(\0132%.google.protobuf.OneofDescr"
- "iptorProto\0220\n\007options\030\007 \001(\0132\037.google.pro"
- "tobuf.MessageOptions\022F\n\016reserved_range\030\t"
- " \003(\0132..google.protobuf.DescriptorProto.R"
- "eservedRange\022\025\n\rreserved_name\030\n \003(\t\032e\n\016E"
- "xtensionRange\022\r\n\005start\030\001 \001(\005\022\013\n\003end\030\002 \001("
- "\005\0227\n\007options\030\003 \001(\0132&.google.protobuf.Ext"
- "ensionRangeOptions\032+\n\rReservedRange\022\r\n\005s"
- "tart\030\001 \001(\005\022\013\n\003end\030\002 \001(\005\"g\n\025ExtensionRang"
- "eOptions\022C\n\024uninterpreted_option\030\347\007 \003(\0132"
- "$.google.protobuf.UninterpretedOption*\t\010"
- "\350\007\020\200\200\200\200\002\"\325\005\n\024FieldDescriptorProto\022\014\n\004nam"
- "e\030\001 \001(\t\022\016\n\006number\030\003 \001(\005\022:\n\005label\030\004 \001(\0162+"
- ".google.protobuf.FieldDescriptorProto.La"
- "bel\0228\n\004type\030\005 \001(\0162*.google.protobuf.Fiel"
- "dDescriptorProto.Type\022\021\n\ttype_name\030\006 \001(\t"
- "\022\020\n\010extendee\030\002 \001(\t\022\025\n\rdefault_value\030\007 \001("
- "\t\022\023\n\013oneof_index\030\t \001(\005\022\021\n\tjson_name\030\n \001("
- "\t\022.\n\007options\030\010 \001(\0132\035.google.protobuf.Fie"
- "ldOptions\022\027\n\017proto3_optional\030\021 \001(\010\"\266\002\n\004T"
- "ype\022\017\n\013TYPE_DOUBLE\020\001\022\016\n\nTYPE_FLOAT\020\002\022\016\n\n"
- "TYPE_INT64\020\003\022\017\n\013TYPE_UINT64\020\004\022\016\n\nTYPE_IN"
- "T32\020\005\022\020\n\014TYPE_FIXED64\020\006\022\020\n\014TYPE_FIXED32\020"
- "\007\022\r\n\tTYPE_BOOL\020\010\022\017\n\013TYPE_STRING\020\t\022\016\n\nTYP"
- "E_GROUP\020\n\022\020\n\014TYPE_MESSAGE\020\013\022\016\n\nTYPE_BYTE"
- "S\020\014\022\017\n\013TYPE_UINT32\020\r\022\r\n\tTYPE_ENUM\020\016\022\021\n\rT"
- "YPE_SFIXED32\020\017\022\021\n\rTYPE_SFIXED64\020\020\022\017\n\013TYP"
- "E_SINT32\020\021\022\017\n\013TYPE_SINT64\020\022\"C\n\005Label\022\022\n\016"
- "LABEL_OPTIONAL\020\001\022\022\n\016LABEL_REQUIRED\020\002\022\022\n\016"
- "LABEL_REPEATED\020\003\"T\n\024OneofDescriptorProto"
- "\022\014\n\004name\030\001 \001(\t\022.\n\007options\030\002 \001(\0132\035.google"
- ".protobuf.OneofOptions\"\244\002\n\023EnumDescripto"
- "rProto\022\014\n\004name\030\001 \001(\t\0228\n\005value\030\002 \003(\0132).go"
- "ogle.protobuf.EnumValueDescriptorProto\022-"
- "\n\007options\030\003 \001(\0132\034.google.protobuf.EnumOp"
- "tions\022N\n\016reserved_range\030\004 \003(\01326.google.p"
- "rotobuf.EnumDescriptorProto.EnumReserved"
- "Range\022\025\n\rreserved_name\030\005 \003(\t\032/\n\021EnumRese"
- "rvedRange\022\r\n\005start\030\001 \001(\005\022\013\n\003end\030\002 \001(\005\"l\n"
- "\030EnumValueDescriptorProto\022\014\n\004name\030\001 \001(\t\022"
- "\016\n\006number\030\002 \001(\005\0222\n\007options\030\003 \001(\0132!.googl"
- "e.protobuf.EnumValueOptions\"\220\001\n\026ServiceD"
- "escriptorProto\022\014\n\004name\030\001 \001(\t\0226\n\006method\030\002"
- " \003(\0132&.google.protobuf.MethodDescriptorP"
- "roto\0220\n\007options\030\003 \001(\0132\037.google.protobuf."
- "ServiceOptions\"\301\001\n\025MethodDescriptorProto"
- "\022\014\n\004name\030\001 \001(\t\022\022\n\ninput_type\030\002 \001(\t\022\023\n\013ou"
- "tput_type\030\003 \001(\t\022/\n\007options\030\004 \001(\0132\036.googl"
- "e.protobuf.MethodOptions\022\037\n\020client_strea"
- "ming\030\005 \001(\010:\005false\022\037\n\020server_streaming\030\006 "
- "\001(\010:\005false\"\245\006\n\013FileOptions\022\024\n\014java_packa"
- "ge\030\001 \001(\t\022\034\n\024java_outer_classname\030\010 \001(\t\022\""
- "\n\023java_multiple_files\030\n \001(\010:\005false\022)\n\035ja"
- "va_generate_equals_and_hash\030\024 \001(\010B\002\030\001\022%\n"
- "\026java_string_check_utf8\030\033 \001(\010:\005false\022F\n\014"
- "optimize_for\030\t \001(\0162).google.protobuf.Fil"
- "eOptions.OptimizeMode:\005SPEED\022\022\n\ngo_packa"
- "ge\030\013 \001(\t\022\"\n\023cc_generic_services\030\020 \001(\010:\005f"
- "alse\022$\n\025java_generic_services\030\021 \001(\010:\005fal"
- "se\022\"\n\023py_generic_services\030\022 \001(\010:\005false\022#"
- "\n\024php_generic_services\030* \001(\010:\005false\022\031\n\nd"
- "eprecated\030\027 \001(\010:\005false\022\036\n\020cc_enable_aren"
- "as\030\037 \001(\010:\004true\022\031\n\021objc_class_prefix\030$ \001("
- "\t\022\030\n\020csharp_namespace\030% \001(\t\022\024\n\014swift_pre"
- "fix\030\' \001(\t\022\030\n\020php_class_prefix\030( \001(\t\022\025\n\rp"
- "hp_namespace\030) \001(\t\022\036\n\026php_metadata_names"
- "pace\030, \001(\t\022\024\n\014ruby_package\030- \001(\t\022C\n\024unin"
- "terpreted_option\030\347\007 \003(\0132$.google.protobu"
- "f.UninterpretedOption\":\n\014OptimizeMode\022\t\n"
- "\005SPEED\020\001\022\r\n\tCODE_SIZE\020\002\022\020\n\014LITE_RUNTIME\020"
- "\003*\t\010\350\007\020\200\200\200\200\002J\004\010&\020\'\"\204\002\n\016MessageOptions\022&\n"
- "\027message_set_wire_format\030\001 \001(\010:\005false\022.\n"
- "\037no_standard_descriptor_accessor\030\002 \001(\010:\005"
- "false\022\031\n\ndeprecated\030\003 \001(\010:\005false\022\021\n\tmap_"
- "entry\030\007 \001(\010\022C\n\024uninterpreted_option\030\347\007 \003"
- "(\0132$.google.protobuf.UninterpretedOption"
- "*\t\010\350\007\020\200\200\200\200\002J\004\010\004\020\005J\004\010\005\020\006J\004\010\006\020\007J\004\010\010\020\tJ\004\010\t\020"
- "\n\"\276\003\n\014FieldOptions\022:\n\005ctype\030\001 \001(\0162#.goog"
- "le.protobuf.FieldOptions.CType:\006STRING\022\016"
- "\n\006packed\030\002 \001(\010\022\?\n\006jstype\030\006 \001(\0162$.google."
- "protobuf.FieldOptions.JSType:\tJS_NORMAL\022"
- "\023\n\004lazy\030\005 \001(\010:\005false\022\036\n\017unverified_lazy\030"
- "\017 \001(\010:\005false\022\031\n\ndeprecated\030\003 \001(\010:\005false\022"
- "\023\n\004weak\030\n \001(\010:\005false\022C\n\024uninterpreted_op"
- "tion\030\347\007 \003(\0132$.google.protobuf.Uninterpre"
- "tedOption\"/\n\005CType\022\n\n\006STRING\020\000\022\010\n\004CORD\020\001"
- "\022\020\n\014STRING_PIECE\020\002\"5\n\006JSType\022\r\n\tJS_NORMA"
- "L\020\000\022\r\n\tJS_STRING\020\001\022\r\n\tJS_NUMBER\020\002*\t\010\350\007\020\200"
- "\200\200\200\002J\004\010\004\020\005\"^\n\014OneofOptions\022C\n\024uninterpre"
- "ted_option\030\347\007 \003(\0132$.google.protobuf.Unin"
- "terpretedOption*\t\010\350\007\020\200\200\200\200\002\"\223\001\n\013EnumOptio"
- "ns\022\023\n\013allow_alias\030\002 \001(\010\022\031\n\ndeprecated\030\003 "
- "\001(\010:\005false\022C\n\024uninterpreted_option\030\347\007 \003("
- "\0132$.google.protobuf.UninterpretedOption*"
- "\t\010\350\007\020\200\200\200\200\002J\004\010\005\020\006\"}\n\020EnumValueOptions\022\031\n\n"
- "deprecated\030\001 \001(\010:\005false\022C\n\024uninterpreted"
- "_option\030\347\007 \003(\0132$.google.protobuf.Uninter"
- "pretedOption*\t\010\350\007\020\200\200\200\200\002\"{\n\016ServiceOption"
- "s\022\031\n\ndeprecated\030! \001(\010:\005false\022C\n\024uninterp"
- "reted_option\030\347\007 \003(\0132$.google.protobuf.Un"
- "interpretedOption*\t\010\350\007\020\200\200\200\200\002\"\255\002\n\rMethodO"
- "ptions\022\031\n\ndeprecated\030! \001(\010:\005false\022_\n\021ide"
- "mpotency_level\030\" \001(\0162/.google.protobuf.M"
- "ethodOptions.IdempotencyLevel:\023IDEMPOTEN"
- "CY_UNKNOWN\022C\n\024uninterpreted_option\030\347\007 \003("
- "\0132$.google.protobuf.UninterpretedOption\""
- "P\n\020IdempotencyLevel\022\027\n\023IDEMPOTENCY_UNKNO"
- "WN\020\000\022\023\n\017NO_SIDE_EFFECTS\020\001\022\016\n\nIDEMPOTENT\020"
- "\002*\t\010\350\007\020\200\200\200\200\002\"\236\002\n\023UninterpretedOption\022;\n\004"
- "name\030\002 \003(\0132-.google.protobuf.Uninterpret"
- "edOption.NamePart\022\030\n\020identifier_value\030\003 "
- "\001(\t\022\032\n\022positive_int_value\030\004 \001(\004\022\032\n\022negat"
- "ive_int_value\030\005 \001(\003\022\024\n\014double_value\030\006 \001("
- "\001\022\024\n\014string_value\030\007 \001(\014\022\027\n\017aggregate_val"
- "ue\030\010 \001(\t\0323\n\010NamePart\022\021\n\tname_part\030\001 \002(\t\022"
- "\024\n\014is_extension\030\002 \002(\010\"\325\001\n\016SourceCodeInfo"
- "\022:\n\010location\030\001 \003(\0132(.google.protobuf.Sou"
- "rceCodeInfo.Location\032\206\001\n\010Location\022\020\n\004pat"
- "h\030\001 \003(\005B\002\020\001\022\020\n\004span\030\002 \003(\005B\002\020\001\022\030\n\020leading"
- "_comments\030\003 \001(\t\022\031\n\021trailing_comments\030\004 \001"
- "(\t\022!\n\031leading_detached_comments\030\006 \003(\t\"\234\002"
- "\n\021GeneratedCodeInfo\022A\n\nannotation\030\001 \003(\0132"
- "-.google.protobuf.GeneratedCodeInfo.Anno"
- "tation\032\303\001\n\nAnnotation\022\020\n\004path\030\001 \003(\005B\002\020\001\022"
- "\023\n\013source_file\030\002 \001(\t\022\r\n\005begin\030\003 \001(\005\022\013\n\003e"
- "nd\030\004 \001(\005\022H\n\010semantic\030\005 \001(\01626.google.prot"
- "obuf.GeneratedCodeInfo.Annotation.Semant"
- "ic\"(\n\010Semantic\022\010\n\004NONE\020\000\022\007\n\003SET\020\001\022\t\n\005ALI"
- "AS\020\002B~\n\023com.google.protobufB\020DescriptorP"
- "rotosH\001Z-google.golang.org/protobuf/type"
- "s/descriptorpb\370\001\001\242\002\003GPB\252\002\032Google.Protobu"
- "f.Reflection"
- ;
+const char descriptor_table_protodef_google_2fprotobuf_2fdescriptor_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+ "\n google/protobuf/descriptor.proto\022\017goog"
+ "le.protobuf\"G\n\021FileDescriptorSet\0222\n\004file"
+ "\030\001 \003(\0132$.google.protobuf.FileDescriptorP"
+ "roto\"\354\003\n\023FileDescriptorProto\022\014\n\004name\030\001 \001"
+ "(\t\022\017\n\007package\030\002 \001(\t\022\022\n\ndependency\030\003 \003(\t\022"
+ "\031\n\021public_dependency\030\n \003(\005\022\027\n\017weak_depen"
+ "dency\030\013 \003(\005\0226\n\014message_type\030\004 \003(\0132 .goog"
+ "le.protobuf.DescriptorProto\0227\n\tenum_type"
+ "\030\005 \003(\0132$.google.protobuf.EnumDescriptorP"
+ "roto\0228\n\007service\030\006 \003(\0132\'.google.protobuf."
+ "ServiceDescriptorProto\0228\n\textension\030\007 \003("
+ "\0132%.google.protobuf.FieldDescriptorProto"
+ "\022-\n\007options\030\010 \001(\0132\034.google.protobuf.File"
+ "Options\0229\n\020source_code_info\030\t \001(\0132\037.goog"
+ "le.protobuf.SourceCodeInfo\022\016\n\006syntax\030\014 \001"
+ "(\t\022\017\n\007edition\030\r \001(\t\"\251\005\n\017DescriptorProto\022"
+ "\014\n\004name\030\001 \001(\t\0224\n\005field\030\002 \003(\0132%.google.pr"
+ "otobuf.FieldDescriptorProto\0228\n\textension"
+ "\030\006 \003(\0132%.google.protobuf.FieldDescriptor"
+ "Proto\0225\n\013nested_type\030\003 \003(\0132 .google.prot"
+ "obuf.DescriptorProto\0227\n\tenum_type\030\004 \003(\0132"
+ "$.google.protobuf.EnumDescriptorProto\022H\n"
+ "\017extension_range\030\005 \003(\0132/.google.protobuf"
+ ".DescriptorProto.ExtensionRange\0229\n\noneof"
+ "_decl\030\010 \003(\0132%.google.protobuf.OneofDescr"
+ "iptorProto\0220\n\007options\030\007 \001(\0132\037.google.pro"
+ "tobuf.MessageOptions\022F\n\016reserved_range\030\t"
+ " \003(\0132..google.protobuf.DescriptorProto.R"
+ "eservedRange\022\025\n\rreserved_name\030\n \003(\t\032e\n\016E"
+ "xtensionRange\022\r\n\005start\030\001 \001(\005\022\013\n\003end\030\002 \001("
+ "\005\0227\n\007options\030\003 \001(\0132&.google.protobuf.Ext"
+ "ensionRangeOptions\032+\n\rReservedRange\022\r\n\005s"
+ "tart\030\001 \001(\005\022\013\n\003end\030\002 \001(\005\"g\n\025ExtensionRang"
+ "eOptions\022C\n\024uninterpreted_option\030\347\007 \003(\0132"
+ "$.google.protobuf.UninterpretedOption*\t\010"
+ "\350\007\020\200\200\200\200\002\"\325\005\n\024FieldDescriptorProto\022\014\n\004nam"
+ "e\030\001 \001(\t\022\016\n\006number\030\003 \001(\005\022:\n\005label\030\004 \001(\0162+"
+ ".google.protobuf.FieldDescriptorProto.La"
+ "bel\0228\n\004type\030\005 \001(\0162*.google.protobuf.Fiel"
+ "dDescriptorProto.Type\022\021\n\ttype_name\030\006 \001(\t"
+ "\022\020\n\010extendee\030\002 \001(\t\022\025\n\rdefault_value\030\007 \001("
+ "\t\022\023\n\013oneof_index\030\t \001(\005\022\021\n\tjson_name\030\n \001("
+ "\t\022.\n\007options\030\010 \001(\0132\035.google.protobuf.Fie"
+ "ldOptions\022\027\n\017proto3_optional\030\021 \001(\010\"\266\002\n\004T"
+ "ype\022\017\n\013TYPE_DOUBLE\020\001\022\016\n\nTYPE_FLOAT\020\002\022\016\n\n"
+ "TYPE_INT64\020\003\022\017\n\013TYPE_UINT64\020\004\022\016\n\nTYPE_IN"
+ "T32\020\005\022\020\n\014TYPE_FIXED64\020\006\022\020\n\014TYPE_FIXED32\020"
+ "\007\022\r\n\tTYPE_BOOL\020\010\022\017\n\013TYPE_STRING\020\t\022\016\n\nTYP"
+ "E_GROUP\020\n\022\020\n\014TYPE_MESSAGE\020\013\022\016\n\nTYPE_BYTE"
+ "S\020\014\022\017\n\013TYPE_UINT32\020\r\022\r\n\tTYPE_ENUM\020\016\022\021\n\rT"
+ "YPE_SFIXED32\020\017\022\021\n\rTYPE_SFIXED64\020\020\022\017\n\013TYP"
+ "E_SINT32\020\021\022\017\n\013TYPE_SINT64\020\022\"C\n\005Label\022\022\n\016"
+ "LABEL_OPTIONAL\020\001\022\022\n\016LABEL_REQUIRED\020\002\022\022\n\016"
+ "LABEL_REPEATED\020\003\"T\n\024OneofDescriptorProto"
+ "\022\014\n\004name\030\001 \001(\t\022.\n\007options\030\002 \001(\0132\035.google"
+ ".protobuf.OneofOptions\"\244\002\n\023EnumDescripto"
+ "rProto\022\014\n\004name\030\001 \001(\t\0228\n\005value\030\002 \003(\0132).go"
+ "ogle.protobuf.EnumValueDescriptorProto\022-"
+ "\n\007options\030\003 \001(\0132\034.google.protobuf.EnumOp"
+ "tions\022N\n\016reserved_range\030\004 \003(\01326.google.p"
+ "rotobuf.EnumDescriptorProto.EnumReserved"
+ "Range\022\025\n\rreserved_name\030\005 \003(\t\032/\n\021EnumRese"
+ "rvedRange\022\r\n\005start\030\001 \001(\005\022\013\n\003end\030\002 \001(\005\"l\n"
+ "\030EnumValueDescriptorProto\022\014\n\004name\030\001 \001(\t\022"
+ "\016\n\006number\030\002 \001(\005\0222\n\007options\030\003 \001(\0132!.googl"
+ "e.protobuf.EnumValueOptions\"\220\001\n\026ServiceD"
+ "escriptorProto\022\014\n\004name\030\001 \001(\t\0226\n\006method\030\002"
+ " \003(\0132&.google.protobuf.MethodDescriptorP"
+ "roto\0220\n\007options\030\003 \001(\0132\037.google.protobuf."
+ "ServiceOptions\"\301\001\n\025MethodDescriptorProto"
+ "\022\014\n\004name\030\001 \001(\t\022\022\n\ninput_type\030\002 \001(\t\022\023\n\013ou"
+ "tput_type\030\003 \001(\t\022/\n\007options\030\004 \001(\0132\036.googl"
+ "e.protobuf.MethodOptions\022\037\n\020client_strea"
+ "ming\030\005 \001(\010:\005false\022\037\n\020server_streaming\030\006 "
+ "\001(\010:\005false\"\245\006\n\013FileOptions\022\024\n\014java_packa"
+ "ge\030\001 \001(\t\022\034\n\024java_outer_classname\030\010 \001(\t\022\""
+ "\n\023java_multiple_files\030\n \001(\010:\005false\022)\n\035ja"
+ "va_generate_equals_and_hash\030\024 \001(\010B\002\030\001\022%\n"
+ "\026java_string_check_utf8\030\033 \001(\010:\005false\022F\n\014"
+ "optimize_for\030\t \001(\0162).google.protobuf.Fil"
+ "eOptions.OptimizeMode:\005SPEED\022\022\n\ngo_packa"
+ "ge\030\013 \001(\t\022\"\n\023cc_generic_services\030\020 \001(\010:\005f"
+ "alse\022$\n\025java_generic_services\030\021 \001(\010:\005fal"
+ "se\022\"\n\023py_generic_services\030\022 \001(\010:\005false\022#"
+ "\n\024php_generic_services\030* \001(\010:\005false\022\031\n\nd"
+ "eprecated\030\027 \001(\010:\005false\022\036\n\020cc_enable_aren"
+ "as\030\037 \001(\010:\004true\022\031\n\021objc_class_prefix\030$ \001("
+ "\t\022\030\n\020csharp_namespace\030% \001(\t\022\024\n\014swift_pre"
+ "fix\030\' \001(\t\022\030\n\020php_class_prefix\030( \001(\t\022\025\n\rp"
+ "hp_namespace\030) \001(\t\022\036\n\026php_metadata_names"
+ "pace\030, \001(\t\022\024\n\014ruby_package\030- \001(\t\022C\n\024unin"
+ "terpreted_option\030\347\007 \003(\0132$.google.protobu"
+ "f.UninterpretedOption\":\n\014OptimizeMode\022\t\n"
+ "\005SPEED\020\001\022\r\n\tCODE_SIZE\020\002\022\020\n\014LITE_RUNTIME\020"
+ "\003*\t\010\350\007\020\200\200\200\200\002J\004\010&\020\'\"\204\002\n\016MessageOptions\022&\n"
+ "\027message_set_wire_format\030\001 \001(\010:\005false\022.\n"
+ "\037no_standard_descriptor_accessor\030\002 \001(\010:\005"
+ "false\022\031\n\ndeprecated\030\003 \001(\010:\005false\022\021\n\tmap_"
+ "entry\030\007 \001(\010\022C\n\024uninterpreted_option\030\347\007 \003"
+ "(\0132$.google.protobuf.UninterpretedOption"
+ "*\t\010\350\007\020\200\200\200\200\002J\004\010\004\020\005J\004\010\005\020\006J\004\010\006\020\007J\004\010\010\020\tJ\004\010\t\020"
+ "\n\"\276\003\n\014FieldOptions\022:\n\005ctype\030\001 \001(\0162#.goog"
+ "le.protobuf.FieldOptions.CType:\006STRING\022\016"
+ "\n\006packed\030\002 \001(\010\022\?\n\006jstype\030\006 \001(\0162$.google."
+ "protobuf.FieldOptions.JSType:\tJS_NORMAL\022"
+ "\023\n\004lazy\030\005 \001(\010:\005false\022\036\n\017unverified_lazy\030"
+ "\017 \001(\010:\005false\022\031\n\ndeprecated\030\003 \001(\010:\005false\022"
+ "\023\n\004weak\030\n \001(\010:\005false\022C\n\024uninterpreted_op"
+ "tion\030\347\007 \003(\0132$.google.protobuf.Uninterpre"
+ "tedOption\"/\n\005CType\022\n\n\006STRING\020\000\022\010\n\004CORD\020\001"
+ "\022\020\n\014STRING_PIECE\020\002\"5\n\006JSType\022\r\n\tJS_NORMA"
+ "L\020\000\022\r\n\tJS_STRING\020\001\022\r\n\tJS_NUMBER\020\002*\t\010\350\007\020\200"
+ "\200\200\200\002J\004\010\004\020\005\"^\n\014OneofOptions\022C\n\024uninterpre"
+ "ted_option\030\347\007 \003(\0132$.google.protobuf.Unin"
+ "terpretedOption*\t\010\350\007\020\200\200\200\200\002\"\223\001\n\013EnumOptio"
+ "ns\022\023\n\013allow_alias\030\002 \001(\010\022\031\n\ndeprecated\030\003 "
+ "\001(\010:\005false\022C\n\024uninterpreted_option\030\347\007 \003("
+ "\0132$.google.protobuf.UninterpretedOption*"
+ "\t\010\350\007\020\200\200\200\200\002J\004\010\005\020\006\"}\n\020EnumValueOptions\022\031\n\n"
+ "deprecated\030\001 \001(\010:\005false\022C\n\024uninterpreted"
+ "_option\030\347\007 \003(\0132$.google.protobuf.Uninter"
+ "pretedOption*\t\010\350\007\020\200\200\200\200\002\"{\n\016ServiceOption"
+ "s\022\031\n\ndeprecated\030! \001(\010:\005false\022C\n\024uninterp"
+ "reted_option\030\347\007 \003(\0132$.google.protobuf.Un"
+ "interpretedOption*\t\010\350\007\020\200\200\200\200\002\"\255\002\n\rMethodO"
+ "ptions\022\031\n\ndeprecated\030! \001(\010:\005false\022_\n\021ide"
+ "mpotency_level\030\" \001(\0162/.google.protobuf.M"
+ "ethodOptions.IdempotencyLevel:\023IDEMPOTEN"
+ "CY_UNKNOWN\022C\n\024uninterpreted_option\030\347\007 \003("
+ "\0132$.google.protobuf.UninterpretedOption\""
+ "P\n\020IdempotencyLevel\022\027\n\023IDEMPOTENCY_UNKNO"
+ "WN\020\000\022\023\n\017NO_SIDE_EFFECTS\020\001\022\016\n\nIDEMPOTENT\020"
+ "\002*\t\010\350\007\020\200\200\200\200\002\"\236\002\n\023UninterpretedOption\022;\n\004"
+ "name\030\002 \003(\0132-.google.protobuf.Uninterpret"
+ "edOption.NamePart\022\030\n\020identifier_value\030\003 "
+ "\001(\t\022\032\n\022positive_int_value\030\004 \001(\004\022\032\n\022negat"
+ "ive_int_value\030\005 \001(\003\022\024\n\014double_value\030\006 \001("
+ "\001\022\024\n\014string_value\030\007 \001(\014\022\027\n\017aggregate_val"
+ "ue\030\010 \001(\t\0323\n\010NamePart\022\021\n\tname_part\030\001 \002(\t\022"
+ "\024\n\014is_extension\030\002 \002(\010\"\325\001\n\016SourceCodeInfo"
+ "\022:\n\010location\030\001 \003(\0132(.google.protobuf.Sou"
+ "rceCodeInfo.Location\032\206\001\n\010Location\022\020\n\004pat"
+ "h\030\001 \003(\005B\002\020\001\022\020\n\004span\030\002 \003(\005B\002\020\001\022\030\n\020leading"
+ "_comments\030\003 \001(\t\022\031\n\021trailing_comments\030\004 \001"
+ "(\t\022!\n\031leading_detached_comments\030\006 \003(\t\"\234\002"
+ "\n\021GeneratedCodeInfo\022A\n\nannotation\030\001 \003(\0132"
+ "-.google.protobuf.GeneratedCodeInfo.Anno"
+ "tation\032\303\001\n\nAnnotation\022\020\n\004path\030\001 \003(\005B\002\020\001\022"
+ "\023\n\013source_file\030\002 \001(\t\022\r\n\005begin\030\003 \001(\005\022\013\n\003e"
+ "nd\030\004 \001(\005\022H\n\010semantic\030\005 \001(\01626.google.prot"
+ "obuf.GeneratedCodeInfo.Annotation.Semant"
+ "ic\"(\n\010Semantic\022\010\n\004NONE\020\000\022\007\n\003SET\020\001\022\t\n\005ALI"
+ "AS\020\002B~\n\023com.google.protobufB\020DescriptorP"
+ "rotosH\001Z-google.golang.org/protobuf/type"
+ "s/descriptorpb\370\001\001\242\002\003GPB\252\002\032Google.Protobu"
+ "f.Reflection"
+};
static ::absl::once_flag descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once;
const ::_pbi::DescriptorTable descriptor_table_google_2fprotobuf_2fdescriptor_2eproto = {
- false, false, 6212, descriptor_table_protodef_google_2fprotobuf_2fdescriptor_2eproto,
+ false,
+ false,
+ 6212,
+ descriptor_table_protodef_google_2fprotobuf_2fdescriptor_2eproto,
"google/protobuf/descriptor.proto",
- &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once, nullptr, 0, 27,
- schemas, file_default_instances, TableStruct_google_2fprotobuf_2fdescriptor_2eproto::offsets,
- file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto, file_level_enum_descriptors_google_2fprotobuf_2fdescriptor_2eproto,
+ &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
+ nullptr,
+ 0,
+ 27,
+ schemas,
+ file_default_instances,
+ TableStruct_google_2fprotobuf_2fdescriptor_2eproto::offsets,
+ file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto,
+ file_level_enum_descriptors_google_2fprotobuf_2fdescriptor_2eproto,
file_level_service_descriptors_google_2fprotobuf_2fdescriptor_2eproto,
};
+
+// This function exists to be marked as weak.
+// It can significantly speed up compilation by breaking up LLVM's SCC
+// in the .pb.cc translation units. Large translation units see a
+// reduction of more than 35% of walltime for optimized builds. Without
+// the weak attribute all the messages in the file, including all the
+// vtables and everything they use become part of the same SCC through
+// a cycle like:
+// GetMetadata -> descriptor table -> default instances ->
+// vtables -> GetMetadata
+// By adding a weak function here we break the connection from the
+// individual vtables back into the descriptor table.
PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter() {
return &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto;
}
-
// Force running AddDescriptors() at dynamic initialization time.
-PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_google_2fprotobuf_2fdescriptor_2eproto(&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto);
+PROTOBUF_ATTRIBUTE_INIT_PRIORITY2
+static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_google_2fprotobuf_2fdescriptor_2eproto(&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto);
PROTOBUF_NAMESPACE_OPEN
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FieldDescriptorProto_Type_descriptor() {
::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto);
@@ -1406,7 +1454,6 @@
constexpr GeneratedCodeInfo_Annotation_Semantic GeneratedCodeInfo_Annotation::Semantic_MAX;
constexpr int GeneratedCodeInfo_Annotation::Semantic_ARRAYSIZE;
#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
-
// ===================================================================
class FileDescriptorSet::_Internal {
@@ -1593,7 +1640,6 @@
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[0]);
}
-
// ===================================================================
class FileDescriptorProto::_Internal {
@@ -2349,7 +2395,6 @@
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[1]);
}
-
// ===================================================================
class DescriptorProto_ExtensionRange::_Internal {
@@ -2635,7 +2680,6 @@
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[2]);
}
-
// ===================================================================
class DescriptorProto_ReservedRange::_Internal {
@@ -2874,7 +2918,6 @@
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[3]);
}
-
// ===================================================================
class DescriptorProto::_Internal {
@@ -3442,7 +3485,6 @@
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[4]);
}
-
// ===================================================================
class ExtensionRangeOptions::_Internal {
@@ -3651,7 +3693,6 @@
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[5]);
}
-
// ===================================================================
class FieldDescriptorProto::_Internal {
@@ -4334,7 +4375,6 @@
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[6]);
}
-
// ===================================================================
class OneofDescriptorProto::_Internal {
@@ -4611,7 +4651,6 @@
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[7]);
}
-
// ===================================================================
class EnumDescriptorProto_EnumReservedRange::_Internal {
@@ -4850,7 +4889,6 @@
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[8]);
}
-
// ===================================================================
class EnumDescriptorProto::_Internal {
@@ -5238,7 +5276,6 @@
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[9]);
}
-
// ===================================================================
class EnumValueDescriptorProto::_Internal {
@@ -5551,7 +5588,6 @@
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[10]);
}
-
// ===================================================================
class ServiceDescriptorProto::_Internal {
@@ -5864,7 +5900,6 @@
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[11]);
}
-
// ===================================================================
class MethodDescriptorProto::_Internal {
@@ -6323,7 +6358,6 @@
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[12]);
}
-
// ===================================================================
class FileOptions::_Internal {
@@ -7444,7 +7478,6 @@
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[13]);
}
-
// ===================================================================
class MessageOptions::_Internal {
@@ -7794,7 +7827,6 @@
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[14]);
}
-
// ===================================================================
class FieldOptions::_Internal {
@@ -8243,7 +8275,6 @@
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[15]);
}
-
// ===================================================================
class OneofOptions::_Internal {
@@ -8452,7 +8483,6 @@
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[16]);
}
-
// ===================================================================
class EnumOptions::_Internal {
@@ -8746,7 +8776,6 @@
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[17]);
}
-
// ===================================================================
class EnumValueOptions::_Internal {
@@ -8997,7 +9026,6 @@
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[18]);
}
-
// ===================================================================
class ServiceOptions::_Internal {
@@ -9248,7 +9276,6 @@
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[19]);
}
-
// ===================================================================
class MethodOptions::_Internal {
@@ -9551,7 +9578,6 @@
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[20]);
}
-
// ===================================================================
class UninterpretedOption_NamePart::_Internal {
@@ -9829,7 +9855,6 @@
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[21]);
}
-
// ===================================================================
class UninterpretedOption::_Internal {
@@ -10300,7 +10325,6 @@
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[22]);
}
-
// ===================================================================
class SourceCodeInfo_Location::_Internal {
@@ -10709,7 +10733,6 @@
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[23]);
}
-
// ===================================================================
class SourceCodeInfo::_Internal {
@@ -10894,7 +10917,6 @@
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[24]);
}
-
// ===================================================================
class GeneratedCodeInfo_Annotation::_Internal {
@@ -11267,7 +11289,6 @@
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[25]);
}
-
// ===================================================================
class GeneratedCodeInfo::_Internal {
@@ -11452,7 +11473,6 @@
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[26]);
}
-
// @@protoc_insertion_point(namespace_scope)
PROTOBUF_NAMESPACE_CLOSE
PROTOBUF_NAMESPACE_OPEN
@@ -11565,6 +11585,5 @@
return Arena::CreateMessageInternal< ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo >(arena);
}
PROTOBUF_NAMESPACE_CLOSE
-
// @@protoc_insertion_point(global_scope)
#include "google/protobuf/port_undef.inc"
diff --git a/src/google/protobuf/descriptor.pb.h b/src/google/protobuf/descriptor.pb.h
index 902b8e7..834e9ac 100644
--- a/src/google/protobuf/descriptor.pb.h
+++ b/src/google/protobuf/descriptor.pb.h
@@ -6,6 +6,7 @@
#include <limits>
#include <string>
+#include <type_traits>
#include "google/protobuf/port_def.inc"
#if PROTOBUF_VERSION < 3021000
@@ -19,6 +20,11 @@
#error regenerate this file with a newer version of protoc.
#endif
+#if 3021005 < PROTOBUF_MIN_PROTOC_VERSION
+#error "This file was generated by an older version of protoc which is"
+#error "incompatible with your Protocol Buffer headers. Please"
+#error "regenerate this file with a newer version of protoc."
+#endif // PROTOBUF_MIN_PROTOC_VERSION
#include "google/protobuf/port_undef.inc"
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/arena.h"
@@ -32,8 +38,12 @@
#include "google/protobuf/generated_enum_reflection.h"
#include "google/protobuf/unknown_field_set.h"
// @@protoc_insertion_point(includes)
+
+// Must be included last.
#include "google/protobuf/port_def.inc"
+
#define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2fdescriptor_2eproto PROTOBUF_EXPORT
+
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
@@ -44,7 +54,8 @@
struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fdescriptor_2eproto {
static const uint32_t offsets[];
};
-PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fdescriptor_2eproto;
+PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable
+ descriptor_table_google_2fprotobuf_2fdescriptor_2eproto;
PROTOBUF_NAMESPACE_OPEN
class DescriptorProto;
struct DescriptorProtoDefaultTypeInternal;
@@ -127,38 +138,63 @@
class UninterpretedOption_NamePart;
struct UninterpretedOption_NamePartDefaultTypeInternal;
PROTOBUF_EXPORT extern UninterpretedOption_NamePartDefaultTypeInternal _UninterpretedOption_NamePart_default_instance_;
+template <>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::DescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::DescriptorProto>(Arena*);
+template <>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange>(Arena*);
+template <>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange>(Arena*);
+template <>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto>(Arena*);
+template <>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange>(Arena*);
+template <>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::EnumOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumOptions>(Arena*);
+template <>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto>(Arena*);
+template <>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumValueOptions>(Arena*);
+template <>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions>(Arena*);
+template <>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto>(Arena*);
+template <>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FieldOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FieldOptions>(Arena*);
+template <>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FileDescriptorProto>(Arena*);
+template <>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FileDescriptorSet* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FileDescriptorSet>(Arena*);
+template <>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FileOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FileOptions>(Arena*);
+template <>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo>(Arena*);
+template <>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation>(Arena*);
+template <>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::MessageOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::MessageOptions>(Arena*);
+template <>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto>(Arena*);
+template <>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::MethodOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::MethodOptions>(Arena*);
+template <>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto>(Arena*);
+template <>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::OneofOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::OneofOptions>(Arena*);
+template <>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto>(Arena*);
+template <>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::ServiceOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::ServiceOptions>(Arena*);
+template <>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::SourceCodeInfo>(Arena*);
+template <>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location>(Arena*);
+template <>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>(Arena*);
+template <>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
-PROTOBUF_NAMESPACE_OPEN
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::DescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::DescriptorProto>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::EnumOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumOptions>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumValueOptions>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FieldOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FieldOptions>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FileDescriptorProto>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FileDescriptorSet* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FileDescriptorSet>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FileOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FileOptions>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::MessageOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::MessageOptions>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::MethodOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::MethodOptions>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::OneofOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::OneofOptions>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::ServiceOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::ServiceOptions>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::SourceCodeInfo>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart>(Arena*);
-PROTOBUF_NAMESPACE_CLOSE
-PROTOBUF_NAMESPACE_OPEN
+PROTOBUF_NAMESPACE_OPEN
enum FieldDescriptorProto_Type : int {
FieldDescriptorProto_Type_TYPE_DOUBLE = 1,
FieldDescriptorProto_Type_TYPE_FLOAT = 2,
@@ -370,8 +406,12 @@
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<GeneratedCodeInfo_Annotation_Semantic>(
GeneratedCodeInfo_Annotation_Semantic_descriptor(), name, value);
}
+
// ===================================================================
+
+// -------------------------------------------------------------------
+
class PROTOBUF_EXPORT FileDescriptorSet final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FileDescriptorSet) */ {
public:
@@ -533,8 +573,7 @@
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+};// -------------------------------------------------------------------
class PROTOBUF_EXPORT FileDescriptorProto final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FileDescriptorProto) */ {
@@ -952,8 +991,7 @@
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+};// -------------------------------------------------------------------
class PROTOBUF_EXPORT DescriptorProto_ExtensionRange final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.DescriptorProto.ExtensionRange) */ {
@@ -1147,8 +1185,7 @@
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+};// -------------------------------------------------------------------
class PROTOBUF_EXPORT DescriptorProto_ReservedRange final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.DescriptorProto.ReservedRange) */ {
@@ -1322,8 +1359,7 @@
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+};// -------------------------------------------------------------------
class PROTOBUF_EXPORT DescriptorProto final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.DescriptorProto) */ {
@@ -1676,8 +1712,7 @@
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+};// -------------------------------------------------------------------
class PROTOBUF_EXPORT ExtensionRangeOptions final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ExtensionRangeOptions) */ {
@@ -2032,8 +2067,7 @@
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+};// -------------------------------------------------------------------
class PROTOBUF_EXPORT FieldDescriptorProto final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FieldDescriptorProto) */ {
@@ -2466,8 +2500,7 @@
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+};// -------------------------------------------------------------------
class PROTOBUF_EXPORT OneofDescriptorProto final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.OneofDescriptorProto) */ {
@@ -2651,8 +2684,7 @@
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+};// -------------------------------------------------------------------
class PROTOBUF_EXPORT EnumDescriptorProto_EnumReservedRange final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumDescriptorProto.EnumReservedRange) */ {
@@ -2826,8 +2858,7 @@
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+};// -------------------------------------------------------------------
class PROTOBUF_EXPORT EnumDescriptorProto final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumDescriptorProto) */ {
@@ -3079,8 +3110,7 @@
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+};// -------------------------------------------------------------------
class PROTOBUF_EXPORT EnumValueDescriptorProto final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumValueDescriptorProto) */ {
@@ -3279,8 +3309,7 @@
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+};// -------------------------------------------------------------------
class PROTOBUF_EXPORT ServiceDescriptorProto final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ServiceDescriptorProto) */ {
@@ -3484,8 +3513,7 @@
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+};// -------------------------------------------------------------------
class PROTOBUF_EXPORT MethodDescriptorProto final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.MethodDescriptorProto) */ {
@@ -3739,8 +3767,7 @@
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+};// -------------------------------------------------------------------
class PROTOBUF_EXPORT FileOptions final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FileOptions) */ {
@@ -4478,8 +4505,7 @@
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+};// -------------------------------------------------------------------
class PROTOBUF_EXPORT MessageOptions final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.MessageOptions) */ {
@@ -4895,8 +4921,7 @@
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+};// -------------------------------------------------------------------
class PROTOBUF_EXPORT FieldOptions final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FieldOptions) */ {
@@ -5421,8 +5446,7 @@
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+};// -------------------------------------------------------------------
class PROTOBUF_EXPORT OneofOptions final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.OneofOptions) */ {
@@ -5777,8 +5801,7 @@
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+};// -------------------------------------------------------------------
class PROTOBUF_EXPORT EnumOptions final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumOptions) */ {
@@ -6164,8 +6187,7 @@
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+};// -------------------------------------------------------------------
class PROTOBUF_EXPORT EnumValueOptions final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumValueOptions) */ {
@@ -6536,8 +6558,7 @@
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+};// -------------------------------------------------------------------
class PROTOBUF_EXPORT ServiceOptions final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ServiceOptions) */ {
@@ -6908,8 +6929,7 @@
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+};// -------------------------------------------------------------------
class PROTOBUF_EXPORT MethodOptions final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.MethodOptions) */ {
@@ -7327,8 +7347,7 @@
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+};// -------------------------------------------------------------------
class PROTOBUF_EXPORT UninterpretedOption_NamePart final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.UninterpretedOption.NamePart) */ {
@@ -7510,8 +7529,7 @@
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+};// -------------------------------------------------------------------
class PROTOBUF_EXPORT UninterpretedOption final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.UninterpretedOption) */ {
@@ -7782,8 +7800,7 @@
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+};// -------------------------------------------------------------------
class PROTOBUF_EXPORT SourceCodeInfo_Location final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.SourceCodeInfo.Location) */ {
@@ -8043,8 +8060,7 @@
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+};// -------------------------------------------------------------------
class PROTOBUF_EXPORT SourceCodeInfo final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.SourceCodeInfo) */ {
@@ -8209,8 +8225,7 @@
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+};// -------------------------------------------------------------------
class PROTOBUF_EXPORT GeneratedCodeInfo_Annotation final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.GeneratedCodeInfo.Annotation) */ {
@@ -8476,8 +8491,7 @@
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+};// -------------------------------------------------------------------
class PROTOBUF_EXPORT GeneratedCodeInfo final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.GeneratedCodeInfo) */ {
@@ -8646,12 +8660,17 @@
// ===================================================================
+
+
// ===================================================================
+
#ifdef __GNUC__
- #pragma GCC diagnostic push
- #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif // __GNUC__
+// -------------------------------------------------------------------
+
// FileDescriptorSet
// repeated .google.protobuf.FileDescriptorProto file = 1;
@@ -14861,65 +14880,13 @@
}
#ifdef __GNUC__
- #pragma GCC diagnostic pop
+#pragma GCC diagnostic pop
#endif // __GNUC__
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
// @@protoc_insertion_point(namespace_scope)
-
PROTOBUF_NAMESPACE_CLOSE
+
PROTOBUF_NAMESPACE_OPEN
template <> struct is_proto_enum< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type> : ::std::true_type {};
@@ -14963,4 +14930,5 @@
// @@protoc_insertion_point(global_scope)
#include "google/protobuf/port_undef.inc"
-#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fdescriptor_2eproto_2epb_2eh
+
+#endif // GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fdescriptor_2eproto_2epb_2eh
diff --git a/src/google/protobuf/descriptor_database.cc b/src/google/protobuf/descriptor_database.cc
index 440bf9a..c024a77 100644
--- a/src/google/protobuf/descriptor_database.cc
+++ b/src/google/protobuf/descriptor_database.cc
@@ -39,7 +39,7 @@
#include <utility>
#include "absl/strings/ascii.h"
-#include "google/protobuf/stubs/strutil.h"
+#include "absl/strings/match.h"
#include "absl/strings/str_replace.h"
#include "google/protobuf/descriptor.pb.h"
#include "google/protobuf/stubs/stl_util.h"
@@ -190,7 +190,7 @@
// "foo.bar.baz", but not a parent of "foo.barbaz").
bool IsSubSymbol(absl::string_view sub_symbol, absl::string_view super_symbol) {
return sub_symbol == super_symbol ||
- (HasPrefixString(super_symbol, sub_symbol) &&
+ (absl::StartsWith(super_symbol, sub_symbol) &&
super_symbol[sub_symbol.size()] == '.');
}
diff --git a/src/google/protobuf/descriptor_unittest.cc b/src/google/protobuf/descriptor_unittest.cc
index 8079a26..ef99f80 100644
--- a/src/google/protobuf/descriptor_unittest.cc
+++ b/src/google/protobuf/descriptor_unittest.cc
@@ -43,6 +43,7 @@
#include "google/protobuf/compiler/parser.h"
#include "google/protobuf/unittest.pb.h"
#include "google/protobuf/unittest_custom_options.pb.h"
+#include "google/protobuf/descriptor.pb.h"
#include "google/protobuf/stubs/common.h"
#include "google/protobuf/stubs/logging.h"
#include "google/protobuf/stubs/stringprintf.h"
@@ -553,6 +554,27 @@
}
}
+TEST_F(FileDescriptorTest, CopyHeadingTo) {
+ FileDescriptorProto proto;
+ proto.set_name("foo.proto");
+ proto.set_package("foo.bar.baz");
+ proto.set_syntax("proto3");
+
+ // Won't be copied.
+ proto.add_message_type()->set_name("Foo");
+
+ DescriptorPool pool;
+ const FileDescriptor* file = pool.BuildFile(proto);
+ ASSERT_NE(file, nullptr);
+
+ FileDescriptorProto other;
+ file->CopyHeadingTo(&other);
+ EXPECT_EQ(other.name(), "foo.proto");
+ EXPECT_EQ(other.package(), "foo.bar.baz");
+ EXPECT_EQ(other.syntax(), "proto3");
+ EXPECT_TRUE(other.message_type().empty());
+}
+
void ExtractDebugString(
const FileDescriptor* file, std::set<std::string>* visited,
std::vector<std::pair<std::string, std::string>>* debug_strings) {
@@ -1063,6 +1085,34 @@
EXPECT_TRUE(baz_->is_repeated());
}
+TEST_F(DescriptorTest, NeedsUtf8Check) {
+ EXPECT_FALSE(foo_->requires_utf8_validation());
+ EXPECT_FALSE(bar_->requires_utf8_validation());
+
+ // Build a copy of the file in proto3.
+ FileDescriptorProto foo_file3;
+ foo_file_->CopyTo(&foo_file3);
+ foo_file3.set_syntax("proto3");
+
+ // Make this valid proto3 by removing `required` and the one group field.
+ for (auto& f : *foo_file3.mutable_message_type(1)->mutable_field()) {
+ f.clear_label();
+ if (f.type() == FieldDescriptorProto::TYPE_GROUP) {
+ f.set_type(FieldDescriptorProto::TYPE_MESSAGE);
+ }
+ }
+ // Make this valid proto3 by making the first enum value be zero.
+ foo_file3.mutable_enum_type(0)->mutable_value(0)->set_number(0);
+
+ DescriptorPool pool3;
+ const Descriptor* message3 = pool3.BuildFile(foo_file3)->message_type(1);
+ const FieldDescriptor* foo3 = message3->field(0);
+ const FieldDescriptor* bar3 = message3->field(1);
+
+ EXPECT_TRUE(foo3->requires_utf8_validation());
+ EXPECT_FALSE(bar3->requires_utf8_validation());
+}
+
TEST_F(DescriptorTest, IsMap) {
EXPECT_TRUE(map_->is_map());
EXPECT_FALSE(baz_->is_map());
@@ -1535,6 +1585,23 @@
EXPECT_EQ(enum2_, baz2_->type());
}
+TEST_F(EnumDescriptorTest, IsClosed) {
+ // enum_ is proto2.
+ EXPECT_TRUE(enum_->is_closed());
+
+ // Make a proto3 version of enum_.
+ FileDescriptorProto foo_file3;
+ foo_file_->CopyTo(&foo_file3);
+ foo_file3.set_syntax("proto3");
+
+ // Make this valid proto3 by making the first enum value be zero.
+ foo_file3.mutable_enum_type(0)->mutable_value(0)->set_number(0);
+
+ DescriptorPool pool3;
+ const EnumDescriptor* enum3 = pool3.BuildFile(foo_file3)->enum_type(0);
+ EXPECT_FALSE(enum3->is_closed());
+}
+
// ===================================================================
// Test service descriptors.
diff --git a/src/google/protobuf/extension_set_unittest.cc b/src/google/protobuf/extension_set_unittest.cc
index 84da3c5..2db28c3 100644
--- a/src/google/protobuf/extension_set_unittest.cc
+++ b/src/google/protobuf/extension_set_unittest.cc
@@ -49,6 +49,7 @@
#include "google/protobuf/testing/googletest.h"
#include <gtest/gtest.h>
#include "absl/base/casts.h"
+#include "absl/strings/match.h"
#include "google/protobuf/test_util.h"
#include "google/protobuf/test_util2.h"
#include "google/protobuf/stubs/stl_util.h"
@@ -1234,7 +1235,7 @@
std::string prefix = "." + template_descriptor->full_name() + ".";
if (extension->has_type_name()) {
std::string* type_name = extension->mutable_type_name();
- if (HasPrefixString(*type_name, prefix)) {
+ if (absl::StartsWith(*type_name, prefix)) {
type_name->replace(0, prefix.size(), ".dynamic_extensions.");
}
}
diff --git a/src/google/protobuf/io/gzip_stream.h b/src/google/protobuf/io/gzip_stream.h
index c7ef132..eec111c 100644
--- a/src/google/protobuf/io/gzip_stream.h
+++ b/src/google/protobuf/io/gzip_stream.h
@@ -76,7 +76,7 @@
Format format = AUTO, int buffer_size = -1);
GzipInputStream(const GzipInputStream&) = delete;
GzipInputStream& operator=(const GzipInputStream&) = delete;
- virtual ~GzipInputStream();
+ ~GzipInputStream() override;
// Return last error message or NULL if no error.
inline const char* ZlibErrorMessage() const { return zcontext_.msg; }
@@ -144,7 +144,7 @@
GzipOutputStream(const GzipOutputStream&) = delete;
GzipOutputStream& operator=(const GzipOutputStream&) = delete;
- virtual ~GzipOutputStream();
+ ~GzipOutputStream() override;
// Return last error message or NULL if no error.
inline const char* ZlibErrorMessage() const { return zcontext_.msg; }
diff --git a/src/google/protobuf/io/printer.cc b/src/google/protobuf/io/printer.cc
index c4d1847..99dc5bd 100644
--- a/src/google/protobuf/io/printer.cc
+++ b/src/google/protobuf/io/printer.cc
@@ -48,7 +48,7 @@
#include "google/protobuf/stubs/common.h"
#include "absl/strings/ascii.h"
#include "absl/strings/escaping.h"
-#include "google/protobuf/stubs/strutil.h"
+#include "absl/strings/match.h"
#include "absl/strings/str_cat.h"
#include "google/protobuf/stubs/stringprintf.h"
#include "absl/strings/string_view.h"
@@ -129,6 +129,16 @@
}
}
+absl::string_view Printer::LookupVar(absl::string_view var) {
+ LookupResult result = LookupInFrameStack(var, absl::MakeSpan(var_lookups_));
+ GOOGLE_CHECK(result.has_value()) << "could not find " << var;
+ auto* view = absl::get_if<absl::string_view>(&*result);
+ GOOGLE_CHECK(view != nullptr) << "could not find " << var
+ << "; found callback instead";
+
+ return *view;
+}
+
bool Printer::Validate(bool cond, Printer::PrintOptions opts,
absl::FunctionRef<std::string()> message) {
if (!cond) {
@@ -614,10 +624,12 @@
//
// };
//
- // in many cases. We *also* do this if a ; follows the substitution,
+ // in many cases. We *also* do this if a ; or , follows the substitution,
// because this helps clang-format keep its head on in many cases.
// Users that need to keep the semi can write $foo$/**/;
- absl::ConsumePrefix(&format, ";");
+ if (!absl::ConsumePrefix(&format, ";")) {
+ absl::ConsumePrefix(&format, ",");
+ }
absl::ConsumePrefix(&format, "\n");
indent_ =
original_indent + ConsumeIndentForLine(raw_string_indent_len, format);
diff --git a/src/google/protobuf/io/printer.h b/src/google/protobuf/io/printer.h
index 3c096a4..176f484 100644
--- a/src/google/protobuf/io/printer.h
+++ b/src/google/protobuf/io/printer.h
@@ -495,6 +495,13 @@
return absl::MakeCleanup([this] { var_lookups_.pop_back(); });
}
+ // Looks up a variable set with WithVars().
+ //
+ // Will crash if:
+ // - `var` is not present in the lookup frame table.
+ // - `var` is a callback, rather than a string.
+ absl::string_view LookupVar(absl::string_view var);
+
// Pushes a new annotation lookup frame that stores `vars` by reference.
//
// Returns an RAII object that pops the lookup frame.
diff --git a/src/google/protobuf/lite_unittest.cc b/src/google/protobuf/lite_unittest.cc
index 529e7bd..3b615b7 100644
--- a/src/google/protobuf/lite_unittest.cc
+++ b/src/google/protobuf/lite_unittest.cc
@@ -39,7 +39,7 @@
#include "google/protobuf/map_lite_unittest.pb.h"
#include "google/protobuf/unittest_lite.pb.h"
#include <gtest/gtest.h>
-#include "google/protobuf/stubs/strutil.h"
+#include "absl/strings/match.h"
#include "absl/strings/string_view.h"
#include "google/protobuf/arena_test_util.h"
#include "google/protobuf/io/coded_stream.h"
@@ -1144,8 +1144,8 @@
TEST(Lite, DebugString) {
protobuf_unittest::TestAllTypesLite message1, message2;
- EXPECT_TRUE(HasPrefixString(message1.DebugString(), "MessageLite at 0x"));
- EXPECT_TRUE(HasPrefixString(message2.DebugString(), "MessageLite at 0x"));
+ EXPECT_TRUE(absl::StartsWith(message1.DebugString(), "MessageLite at 0x"));
+ EXPECT_TRUE(absl::StartsWith(message2.DebugString(), "MessageLite at 0x"));
// DebugString() and ShortDebugString() are the same for now.
EXPECT_EQ(message1.DebugString(), message1.ShortDebugString());
diff --git a/src/google/protobuf/message_lite.cc b/src/google/protobuf/message_lite.cc
index 7cae7be..defc815 100644
--- a/src/google/protobuf/message_lite.cc
+++ b/src/google/protobuf/message_lite.cc
@@ -63,6 +63,10 @@
namespace google {
namespace protobuf {
+MessageLite::~MessageLite(){
+// Defined out of line to save code space
+}
+
std::string MessageLite::InitializationErrorString() const {
return "(cannot determine missing fields for lite message)";
}
diff --git a/src/google/protobuf/message_lite.h b/src/google/protobuf/message_lite.h
index f4bca9c..92e5b73 100644
--- a/src/google/protobuf/message_lite.h
+++ b/src/google/protobuf/message_lite.h
@@ -171,7 +171,7 @@
constexpr MessageLite() {}
MessageLite(const MessageLite&) = delete;
MessageLite& operator=(const MessageLite&) = delete;
- virtual ~MessageLite() = default;
+ virtual ~MessageLite();
// Basic Operations ------------------------------------------------
diff --git a/src/google/protobuf/parse_context.h b/src/google/protobuf/parse_context.h
index 3dbdf3e..12d51f5 100644
--- a/src/google/protobuf/parse_context.h
+++ b/src/google/protobuf/parse_context.h
@@ -337,7 +337,7 @@
template <typename A>
const char* AppendSize(const char* ptr, int size, const A& append) {
- int chunk_size = buffer_end_ + kSlopBytes - ptr;
+ int chunk_size = static_cast<int>(buffer_end_ + kSlopBytes - ptr);
do {
GOOGLE_DCHECK(size > chunk_size);
if (next_chunk_ == nullptr) return nullptr;
@@ -351,7 +351,7 @@
ptr = Next();
if (ptr == nullptr) return nullptr; // passed the limit
ptr += kSlopBytes;
- chunk_size = buffer_end_ + kSlopBytes - ptr;
+ chunk_size = static_cast<int>(buffer_end_ + kSlopBytes - ptr);
} while (size > chunk_size);
append(ptr, size);
return ptr + size;
@@ -880,7 +880,7 @@
const char* EpsCopyInputStream::ReadPackedFixed(const char* ptr, int size,
RepeatedField<T>* out) {
GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- int nbytes = buffer_end_ + kSlopBytes - ptr;
+ int nbytes = static_cast<int>(buffer_end_ + kSlopBytes - ptr);
while (size > nbytes) {
int num = nbytes / sizeof(T);
int old_entries = out->size();
@@ -898,7 +898,7 @@
ptr = Next();
if (ptr == nullptr) return nullptr;
ptr += kSlopBytes - (nbytes - block_size);
- nbytes = buffer_end_ + kSlopBytes - ptr;
+ nbytes = static_cast<int>(buffer_end_ + kSlopBytes - ptr);
}
int num = size / sizeof(T);
int old_entries = out->size();
@@ -930,11 +930,11 @@
const char* EpsCopyInputStream::ReadPackedVarint(const char* ptr, Add add) {
int size = ReadSize(&ptr);
GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
- int chunk_size = buffer_end_ - ptr;
+ int chunk_size = static_cast<int>(buffer_end_ - ptr);
while (size > chunk_size) {
ptr = ReadPackedVarintArray(ptr, buffer_end_, add);
if (ptr == nullptr) return nullptr;
- int overrun = ptr - buffer_end_;
+ int overrun = static_cast<int>(ptr - buffer_end_);
GOOGLE_DCHECK(overrun >= 0 && overrun <= kSlopBytes);
if (size - chunk_size <= kSlopBytes) {
// The current buffer contains all the information needed, we don't need
@@ -955,7 +955,7 @@
ptr = Next();
if (ptr == nullptr) return nullptr;
ptr += overrun;
- chunk_size = buffer_end_ - ptr;
+ chunk_size = static_cast<int>(buffer_end_ - ptr);
}
auto end = ptr + size;
ptr = ReadPackedVarintArray(ptr, end, add);
diff --git a/src/google/protobuf/proto3_arena_unittest.cc b/src/google/protobuf/proto3_arena_unittest.cc
index 175c6e9..0f55865 100644
--- a/src/google/protobuf/proto3_arena_unittest.cc
+++ b/src/google/protobuf/proto3_arena_unittest.cc
@@ -38,7 +38,7 @@
#include "google/protobuf/arena.h"
#include "google/protobuf/text_format.h"
#include <gtest/gtest.h>
-#include "google/protobuf/stubs/strutil.h"
+#include "absl/strings/match.h"
#include "google/protobuf/test_util.h"
// Must be included last.
@@ -296,7 +296,7 @@
for (int i = 0; i < d->field_count(); i++) {
const FieldDescriptor* f = d->field(i);
- if (HasPrefixString(f->name(), "singular")) {
+ if (absl::StartsWith(f->name(), "singular")) {
EXPECT_FALSE(f->has_optional_keyword()) << f->full_name();
EXPECT_FALSE(f->has_presence()) << f->full_name();
EXPECT_FALSE(f->containing_oneof()) << f->full_name();
diff --git a/src/google/protobuf/stubs/common_unittest.cc b/src/google/protobuf/stubs/common_unittest.cc
index eb43fd2..7c86204 100644
--- a/src/google/protobuf/stubs/common_unittest.cc
+++ b/src/google/protobuf/stubs/common_unittest.cc
@@ -95,11 +95,14 @@
GOOGLE_LOG(ERROR ) << "An error.";
std::string text = GetCapturedTestStderr();
- EXPECT_EQ(
- "[libprotobuf INFO " __FILE__ ":" + SimpleItoa(line + 1) + "] A message.\n"
- "[libprotobuf WARNING " __FILE__ ":" + SimpleItoa(line + 2) + "] A warning.\n"
- "[libprotobuf ERROR " __FILE__ ":" + SimpleItoa(line + 3) + "] An error.\n",
- text);
+ EXPECT_EQ(absl::StrCat("[libprotobuf INFO " __FILE__ ":", line + 1,
+ "] A message.\n"
+ "[libprotobuf WARNING " __FILE__ ":",
+ line + 2,
+ "] A warning.\n"
+ "[libprotobuf ERROR " __FILE__ ":",
+ line + 3, "] An error.\n"),
+ text);
}
TEST(LoggingTest, NullLogging) {
@@ -128,12 +131,10 @@
EXPECT_TRUE(SetLogHandler(old_handler) == &CaptureLog);
ASSERT_EQ(2, captured_messages_.size());
- EXPECT_EQ(
- "2 " __FILE__ ":" + SimpleItoa(start_line + 1) + ": An error.",
- captured_messages_[0]);
- EXPECT_EQ(
- "1 " __FILE__ ":" + SimpleItoa(start_line + 2) + ": A warning.",
- captured_messages_[1]);
+ EXPECT_EQ(absl::StrCat("2 " __FILE__ ":", start_line + 1, ": An error."),
+ captured_messages_[0]);
+ EXPECT_EQ(absl::StrCat("1 " __FILE__ ":", start_line + 2, ": A warning."),
+ captured_messages_[1]);
}
TEST(LoggingTest, SilenceLogging) {
@@ -154,12 +155,10 @@
EXPECT_TRUE(SetLogHandler(old_handler) == &CaptureLog);
ASSERT_EQ(2, captured_messages_.size());
- EXPECT_EQ(
- "0 " __FILE__ ":" + SimpleItoa(line1) + ": Visible1",
- captured_messages_[0]);
- EXPECT_EQ(
- "0 " __FILE__ ":" + SimpleItoa(line2) + ": Visible2",
- captured_messages_[1]);
+ EXPECT_EQ(absl::StrCat("0 " __FILE__ ":", line1, ": Visible1"),
+ captured_messages_[0]);
+ EXPECT_EQ(absl::StrCat("0 " __FILE__ ":", line2, ": Visible2"),
+ captured_messages_[1]);
}
class ClosureTest : public testing::Test {
diff --git a/src/google/protobuf/stubs/strutil.cc b/src/google/protobuf/stubs/strutil.cc
index b6d2049..720c6fc 100644
--- a/src/google/protobuf/stubs/strutil.cc
+++ b/src/google/protobuf/stubs/strutil.cc
@@ -63,75 +63,7 @@
namespace google {
namespace protobuf {
-// These are defined as macros on some platforms. #undef them so that we can
-// redefine them.
-#undef isxdigit
-#undef isprint
-
-// The definitions of these in ctype.h change based on locale. Since our
-// string manipulation is all in relation to the protocol buffer and C++
-// languages, we always want to use the C locale. So, we re-define these
-// exactly as we want them.
-inline bool isxdigit(char c) {
- return ('0' <= c && c <= '9') ||
- ('a' <= c && c <= 'f') ||
- ('A' <= c && c <= 'F');
-}
-
-inline bool isprint(char c) {
- return c >= 0x20 && c <= 0x7E;
-}
-
-// ----------------------------------------------------------------------
-// ReplaceCharacters
-// Replaces any occurrence of the character 'remove' (or the characters
-// in 'remove') with the character 'replacewith'.
-// ----------------------------------------------------------------------
-void ReplaceCharacters(std::string *s, const char *remove, char replacewith) {
- const char *str_start = s->c_str();
- const char *str = str_start;
- for (str = strpbrk(str, remove);
- str != nullptr;
- str = strpbrk(str + 1, remove)) {
- (*s)[str - str_start] = replacewith;
- }
-}
-
-void StripWhitespace(std::string *str) {
- int str_length = str->length();
-
- // Strip off leading whitespace.
- int first = 0;
- while (first < str_length && absl::ascii_isspace(str->at(first))) {
- ++first;
- }
- // If entire string is white space.
- if (first == str_length) {
- str->clear();
- return;
- }
- if (first > 0) {
- str->erase(0, first);
- str_length -= first;
- }
-
- // Strip off trailing whitespace.
- int last = str_length - 1;
- while (last >= 0 && absl::ascii_isspace(str->at(last))) {
- --last;
- }
- if (last != (str_length - 1) && last >= 0) {
- str->erase(last + 1, std::string::npos);
- }
-}
-
-// ----------------------------------------------------------------------
-// StringReplace()
-// Replace the "old" pattern with the "new" pattern in a string,
-// and append the result to "res". If replace_all is false,
-// it only replaces the first instance of "old."
-// ----------------------------------------------------------------------
-
+namespace {
void StringReplace(const std::string &s, const std::string &oldsub,
const std::string &newsub, bool replace_all,
std::string *res) {
@@ -153,6 +85,7 @@
} while (replace_all);
res->append(s, start_pos, s.length() - start_pos);
}
+} // namespace
// ----------------------------------------------------------------------
// StringReplace()
@@ -171,91 +104,6 @@
}
// ----------------------------------------------------------------------
-// SplitStringUsing()
-// Split a string using a character delimiter. Append the components
-// to 'result'.
-//
-// Note: For multi-character delimiters, this routine will split on *ANY* of
-// the characters in the string, not the entire string as a single delimiter.
-// ----------------------------------------------------------------------
-template <typename ITR>
-static inline void SplitStringToIteratorUsing(absl::string_view full,
- const char *delim, ITR &result) {
- // Optimize the common case where delim is a single character.
- if (delim[0] != '\0' && delim[1] == '\0') {
- char c = delim[0];
- const char* p = full.data();
- const char* end = p + full.size();
- while (p != end) {
- if (*p == c) {
- ++p;
- } else {
- const char* start = p;
- while (++p != end && *p != c);
- *result++ = std::string(start, p - start);
- }
- }
- return;
- }
-
- std::string::size_type begin_index, end_index;
- begin_index = full.find_first_not_of(delim);
- while (begin_index != std::string::npos) {
- end_index = full.find_first_of(delim, begin_index);
- if (end_index == std::string::npos) {
- *result++ = std::string(full.substr(begin_index));
- return;
- }
- *result++ =
- std::string(full.substr(begin_index, (end_index - begin_index)));
- begin_index = full.find_first_not_of(delim, end_index);
- }
-}
-
-void SplitStringUsing(absl::string_view full, const char *delim,
- std::vector<std::string> *result) {
- std::back_insert_iterator<std::vector<std::string> > it(*result);
- SplitStringToIteratorUsing(full, delim, it);
-}
-
-// Split a string using a character delimiter. Append the components
-// to 'result'. If there are consecutive delimiters, this function
-// will return corresponding empty strings. The string is split into
-// at most the specified number of pieces greedily. This means that the
-// last piece may possibly be split further. To split into as many pieces
-// as possible, specify 0 as the number of pieces.
-//
-// If "full" is the empty string, yields an empty string as the only value.
-//
-// If "pieces" is negative for some reason, it returns the whole string
-// ----------------------------------------------------------------------
-template <typename ITR>
-static inline void SplitStringToIteratorAllowEmpty(absl::string_view full,
- const char *delim,
- int pieces, ITR &result) {
- std::string::size_type begin_index, end_index;
- begin_index = 0;
-
- for (int i = 0; (i < pieces-1) || (pieces == 0); i++) {
- end_index = full.find_first_of(delim, begin_index);
- if (end_index == std::string::npos) {
- *result++ = std::string(full.substr(begin_index));
- return;
- }
- *result++ =
- std::string(full.substr(begin_index, (end_index - begin_index)));
- begin_index = end_index + 1;
- }
- *result++ = std::string(full.substr(begin_index));
-}
-
-void SplitStringAllowEmpty(absl::string_view full, const char *delim,
- std::vector<std::string> *result) {
- std::back_insert_iterator<std::vector<std::string> > it(*result);
- SplitStringToIteratorAllowEmpty(full, delim, 0, it);
-}
-
-// ----------------------------------------------------------------------
// strto32_adaptor()
// strtou32_adaptor()
// Implementation of strto[u]l replacements that have identical
@@ -424,377 +272,8 @@
}
// ----------------------------------------------------------------------
-// FastIntToBuffer()
-// FastInt64ToBuffer()
-// FastHexToBuffer()
-// FastHex64ToBuffer()
-// FastHex32ToBuffer()
-// ----------------------------------------------------------------------
-
-// Offset into buffer where FastInt64ToBuffer places the end of string
-// null character. Also used by FastInt64ToBufferLeft.
-static const int kFastInt64ToBufferOffset = 21;
-
-char *FastInt64ToBuffer(int64_t i, char* buffer) {
- // We could collapse the positive and negative sections, but that
- // would be slightly slower for positive numbers...
- // 22 bytes is enough to store -2**64, -18446744073709551616.
- char* p = buffer + kFastInt64ToBufferOffset;
- *p-- = '\0';
- if (i >= 0) {
- do {
- *p-- = '0' + i % 10;
- i /= 10;
- } while (i > 0);
- return p + 1;
- } else {
- // On different platforms, % and / have different behaviors for
- // negative numbers, so we need to jump through hoops to make sure
- // we don't divide negative numbers.
- if (i > -10) {
- i = -i;
- *p-- = '0' + i;
- *p = '-';
- return p;
- } else {
- // Make sure we aren't at MIN_INT, in which case we can't say i = -i
- i = i + 10;
- i = -i;
- *p-- = '0' + i % 10;
- // Undo what we did a moment ago
- i = i / 10 + 1;
- do {
- *p-- = '0' + i % 10;
- i /= 10;
- } while (i > 0);
- *p = '-';
- return p;
- }
- }
-}
-
-// Offset into buffer where FastInt32ToBuffer places the end of string
-// null character. Also used by FastInt32ToBufferLeft
-static const int kFastInt32ToBufferOffset = 11;
-
-// Yes, this is a duplicate of FastInt64ToBuffer. But, we need this for the
-// compiler to generate 32 bit arithmetic instructions. It's much faster, at
-// least with 32 bit binaries.
-char *FastInt32ToBuffer(int32_t i, char* buffer) {
- // We could collapse the positive and negative sections, but that
- // would be slightly slower for positive numbers...
- // 12 bytes is enough to store -2**32, -4294967296.
- char* p = buffer + kFastInt32ToBufferOffset;
- *p-- = '\0';
- if (i >= 0) {
- do {
- *p-- = '0' + i % 10;
- i /= 10;
- } while (i > 0);
- return p + 1;
- } else {
- // On different platforms, % and / have different behaviors for
- // negative numbers, so we need to jump through hoops to make sure
- // we don't divide negative numbers.
- if (i > -10) {
- i = -i;
- *p-- = '0' + i;
- *p = '-';
- return p;
- } else {
- // Make sure we aren't at MIN_INT, in which case we can't say i = -i
- i = i + 10;
- i = -i;
- *p-- = '0' + i % 10;
- // Undo what we did a moment ago
- i = i / 10 + 1;
- do {
- *p-- = '0' + i % 10;
- i /= 10;
- } while (i > 0);
- *p = '-';
- return p;
- }
- }
-}
-
-char *FastHexToBuffer(int i, char* buffer) {
- GOOGLE_CHECK(i >= 0) << "FastHexToBuffer() wants non-negative integers, not " << i;
-
- static const char *hexdigits = "0123456789abcdef";
- char *p = buffer + 21;
- *p-- = '\0';
- do {
- *p-- = hexdigits[i & 15]; // mod by 16
- i >>= 4; // divide by 16
- } while (i > 0);
- return p + 1;
-}
-
-char *InternalFastHexToBuffer(uint64_t value, char* buffer, int num_byte) {
- static const char *hexdigits = "0123456789abcdef";
- buffer[num_byte] = '\0';
- for (int i = num_byte - 1; i >= 0; i--) {
-#ifdef _M_X64
- // MSVC x64 platform has a bug optimizing the uint32(value) in the #else
- // block. Given that the uint32 cast was to improve performance on 32-bit
- // platforms, we use 64-bit '&' directly.
- buffer[i] = hexdigits[value & 0xf];
-#else
- buffer[i] = hexdigits[uint32_t(value) & 0xf];
-#endif
- value >>= 4;
- }
- return buffer;
-}
-
-char *FastHex64ToBuffer(uint64_t value, char* buffer) {
- return InternalFastHexToBuffer(value, buffer, 16);
-}
-
-char *FastHex32ToBuffer(uint32_t value, char* buffer) {
- return InternalFastHexToBuffer(value, buffer, 8);
-}
-
-// ----------------------------------------------------------------------
-// FastInt32ToBufferLeft()
-// FastUInt32ToBufferLeft()
-// FastInt64ToBufferLeft()
-// FastUInt64ToBufferLeft()
-//
-// Like the Fast*ToBuffer() functions above, these are intended for speed.
-// Unlike the Fast*ToBuffer() functions, however, these functions write
-// their output to the beginning of the buffer (hence the name, as the
-// output is left-aligned). The caller is responsible for ensuring that
-// the buffer has enough space to hold the output.
-//
-// Returns a pointer to the end of the string (i.e. the null character
-// terminating the string).
-// ----------------------------------------------------------------------
-
-static const char two_ASCII_digits[100][2] = {
- {'0','0'}, {'0','1'}, {'0','2'}, {'0','3'}, {'0','4'},
- {'0','5'}, {'0','6'}, {'0','7'}, {'0','8'}, {'0','9'},
- {'1','0'}, {'1','1'}, {'1','2'}, {'1','3'}, {'1','4'},
- {'1','5'}, {'1','6'}, {'1','7'}, {'1','8'}, {'1','9'},
- {'2','0'}, {'2','1'}, {'2','2'}, {'2','3'}, {'2','4'},
- {'2','5'}, {'2','6'}, {'2','7'}, {'2','8'}, {'2','9'},
- {'3','0'}, {'3','1'}, {'3','2'}, {'3','3'}, {'3','4'},
- {'3','5'}, {'3','6'}, {'3','7'}, {'3','8'}, {'3','9'},
- {'4','0'}, {'4','1'}, {'4','2'}, {'4','3'}, {'4','4'},
- {'4','5'}, {'4','6'}, {'4','7'}, {'4','8'}, {'4','9'},
- {'5','0'}, {'5','1'}, {'5','2'}, {'5','3'}, {'5','4'},
- {'5','5'}, {'5','6'}, {'5','7'}, {'5','8'}, {'5','9'},
- {'6','0'}, {'6','1'}, {'6','2'}, {'6','3'}, {'6','4'},
- {'6','5'}, {'6','6'}, {'6','7'}, {'6','8'}, {'6','9'},
- {'7','0'}, {'7','1'}, {'7','2'}, {'7','3'}, {'7','4'},
- {'7','5'}, {'7','6'}, {'7','7'}, {'7','8'}, {'7','9'},
- {'8','0'}, {'8','1'}, {'8','2'}, {'8','3'}, {'8','4'},
- {'8','5'}, {'8','6'}, {'8','7'}, {'8','8'}, {'8','9'},
- {'9','0'}, {'9','1'}, {'9','2'}, {'9','3'}, {'9','4'},
- {'9','5'}, {'9','6'}, {'9','7'}, {'9','8'}, {'9','9'}
-};
-
-char* FastUInt32ToBufferLeft(uint32_t u, char* buffer) {
- uint32_t digits;
- const char *ASCII_digits = nullptr;
- // The idea of this implementation is to trim the number of divides to as few
- // as possible by using multiplication and subtraction rather than mod (%),
- // and by outputting two digits at a time rather than one.
- // The huge-number case is first, in the hopes that the compiler will output
- // that case in one branch-free block of code, and only output conditional
- // branches into it from below.
- if (u >= 1000000000) { // >= 1,000,000,000
- digits = u / 100000000; // 100,000,000
- ASCII_digits = two_ASCII_digits[digits];
- buffer[0] = ASCII_digits[0];
- buffer[1] = ASCII_digits[1];
- buffer += 2;
-sublt100_000_000:
- u -= digits * 100000000; // 100,000,000
-lt100_000_000:
- digits = u / 1000000; // 1,000,000
- ASCII_digits = two_ASCII_digits[digits];
- buffer[0] = ASCII_digits[0];
- buffer[1] = ASCII_digits[1];
- buffer += 2;
-sublt1_000_000:
- u -= digits * 1000000; // 1,000,000
-lt1_000_000:
- digits = u / 10000; // 10,000
- ASCII_digits = two_ASCII_digits[digits];
- buffer[0] = ASCII_digits[0];
- buffer[1] = ASCII_digits[1];
- buffer += 2;
-sublt10_000:
- u -= digits * 10000; // 10,000
-lt10_000:
- digits = u / 100;
- ASCII_digits = two_ASCII_digits[digits];
- buffer[0] = ASCII_digits[0];
- buffer[1] = ASCII_digits[1];
- buffer += 2;
-sublt100:
- u -= digits * 100;
-lt100:
- digits = u;
- ASCII_digits = two_ASCII_digits[digits];
- buffer[0] = ASCII_digits[0];
- buffer[1] = ASCII_digits[1];
- buffer += 2;
-done:
- *buffer = 0;
- return buffer;
- }
-
- if (u < 100) {
- digits = u;
- if (u >= 10) goto lt100;
- *buffer++ = '0' + digits;
- goto done;
- }
- if (u < 10000) { // 10,000
- if (u >= 1000) goto lt10_000;
- digits = u / 100;
- *buffer++ = '0' + digits;
- goto sublt100;
- }
- if (u < 1000000) { // 1,000,000
- if (u >= 100000) goto lt1_000_000;
- digits = u / 10000; // 10,000
- *buffer++ = '0' + digits;
- goto sublt10_000;
- }
- if (u < 100000000) { // 100,000,000
- if (u >= 10000000) goto lt100_000_000;
- digits = u / 1000000; // 1,000,000
- *buffer++ = '0' + digits;
- goto sublt1_000_000;
- }
- // we already know that u < 1,000,000,000
- digits = u / 100000000; // 100,000,000
- *buffer++ = '0' + digits;
- goto sublt100_000_000;
-}
-
-char* FastInt32ToBufferLeft(int32_t i, char* buffer) {
- uint32_t u = 0;
- if (i < 0) {
- *buffer++ = '-';
- u -= i;
- } else {
- u = i;
- }
- return FastUInt32ToBufferLeft(u, buffer);
-}
-
-char* FastUInt64ToBufferLeft(uint64_t u64, char* buffer) {
- int digits;
- const char *ASCII_digits = nullptr;
-
- uint32_t u = static_cast<uint32_t>(u64);
- if (u == u64) return FastUInt32ToBufferLeft(u, buffer);
-
- uint64_t top_11_digits = u64 / 1000000000;
- buffer = FastUInt64ToBufferLeft(top_11_digits, buffer);
- u = u64 - (top_11_digits * 1000000000);
-
- digits = u / 10000000; // 10,000,000
- GOOGLE_DCHECK_LT(digits, 100);
- ASCII_digits = two_ASCII_digits[digits];
- buffer[0] = ASCII_digits[0];
- buffer[1] = ASCII_digits[1];
- buffer += 2;
- u -= digits * 10000000; // 10,000,000
- digits = u / 100000; // 100,000
- ASCII_digits = two_ASCII_digits[digits];
- buffer[0] = ASCII_digits[0];
- buffer[1] = ASCII_digits[1];
- buffer += 2;
- u -= digits * 100000; // 100,000
- digits = u / 1000; // 1,000
- ASCII_digits = two_ASCII_digits[digits];
- buffer[0] = ASCII_digits[0];
- buffer[1] = ASCII_digits[1];
- buffer += 2;
- u -= digits * 1000; // 1,000
- digits = u / 10;
- ASCII_digits = two_ASCII_digits[digits];
- buffer[0] = ASCII_digits[0];
- buffer[1] = ASCII_digits[1];
- buffer += 2;
- u -= digits * 10;
- digits = u;
- *buffer++ = '0' + digits;
- *buffer = 0;
- return buffer;
-}
-
-char* FastInt64ToBufferLeft(int64_t i, char* buffer) {
- uint64_t u = 0;
- if (i < 0) {
- *buffer++ = '-';
- u -= i;
- } else {
- u = i;
- }
- return FastUInt64ToBufferLeft(u, buffer);
-}
-
-// ----------------------------------------------------------------------
-// SimpleItoa()
-// Description: converts an integer to a string.
-//
-// Return value: string
-// ----------------------------------------------------------------------
-
-std::string SimpleItoa(int i) {
- char buffer[kFastToBufferSize];
- return (sizeof(i) == 4) ?
- FastInt32ToBuffer(i, buffer) :
- FastInt64ToBuffer(i, buffer);
-}
-
-std::string SimpleItoa(unsigned int i) {
- char buffer[kFastToBufferSize];
- return std::string(buffer, (sizeof(i) == 4)
- ? FastUInt32ToBufferLeft(i, buffer)
- : FastUInt64ToBufferLeft(i, buffer));
-}
-
-std::string SimpleItoa(long i) {
- char buffer[kFastToBufferSize];
- return (sizeof(i) == 4) ?
- FastInt32ToBuffer(i, buffer) :
- FastInt64ToBuffer(i, buffer);
-}
-
-std::string SimpleItoa(unsigned long i) {
- char buffer[kFastToBufferSize];
- return std::string(buffer, (sizeof(i) == 4)
- ? FastUInt32ToBufferLeft(i, buffer)
- : FastUInt64ToBufferLeft(i, buffer));
-}
-
-std::string SimpleItoa(long long i) {
- char buffer[kFastToBufferSize];
- return (sizeof(i) == 4) ?
- FastInt32ToBuffer(i, buffer) :
- FastInt64ToBuffer(i, buffer);
-}
-
-std::string SimpleItoa(unsigned long long i) {
- char buffer[kFastToBufferSize];
- return std::string(buffer, (sizeof(i) == 4)
- ? FastUInt32ToBufferLeft(i, buffer)
- : FastUInt64ToBufferLeft(i, buffer));
-}
-
-// ----------------------------------------------------------------------
// SimpleDtoa()
// SimpleFtoa()
-// DoubleToBuffer()
-// FloatToBuffer()
// We want to print the value without losing precision, but we also do
// not want to print more digits than necessary. This turns out to be
// trickier than it sounds. Numbers like 0.2 cannot be represented
@@ -831,23 +310,18 @@
// implementation.
// ----------------------------------------------------------------------
-std::string SimpleDtoa(double value) {
- char buffer[kDoubleToBufferSize];
- return DoubleToBuffer(value, buffer);
-}
-
-std::string SimpleFtoa(float value) {
- char buffer[kFloatToBufferSize];
- return FloatToBuffer(value, buffer);
-}
+namespace {
+// In practice, doubles should never need more than 24 bytes and floats
+// should never need more than 14 (including null terminators), but we
+// overestimate to be safe.
+constexpr int kDoubleToBufferSize = 32;
+constexpr int kFloatToBufferSize = 24;
static inline bool IsValidFloatChar(char c) {
- return ('0' <= c && c <= '9') ||
- c == 'e' || c == 'E' ||
- c == '+' || c == '-';
+ return ('0' <= c && c <= '9') || c == 'e' || c == 'E' || c == '+' || c == '-';
}
-void DelocalizeRadix(char* buffer) {
+void DelocalizeRadix(char *buffer) {
// Fast check: if the buffer has a normal decimal point, assume no
// translation is needed.
if (strchr(buffer, '.') != nullptr) return;
@@ -868,12 +342,52 @@
if (!IsValidFloatChar(*buffer) && *buffer != '\0') {
// It appears the radix was a multi-byte character. We need to remove the
// extra bytes.
- char* target = buffer;
- do { ++buffer; } while (!IsValidFloatChar(*buffer) && *buffer != '\0');
+ char *target = buffer;
+ do {
+ ++buffer;
+ } while (!IsValidFloatChar(*buffer) && *buffer != '\0');
memmove(target, buffer, strlen(buffer) + 1);
}
}
+char *FloatToBuffer(float value, char *buffer) {
+ // FLT_DIG is 6 for IEEE-754 floats, which are used on almost all
+ // platforms these days. Just in case some system exists where FLT_DIG
+ // is significantly larger -- and risks overflowing our buffer -- we have
+ // this assert.
+ static_assert(FLT_DIG < 10, "FLT_DIG_is_too_big");
+
+ if (value == std::numeric_limits<double>::infinity()) {
+ strcpy(buffer, "inf");
+ return buffer;
+ } else if (value == -std::numeric_limits<double>::infinity()) {
+ strcpy(buffer, "-inf");
+ return buffer;
+ } else if (std::isnan(value)) {
+ strcpy(buffer, "nan");
+ return buffer;
+ }
+
+ int snprintf_result =
+ snprintf(buffer, kFloatToBufferSize, "%.*g", FLT_DIG, value);
+
+ // The snprintf should never overflow because the buffer is significantly
+ // larger than the precision we asked for.
+ GOOGLE_DCHECK(snprintf_result > 0 && snprintf_result < kFloatToBufferSize);
+
+ float parsed_value;
+ if (!safe_strtof(buffer, &parsed_value) || parsed_value != value) {
+ snprintf_result =
+ snprintf(buffer, kFloatToBufferSize, "%.*g", FLT_DIG + 3, value);
+
+ // Should never overflow; see above.
+ GOOGLE_DCHECK(snprintf_result > 0 && snprintf_result < kFloatToBufferSize);
+ }
+
+ DelocalizeRadix(buffer);
+ return buffer;
+}
+
char* DoubleToBuffer(double value, char* buffer) {
// DBL_DIG is 15 for IEEE-754 doubles, which are used on almost all
// platforms these days. Just in case some system exists where DBL_DIG
@@ -917,6 +431,17 @@
DelocalizeRadix(buffer);
return buffer;
}
+} // namespace
+
+std::string SimpleDtoa(double value) {
+ char buffer[kDoubleToBufferSize];
+ return DoubleToBuffer(value, buffer);
+}
+
+std::string SimpleFtoa(float value) {
+ char buffer[kFloatToBufferSize];
+ return FloatToBuffer(value, buffer);
+}
static int memcasecmp(const char *s1, const char *s2, size_t len) {
const unsigned char *us1 = reinterpret_cast<const unsigned char *>(s1);
@@ -994,72 +519,6 @@
return safe_uint_internal(str, value);
}
-char* FloatToBuffer(float value, char* buffer) {
- // FLT_DIG is 6 for IEEE-754 floats, which are used on almost all
- // platforms these days. Just in case some system exists where FLT_DIG
- // is significantly larger -- and risks overflowing our buffer -- we have
- // this assert.
- static_assert(FLT_DIG < 10, "FLT_DIG_is_too_big");
-
- if (value == std::numeric_limits<double>::infinity()) {
- strcpy(buffer, "inf");
- return buffer;
- } else if (value == -std::numeric_limits<double>::infinity()) {
- strcpy(buffer, "-inf");
- return buffer;
- } else if (std::isnan(value)) {
- strcpy(buffer, "nan");
- return buffer;
- }
-
- int snprintf_result =
- snprintf(buffer, kFloatToBufferSize, "%.*g", FLT_DIG, value);
-
- // The snprintf should never overflow because the buffer is significantly
- // larger than the precision we asked for.
- GOOGLE_DCHECK(snprintf_result > 0 && snprintf_result < kFloatToBufferSize);
-
- float parsed_value;
- if (!safe_strtof(buffer, &parsed_value) || parsed_value != value) {
- snprintf_result =
- snprintf(buffer, kFloatToBufferSize, "%.*g", FLT_DIG + 3, value);
-
- // Should never overflow; see above.
- GOOGLE_DCHECK(snprintf_result > 0 && snprintf_result < kFloatToBufferSize);
- }
-
- DelocalizeRadix(buffer);
- return buffer;
-}
-
-int GlobalReplaceSubstring(const std::string &substring,
- const std::string &replacement, std::string *s) {
- GOOGLE_CHECK(s != nullptr);
- if (s->empty() || substring.empty())
- return 0;
- std::string tmp;
- int num_replacements = 0;
- int pos = 0;
- for (absl::string_view::size_type match_pos =
- s->find(substring.data(), pos, substring.length());
- match_pos != std::string::npos; pos = match_pos + substring.length(),
- match_pos = s->find(substring.data(), pos,
- substring.length())) {
- ++num_replacements;
- // Append the original content before the match.
- tmp.append(*s, pos, match_pos - pos);
- // Append the replacement for the match.
- tmp.append(replacement.begin(), replacement.end());
- }
- // Append the content after the last match. If no replacements were made, the
- // original string is left untouched.
- if (num_replacements > 0) {
- tmp.append(*s, pos, s->length() - pos);
- s->swap(tmp);
- }
- return num_replacements;
-}
-
namespace {
int CalculateBase64EscapedLen(int input_len, bool do_padding) {
// Base64 encodes three bytes of input at a time. If the input is not
diff --git a/src/google/protobuf/stubs/strutil.h b/src/google/protobuf/stubs/strutil.h
index 2aa522d..1e64d7b 100644
--- a/src/google/protobuf/stubs/strutil.h
+++ b/src/google/protobuf/stubs/strutil.h
@@ -68,99 +68,6 @@
}
// ----------------------------------------------------------------------
-// HasPrefixString()
-// Check if a string begins with a given prefix.
-// StripPrefixString()
-// Given a string and a putative prefix, returns the string minus the
-// prefix string if the prefix matches, otherwise the original
-// string.
-// ----------------------------------------------------------------------
-inline bool HasPrefixString(absl::string_view str, absl::string_view prefix) {
- return str.size() >= prefix.size() &&
- memcmp(str.data(), prefix.data(), prefix.size()) == 0;
-}
-
-inline std::string StripPrefixString(const std::string& str,
- const std::string& prefix) {
- if (HasPrefixString(str, prefix)) {
- return str.substr(prefix.size());
- } else {
- return str;
- }
-}
-
-// ----------------------------------------------------------------------
-// HasSuffixString()
-// Return true if str ends in suffix.
-// StripSuffixString()
-// Given a string and a putative suffix, returns the string minus the
-// suffix string if the suffix matches, otherwise the original
-// string.
-// ----------------------------------------------------------------------
-inline bool HasSuffixString(absl::string_view str, absl::string_view suffix) {
- return str.size() >= suffix.size() &&
- memcmp(str.data() + str.size() - suffix.size(), suffix.data(),
- suffix.size()) == 0;
-}
-
-inline std::string StripSuffixString(const std::string& str,
- const std::string& suffix) {
- if (HasSuffixString(str, suffix)) {
- return str.substr(0, str.size() - suffix.size());
- } else {
- return str;
- }
-}
-
-// ----------------------------------------------------------------------
-// ReplaceCharacters
-// Replaces any occurrence of the character 'remove' (or the characters
-// in 'remove') with the character 'replacewith'.
-// Good for keeping html characters or protocol characters (\t) out
-// of places where they might cause a problem.
-// StripWhitespace
-// Removes whitespaces from both ends of the given string.
-// ----------------------------------------------------------------------
-PROTOBUF_EXPORT void ReplaceCharacters(std::string* s, const char* remove,
- char replacewith);
-
-PROTOBUF_EXPORT void StripWhitespace(std::string* s);
-
-// ----------------------------------------------------------------------
-// LowerString()
-// UpperString()
-// ToUpper()
-// Convert the characters in "s" to lowercase or uppercase. ASCII-only:
-// these functions intentionally ignore locale because they are applied to
-// identifiers used in the Protocol Buffer language, not to natural-language
-// strings.
-// ----------------------------------------------------------------------
-
-inline void LowerString(std::string* s) {
- std::string::iterator end = s->end();
- for (std::string::iterator i = s->begin(); i != end; ++i) {
- // tolower() changes based on locale. We don't want this!
- if ('A' <= *i && *i <= 'Z') *i += 'a' - 'A';
- }
-}
-
-inline void UpperString(std::string* s) {
- std::string::iterator end = s->end();
- for (std::string::iterator i = s->begin(); i != end; ++i) {
- // toupper() changes based on locale. We don't want this!
- if ('a' <= *i && *i <= 'z') *i += 'A' - 'a';
- }
-}
-
-inline void ToUpper(std::string* s) { UpperString(s); }
-
-inline std::string ToUpper(const std::string& s) {
- std::string out = s;
- UpperString(&out);
- return out;
-}
-
-// ----------------------------------------------------------------------
// StringReplace()
// Give me a string and two patterns "old" and "new", and I replace
// the first instance of "old" in the string with "new", if it
@@ -273,134 +180,19 @@
}
// ----------------------------------------------------------------------
-// FastIntToBuffer()
-// FastHexToBuffer()
-// FastHex64ToBuffer()
-// FastHex32ToBuffer()
-// FastTimeToBuffer()
-// These are intended for speed. FastIntToBuffer() assumes the
-// integer is non-negative. FastHexToBuffer() puts output in
-// hex rather than decimal. FastTimeToBuffer() puts the output
-// into RFC822 format.
-//
-// FastHex64ToBuffer() puts a 64-bit unsigned value in hex-format,
-// padded to exactly 16 bytes (plus one byte for '\0')
-//
-// FastHex32ToBuffer() puts a 32-bit unsigned value in hex-format,
-// padded to exactly 8 bytes (plus one byte for '\0')
-//
-// All functions take the output buffer as an arg.
-// They all return a pointer to the beginning of the output,
-// which may not be the beginning of the input buffer.
-// ----------------------------------------------------------------------
-
-// Suggested buffer size for FastToBuffer functions. Also works with
-// DoubleToBuffer() and FloatToBuffer().
-static const int kFastToBufferSize = 32;
-
-PROTOBUF_EXPORT char* FastInt32ToBuffer(int32_t i, char* buffer);
-PROTOBUF_EXPORT char* FastInt64ToBuffer(int64_t i, char* buffer);
-char* FastUInt32ToBuffer(uint32_t i, char* buffer); // inline below
-char* FastUInt64ToBuffer(uint64_t i, char* buffer); // inline below
-PROTOBUF_EXPORT char* FastHexToBuffer(int i, char* buffer);
-PROTOBUF_EXPORT char* FastHex64ToBuffer(uint64_t i, char* buffer);
-PROTOBUF_EXPORT char* FastHex32ToBuffer(uint32_t i, char* buffer);
-
-// at least 22 bytes long
-inline char* FastIntToBuffer(int i, char* buffer) {
- return (sizeof(i) == 4 ?
- FastInt32ToBuffer(i, buffer) : FastInt64ToBuffer(i, buffer));
-}
-inline char* FastUIntToBuffer(unsigned int i, char* buffer) {
- return (sizeof(i) == 4 ?
- FastUInt32ToBuffer(i, buffer) : FastUInt64ToBuffer(i, buffer));
-}
-inline char* FastLongToBuffer(long i, char* buffer) {
- return (sizeof(i) == 4 ?
- FastInt32ToBuffer(i, buffer) : FastInt64ToBuffer(i, buffer));
-}
-inline char* FastULongToBuffer(unsigned long i, char* buffer) {
- return (sizeof(i) == 4 ?
- FastUInt32ToBuffer(i, buffer) : FastUInt64ToBuffer(i, buffer));
-}
-
-// ----------------------------------------------------------------------
-// FastInt32ToBufferLeft()
-// FastUInt32ToBufferLeft()
-// FastInt64ToBufferLeft()
-// FastUInt64ToBufferLeft()
-//
-// Like the Fast*ToBuffer() functions above, these are intended for speed.
-// Unlike the Fast*ToBuffer() functions, however, these functions write
-// their output to the beginning of the buffer (hence the name, as the
-// output is left-aligned). The caller is responsible for ensuring that
-// the buffer has enough space to hold the output.
-//
-// Returns a pointer to the end of the string (i.e. the null character
-// terminating the string).
-// ----------------------------------------------------------------------
-
-PROTOBUF_EXPORT char* FastInt32ToBufferLeft(int32_t i, char* buffer);
-PROTOBUF_EXPORT char* FastUInt32ToBufferLeft(uint32_t i, char* buffer);
-PROTOBUF_EXPORT char* FastInt64ToBufferLeft(int64_t i, char* buffer);
-PROTOBUF_EXPORT char* FastUInt64ToBufferLeft(uint64_t i, char* buffer);
-
-// Just define these in terms of the above.
-inline char* FastUInt32ToBuffer(uint32_t i, char* buffer) {
- FastUInt32ToBufferLeft(i, buffer);
- return buffer;
-}
-inline char* FastUInt64ToBuffer(uint64_t i, char* buffer) {
- FastUInt64ToBufferLeft(i, buffer);
- return buffer;
-}
-
-inline std::string SimpleBtoa(bool value) { return value ? "true" : "false"; }
-
-// ----------------------------------------------------------------------
-// SimpleItoa()
-// Description: converts an integer to a string.
-//
-// Return value: string
-// ----------------------------------------------------------------------
-PROTOBUF_EXPORT std::string SimpleItoa(int i);
-PROTOBUF_EXPORT std::string SimpleItoa(unsigned int i);
-PROTOBUF_EXPORT std::string SimpleItoa(long i);
-PROTOBUF_EXPORT std::string SimpleItoa(unsigned long i);
-PROTOBUF_EXPORT std::string SimpleItoa(long long i);
-PROTOBUF_EXPORT std::string SimpleItoa(unsigned long long i);
-
-// ----------------------------------------------------------------------
// SimpleDtoa()
// SimpleFtoa()
-// DoubleToBuffer()
-// FloatToBuffer()
// Description: converts a double or float to a string which, if
// passed to NoLocaleStrtod(), will produce the exact same original double
// (except in case of NaN; all NaNs are considered the same value).
// We try to keep the string short but it's not guaranteed to be as
// short as possible.
//
-// DoubleToBuffer() and FloatToBuffer() write the text to the given
-// buffer and return it. The buffer must be at least
-// kDoubleToBufferSize bytes for doubles and kFloatToBufferSize
-// bytes for floats. kFastToBufferSize is also guaranteed to be large
-// enough to hold either.
-//
// Return value: string
// ----------------------------------------------------------------------
PROTOBUF_EXPORT std::string SimpleDtoa(double value);
PROTOBUF_EXPORT std::string SimpleFtoa(float value);
-PROTOBUF_EXPORT char* DoubleToBuffer(double i, char* buffer);
-PROTOBUF_EXPORT char* FloatToBuffer(float i, char* buffer);
-
-// In practice, doubles should never need more than 24 bytes and floats
-// should never need more than 14 (including null terminators), but we
-// overestimate to be safe.
-static const int kDoubleToBufferSize = 32;
-static const int kFloatToBufferSize = 24;
-
namespace strings {
using Hex = absl::Hex;
@@ -413,17 +205,6 @@
// ----------------------------------------------------------------------
PROTOBUF_EXPORT std::string ToHex(uint64_t num);
-// ----------------------------------------------------------------------
-// GlobalReplaceSubstring()
-// Replaces all instances of a substring in a string. Does nothing
-// if 'substring' is empty. Returns the number of replacements.
-//
-// NOTE: The string pieces must not overlap s.
-// ----------------------------------------------------------------------
-PROTOBUF_EXPORT int GlobalReplaceSubstring(const std::string& substring,
- const std::string& replacement,
- std::string* s);
-
namespace strings {
// Encode src into dest web-safely with padding.
PROTOBUF_EXPORT void WebSafeBase64EscapeWithPadding(absl::string_view src,
@@ -452,15 +233,6 @@
// ----------------------------------------------------------------------
PROTOBUF_EXPORT int UTF8FirstLetterNumBytes(const char* src, int len);
-namespace strings {
-inline bool EndsWith(absl::string_view text, absl::string_view suffix) {
- return suffix.empty() ||
- (text.size() >= suffix.size() &&
- memcmp(text.data() + (text.size() - suffix.size()), suffix.data(),
- suffix.size()) == 0);
-}
-} // namespace strings
-
namespace internal {
// A locale-independent version of the standard strtod(), which always
diff --git a/src/google/protobuf/stubs/strutil_unittest.cc b/src/google/protobuf/stubs/strutil_unittest.cc
index d657579..71e60e6 100644
--- a/src/google/protobuf/stubs/strutil_unittest.cc
+++ b/src/google/protobuf/stubs/strutil_unittest.cc
@@ -74,62 +74,6 @@
setlocale(LC_NUMERIC, old_locale.c_str());
}
-class ReplaceChars
- : public ::testing::TestWithParam<
- std::tuple<std::string, std::string, const char*, char>> {};
-
-TEST_P(ReplaceChars, ReplacesAllOccurencesOfAnyCharInReplaceWithAReplaceChar) {
- std::string expected = std::get<0>(GetParam());
- std::string string_to_replace_in = std::get<1>(GetParam());
- const char* what_to_replace = std::get<2>(GetParam());
- char replacement = std::get<3>(GetParam());
- ReplaceCharacters(&string_to_replace_in, what_to_replace, replacement);
- ASSERT_EQ(expected, string_to_replace_in);
-}
-
-INSTANTIATE_TEST_CASE_P(
- Replace, ReplaceChars,
- ::testing::Values(
- std::make_tuple("", "", "", '_'), // empty string should remain empty
- std::make_tuple(" ", " ", "", '_'), // no replacement string
- std::make_tuple(" ", " ", "_-abcedf",
- '*'), // replacement character not in string
- std::make_tuple("replace", "Replace", "R",
- 'r'), // replace one character
- std::make_tuple("not_spaces__", "not\nspaces\t ", " \t\r\n",
- '_'), // replace some special characters
- std::make_tuple("c++", "cxx", "x",
- '+'), // same character multiple times
- std::make_tuple("qvvvvvng v T", "queueing a T", "aeiou",
- 'v'))); // replace all voewls
-
-class StripWs
- : public ::testing::TestWithParam<std::tuple<std::string, std::string>> {};
-
-TEST_P(StripWs, AlwaysStripsLeadingAndTrailingWhitespace) {
- std::string expected = std::get<0>(GetParam());
- std::string string_to_strip = std::get<1>(GetParam());
- StripWhitespace(&string_to_strip);
- ASSERT_EQ(expected, string_to_strip);
-}
-
-INSTANTIATE_TEST_CASE_P(
- Strip, StripWs,
- ::testing::Values(
- std::make_tuple("", ""), // empty string should remain empty
- std::make_tuple("", " "), // only ws should become empty
- std::make_tuple("no whitespace",
- " no whitespace"), // leading ws removed
- std::make_tuple("no whitespace",
- "no whitespace "), // trailing ws removed
- std::make_tuple("no whitespace",
- " no whitespace "), // same nb. of leading and trailing
- std::make_tuple(
- "no whitespace",
- " no whitespace "), // different nb. of leading/trailing
- std::make_tuple("no whitespace",
- " no whitespace "))); // more trailing than leading
-
} // anonymous namespace
} // namespace protobuf
} // namespace google
diff --git a/src/google/protobuf/testing/googletest.cc b/src/google/protobuf/testing/googletest.cc
index 350f9a9..5f6a4fb 100644
--- a/src/google/protobuf/testing/googletest.cc
+++ b/src/google/protobuf/testing/googletest.cc
@@ -38,6 +38,7 @@
#include <sys/stat.h>
#include <sys/types.h>
+#include "absl/strings/match.h"
#include "absl/strings/str_replace.h"
#include "google/protobuf/io/io_win32.h"
#include "google/protobuf/stubs/strutil.h"
@@ -147,7 +148,7 @@
}
// On Win32, tmpnam() returns a file prefixed with '\', but which is supposed
// to be used in the current working directory. WTF?
- if (HasPrefixString(result, "\\")) {
+ if (absl::StartsWith(result, "\\")) {
result.erase(0, 1);
}
// The Win32 API accepts forward slashes as a path delimiter as long as the
diff --git a/src/google/protobuf/util/internal/datapiece.cc b/src/google/protobuf/util/internal/datapiece.cc
index 5148329..7daed3f 100644
--- a/src/google/protobuf/util/internal/datapiece.cc
+++ b/src/google/protobuf/util/internal/datapiece.cc
@@ -43,6 +43,7 @@
#include "absl/strings/str_cat.h"
#include "google/protobuf/util/internal/utility.h"
#include "google/protobuf/stubs/strutil.h"
+#include "absl/strings/match.h"
#include "google/protobuf/stubs/mathutil.h"
namespace google {
@@ -263,7 +264,7 @@
case TYPE_FLOAT:
return FloatAsString(float_);
case TYPE_BOOL:
- return SimpleBtoa(bool_);
+ return bool_ ? "true" : "false";
case TYPE_STRING:
return absl::StrCat("\"", str_, "\"");
case TYPE_BYTES: {
@@ -397,7 +398,7 @@
absl::WebSafeBase64Escape(*dest, &encoded);
// Remove trailing padding '=' characters before comparison.
absl::string_view src_no_padding = absl::string_view(src).substr(
- 0, HasSuffixString(src, "=") ? src.find_last_not_of('=') + 1
+ 0, absl::EndsWith(src, "=") ? src.find_last_not_of('=') + 1
: src.length());
return encoded == src_no_padding;
}
@@ -409,7 +410,7 @@
std::string encoded;
strings::LegacyBase64EscapeWithoutPadding(*dest, &encoded);
absl::string_view src_no_padding = absl::string_view(src).substr(
- 0, HasSuffixString(src, "=") ? src.find_last_not_of('=') + 1
+ 0, absl::EndsWith(src, "=") ? src.find_last_not_of('=') + 1
: src.length());
return encoded == src_no_padding;
}
diff --git a/src/google/protobuf/util/internal/field_mask_utility.cc b/src/google/protobuf/util/internal/field_mask_utility.cc
index e0ffe13..5cdc29d 100644
--- a/src/google/protobuf/util/internal/field_mask_utility.cc
+++ b/src/google/protobuf/util/internal/field_mask_utility.cc
@@ -31,7 +31,7 @@
#include "google/protobuf/util/internal/field_mask_utility.h"
#include "absl/status/status.h"
-#include "google/protobuf/stubs/strutil.h"
+#include "absl/strings/match.h"
#include "absl/strings/str_cat.h"
#include "google/protobuf/util/internal/utility.h"
#include "google/protobuf/stubs/status_macros.h"
@@ -56,7 +56,7 @@
return std::string(prefix);
}
// If the segment is a map key, appends it to the prefix without the ".".
- if (HasPrefixString(segment, "[\"")) {
+ if (absl::StartsWith(segment, "[\"")) {
return absl::StrCat(prefix, segment);
}
return absl::StrCat(prefix, ".", segment);
diff --git a/src/google/protobuf/util/internal/json_stream_parser.cc b/src/google/protobuf/util/internal/json_stream_parser.cc
index eccedb9..c294009 100644
--- a/src/google/protobuf/util/internal/json_stream_parser.cc
+++ b/src/google/protobuf/util/internal/json_stream_parser.cc
@@ -43,6 +43,7 @@
#include "absl/status/status.h"
#include "absl/strings/ascii.h"
#include "absl/strings/escaping.h"
+#include "absl/strings/match.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/string_view.h"
#include "google/protobuf/util/internal/object_writer.h"
@@ -966,15 +967,15 @@
return BEGIN_NUMBER;
}
if (size >= kKeywordTrue.length() &&
- HasPrefixString(data_view, kKeywordTrue)) {
+ absl::StartsWith(data_view, kKeywordTrue)) {
return BEGIN_TRUE;
}
if (size >= kKeywordFalse.length() &&
- HasPrefixString(data_view, kKeywordFalse)) {
+ absl::StartsWith(data_view, kKeywordFalse)) {
return BEGIN_FALSE;
}
if (size >= kKeywordNull.length() &&
- HasPrefixString(data_view, kKeywordNull)) {
+ absl::StartsWith(data_view, kKeywordNull)) {
return BEGIN_NULL;
}
if (*data == '{') return BEGIN_OBJECT;
diff --git a/src/google/protobuf/util/internal/protostream_objectwriter.cc b/src/google/protobuf/util/internal/protostream_objectwriter.cc
index 677647e..2c4d5ef 100644
--- a/src/google/protobuf/util/internal/protostream_objectwriter.cc
+++ b/src/google/protobuf/util/internal/protostream_objectwriter.cc
@@ -41,6 +41,7 @@
#include "absl/base/call_once.h"
#include "absl/status/status.h"
#include "absl/status/statusor.h"
+#include "absl/strings/match.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/strip.h"
#include "absl/time/time.h"
@@ -1048,7 +1049,7 @@
absl::string_view value(data.str());
int timezone_offset_seconds = 0;
- if (HasSuffixString(value, "Z")) {
+ if (absl::EndsWith(value, "Z")) {
value = value.substr(0, value.size() - 1);
} else {
size_t pos = value.find_last_of("+-");
@@ -1123,13 +1124,13 @@
absl::string_view value(data.str());
- if (!HasSuffixString(value, "s")) {
+ if (!absl::EndsWith(value, "s")) {
return absl::InvalidArgumentError(
"Illegal duration format; duration must end with 's'");
}
value = value.substr(0, value.size() - 1);
int sign = 1;
- if (HasPrefixString(value, "-")) {
+ if (absl::StartsWith(value, "-")) {
sign = -1;
value = value.substr(1);
}
diff --git a/src/google/protobuf/util/internal/utility.cc b/src/google/protobuf/util/internal/utility.cc
index f8054ca..c2488e8 100644
--- a/src/google/protobuf/util/internal/utility.cc
+++ b/src/google/protobuf/util/internal/utility.cc
@@ -45,6 +45,7 @@
#include "google/protobuf/stubs/strutil.h"
#include "absl/container/flat_hash_set.h"
#include "absl/strings/ascii.h"
+#include "absl/strings/match.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/string_view.h"
#include "google/protobuf/util/internal/constants.h"
diff --git a/src/google/protobuf/util/json_util.cc b/src/google/protobuf/util/json_util.cc
index 8df4733..2942eeb 100644
--- a/src/google/protobuf/util/json_util.cc
+++ b/src/google/protobuf/util/json_util.cc
@@ -32,6 +32,7 @@
#include "absl/base/call_once.h"
#include "absl/status/status.h"
+#include "absl/strings/ascii.h"
#include "google/protobuf/stubs/bytestream.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/string_view.h"
@@ -141,7 +142,7 @@
std::string GetLocString(const converter::LocationTrackerInterface& loc) {
std::string loc_string = loc.ToString();
- StripWhitespace(&loc_string);
+ absl::StripAsciiWhitespace(&loc_string);
if (!loc_string.empty()) {
loc_string = absl::StrCat("(", loc_string, ")");
}
diff --git a/src/google/protobuf/util/json_util_test.cc b/src/google/protobuf/util/json_util_test.cc
index 3f18431..3b582c4 100644
--- a/src/google/protobuf/util/json_util_test.cc
+++ b/src/google/protobuf/util/json_util_test.cc
@@ -509,6 +509,32 @@
IsOkAndHolds("[0.99000000953674316,0.87999999523162842]"));
}
+TEST_P(JsonTest, FloatMinMaxValue) {
+ // 3.4028235e38 is FLT_MAX to 8-significant-digits. The final digit (5)
+ // is rounded up; that means that when parsing this as a 64-bit FP number,
+ // the value ends up higher than FLT_MAX. We still want to accept it though,
+ // as a reasonable representation of FLT_MAX.
+ auto m = ToProto<TestMessage>(R"json(
+ {
+ "repeatedFloatValue": [3.4028235e38, -3.4028235e38],
+ }
+ )json");
+ ASSERT_OK(m);
+ EXPECT_THAT(m->repeated_float_value(), ElementsAre(FLT_MAX, -FLT_MAX));
+}
+
+TEST_P(JsonTest, FloatOutOfRange) {
+ // Check that the slightly-lenient parsing demonstrated in FloatMinMaxValue
+ // doesn't mean we allow all values. The value being parsed differs only
+ // in the least significant (represented) digit.
+ auto m = ToProto<TestMessage>(R"json(
+ {
+ "floatValue": 3.4028236e38
+ }
+ )json");
+ EXPECT_THAT(m, StatusIs(absl::StatusCode::kInvalidArgument));
+}
+
TEST_P(JsonTest, ParseLegacySingleRepeatedField) {
auto m = ToProto<TestMessage>(R"json({
"repeatedInt32Value": 1997,
diff --git a/src/google/protobuf/util/message_differencer.cc b/src/google/protobuf/util/message_differencer.cc
index 51b2bea..ba4db19 100644
--- a/src/google/protobuf/util/message_differencer.cc
+++ b/src/google/protobuf/util/message_differencer.cc
@@ -57,6 +57,7 @@
#include "google/protobuf/stubs/strutil.h"
#include "absl/container/fixed_array.h"
#include "absl/strings/escaping.h"
+#include "absl/strings/match.h"
#include "absl/strings/str_cat.h"
#include "google/protobuf/stubs/stringprintf.h"
#include "google/protobuf/util/field_comparator.h"
diff --git a/src/google/protobuf/wire_format_unittest.inc b/src/google/protobuf/wire_format_unittest.inc
index 5653be7..6224ae7 100644
--- a/src/google/protobuf/wire_format_unittest.inc
+++ b/src/google/protobuf/wire_format_unittest.inc
@@ -45,7 +45,7 @@
#include <gtest/gtest.h>
#include "absl/base/casts.h"
#include "google/protobuf/stubs/logging.h"
-#include "google/protobuf/stubs/strutil.h"
+#include "absl/strings/match.h"
#include "google/protobuf/dynamic_message.h"
#include "google/protobuf/test_util2.h"
#include "google/protobuf/stubs/stl_util.h"
@@ -1560,7 +1560,7 @@
#ifdef GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED
ASSERT_EQ(1, errors.size());
EXPECT_TRUE(
- HasPrefixString(errors[0],
+ absl::StartsWith(errors[0],
"String field contains invalid UTF-8 data when "
"serializing a protocol buffer. Use the "
"'bytes' type if you intend to send raw bytes."));
