diff --git a/cpp/.clang-tidy b/cpp/.clang-tidy
index e57be52d0f6306b2c5190d9a3c7a0c402508131b..756a03e01eb88879438b18d2cfd27e75c3092d8b 100644
--- a/cpp/.clang-tidy
+++ b/cpp/.clang-tidy
@@ -1,5 +1,5 @@
---
-Checks: 'clang-diagnostic-*,clang-analyzer-*,modernize-*,readability-*,-readability-container-size-empty'
+Checks: 'clang-diagnostic-*,clang-analyzer-*,modernize-*,readability-*,-readability-container-size-empty,-readability-magic-numbers'
WarningsAsErrors: ''
HeaderFilterRegex: ''
AnalyzeTemporaryDtors: false
diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
index 8ad13acf0a8899fb8ce9b582f1e11543ca0591c2..81ddf56dc84ab8900038e8c42d02b11bc720bcf4 100644
--- a/cpp/CMakeLists.txt
+++ b/cpp/CMakeLists.txt
@@ -9,7 +9,8 @@ project (vereign)
# Options
option(VEREIGN_USE_LLD "Use the lld linker" OFF)
option(VEREIGN_USE_PRECOMPILED_HEADERS "Use precompiled headers" OFF)
-option(VEREIGN_USE_TIME_TRACE OFF)
+option(VEREIGN_USE_TIME_TRACE "Use compilation profiler" OFF)
+option(VEREIGN_ENABLE_BENCHMARKING "Enable tests benchmarks" ON)
if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS "19.0.24215.1")
@@ -86,6 +87,7 @@ message(STATUS "Using vendor install dir: ${VENDOR_INSTALL_DIR}")
set(_cmake_prefix_paths
${VENDOR_INSTALL_DIR}
${VENDOR_INSTALL_DIR}/grpc
+ ${VENDOR_INSTALL_DIR}/nlohmann
)
set(CMAKE_PREFIX_PATH ${_cmake_prefix_paths} CACHE STRING "")
@@ -128,6 +130,8 @@ else()
set(GRPC_CPP_PLUGIN_EXECUTABLE $<TARGET_FILE:gRPC::grpc_cpp_plugin>)
endif()
+find_package(nlohmann_json 3.7.3 REQUIRED)
+
add_subdirectory("src")
add_subdirectory("tests")
@@ -164,8 +168,10 @@ message(STATUS "summary of build options:
Boost ${Boost_FOUND} [${Boost_VERSION_STRING}] (DIR='${Boost_DIR}')
Boost libs ${Boost_LIBRARIES}
gRPC ${gRPC_FOUND} [${gRPC_VERSION}] (LIBS='${_grpc_libs}')
+ nlohmann ${nlohmann_json_FOUND} [${nlohmann_json_VERSION}] (HEADERS='${nlohmann_json_DIR}')
Options:
- VEREIGN_USE_LLD ${VEREIGN_USE_LLD}
- VEREIGN_USE_PRECOMPILED_HEADERS ${VEREIGN_USE_PRECOMPILED_HEADERS}
- VEREIGN_USE_TIME_TRACE ${VEREIGN_USE_TIME_TRACE}
+ VEREIGN_USE_LLD ${VEREIGN_USE_LLD}
+ VEREIGN_USE_PRECOMPILED_HEADERS ${VEREIGN_USE_PRECOMPILED_HEADERS}
+ VEREIGN_USE_TIME_TRACE ${VEREIGN_USE_TIME_TRACE}
+ VEREIGN_ENABLE_BENCHMARKING ${VEREIGN_ENABLE_BENCHMARKING}
")
diff --git a/cpp/cmake/ProtoGenerate.cmake b/cpp/cmake/ProtoGenerate.cmake
index 89adc18d08049f8a7e98e9cfb8afdf97d42e459e..cb819b7888213d31771fae9e88acf358d2692157 100644
--- a/cpp/cmake/ProtoGenerate.cmake
+++ b/cpp/cmake/ProtoGenerate.cmake
@@ -11,8 +11,8 @@ function(target_proto_generate)
message(STATUS "proto target: ${PROTO_TARGET}")
message(STATUS " proto output dir: ${PROTO_GEN_DIR}")
message(STATUS " proto src dir: ${PROTO_SRC_DIR}")
+ message(STATUS " ${PROTO_DEFINITIONS}")
- # FIXME: remove hardcoded googleapis include below
foreach (proto ${PROTO_DEFINITIONS})
get_filename_component(_proto ${proto} ABSOLUTE)
get_filename_component(_proto_path "${_proto}" PATH)
@@ -31,7 +31,6 @@ function(target_proto_generate)
--cpp_out "${PROTO_GEN_DIR}"
--proto_path "${PROTO_SRC_DIR}"
-I "${_proto_path}"
- -I "${CMAKE_SOURCE_DIR}/src/vereign/proto/googleapis"
"${_proto}"
DEPENDS "${_proto}")
@@ -52,7 +51,6 @@ function(target_grpc_generate)
message(STATUS " grpc output dir: ${PROTO_GEN_DIR}")
message(STATUS " grpc src dir: ${PROTO_SRC_DIR}")
- # FIXME: remove hardcoded googleapis include below
foreach (proto ${PROTO_DEFINITIONS})
get_filename_component(_proto ${proto} ABSOLUTE)
get_filename_component(_proto_path "${_proto}" PATH)
@@ -72,7 +70,6 @@ function(target_grpc_generate)
--cpp_out "${PROTO_GEN_DIR}"
--proto_path "${PROTO_SRC_DIR}"
-I "${_proto_path}"
- -I "${CMAKE_SOURCE_DIR}/src/vereign/proto/googleapis"
--plugin=protoc-gen-grpc="${GRPC_CPP_PLUGIN_EXECUTABLE}"
"${_proto}"
DEPENDS "${_proto}")
diff --git a/cpp/src/CMakeLists.txt b/cpp/src/CMakeLists.txt
index 2defa3f6a017616e9705a17b6a235dec62ecdfdc..750195c025156762b909964bde8e8795711a11c5 100644
--- a/cpp/src/CMakeLists.txt
+++ b/cpp/src/CMakeLists.txt
@@ -35,24 +35,27 @@ target_link_libraries(
OpenSSL::Crypto
$<$<CXX_COMPILER_ID:MSVC>:CRYPT32.LIB>
)
-file(GLOB PROTO_HEADERS ${CMAKE_SOURCE_DIR}/proto/cpp/vereign/client_library/*pb.h)
-target_precompile_headers(vereignproto PUBLIC ${PROTO_HEADERS})
+if (VEREIGN_USE_PRECOMPILED_HEADERS)
+ file(GLOB PROTO_HEADERS ${CMAKE_SOURCE_DIR}/proto/cpp/vereign/client_library/*pb.h)
+ target_precompile_headers(vereignproto PUBLIC ${PROTO_HEADERS})
+endif()
set(VEREIGNLIB_SRC
vereign/restapi/detail/http_reader.cc
vereign/restapi/client.cc
+ vereign/service/passport_service.cc
vereign/grpc/gen/gen.cc
+ vereign/grpc/json/encoder.cc
vereign/grpc/service_registry.cc
vereign/grpc/server.cc
- vereign/service/passport_service.cc
)
file(GLOB GENERATED_SERVICES_SRC vereign/service/gen/*.cc)
list(APPEND VEREIGNLIB_SRC ${GENERATED_SERVICES_SRC})
add_library(vereignlib STATIC ${VEREIGNLIB_SRC})
-target_link_libraries(
- vereignlib
+target_link_libraries(vereignlib PRIVATE nlohmann_json::nlohmann_json)
+target_link_libraries(vereignlib PUBLIC
vereignproto
gRPC::grpc++_reflection
gRPC::grpc++
diff --git a/cpp/src/csandbox.cc b/cpp/src/csandbox.cc
index 3c3bf93fcc2f082edab0b1f4599c1f0a7bbc47d3..7a1eb95ff82436b8f836f9d8e2bdf1e73651a087 100644
--- a/cpp/src/csandbox.cc
+++ b/cpp/src/csandbox.cc
@@ -1,2 +1,6 @@
+#include <iostream>
+
auto main(int argc, char* argv[]) -> int {
+ std::cout << "hello" << std::endl;
+ return 0;
}
diff --git a/cpp/src/vereign/core/hex.hh b/cpp/src/vereign/core/hex.hh
new file mode 100644
index 0000000000000000000000000000000000000000..a370a6e98f39594c98578e1c455a8e390881b69e
--- /dev/null
+++ b/cpp/src/vereign/core/hex.hh
@@ -0,0 +1,55 @@
+#ifndef __VEREIGN_CORE_HEX_HH
+#define __VEREIGN_CORE_HEX_HH
+
+#include <string>
+
+namespace vereign {
+namespace core {
+namespace detail {
+
+inline auto charToInt(char ch) -> int {
+ if (ch >= '0' && ch <= '9') {
+ return ch - '0';
+ }
+
+ if (ch >= 'A' && ch <= 'F') {
+ return ch - 'A' + 10;
+ }
+
+ if (ch >= 'a' && ch <= 'f') {
+ return ch - 'a' + 10;
+ }
+
+ return 0;
+}
+
+} // namespace detail
+
+inline auto BinToHex(const unsigned char* src, std::size_t size) -> std::string {
+ static const char* nibbles = { "0123456789abcdef" };
+
+ std::string result;
+ result.reserve(size * 2);
+
+ for (std::size_t i = 0; i < size; ++i) {
+ result.push_back(nibbles[src[i] >> 4]);
+ result.push_back(nibbles[src[i] & 0x0F]);
+ }
+
+ return result;
+}
+
+inline auto BinToHex(const std::string& src) -> std::string {
+ return BinToHex((unsigned char*) src.c_str(), src.size());
+}
+
+inline void hex_to_bin(const std::string& src, unsigned char* dst) {
+ for (int i = 0, len = (int) src.size() - 1; i < len; i += 2) {
+ dst[i/2] = detail::charToInt(src[i]) * 16 + detail::charToInt(src[i + 1]);
+ }
+}
+
+} // namespace core
+} // namespace vereign
+
+#endif // __VEREIGN_CORE_HEX_HH
diff --git a/cpp/src/vereign/grpc/json/encoder.cc b/cpp/src/vereign/grpc/json/encoder.cc
new file mode 100644
index 0000000000000000000000000000000000000000..31a22833540b2c80d7bbe6adc2d436e0a9a27523
--- /dev/null
+++ b/cpp/src/vereign/grpc/json/encoder.cc
@@ -0,0 +1,343 @@
+#include <iterator>
+#include <vereign/grpc/json/encoder.hh>
+
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/reflection.h>
+#include <nlohmann/json.hpp>
+
+#include <boost/beast/core/detail/base64.hpp>
+
+namespace vereign {
+namespace grpc {
+namespace json {
+
+namespace detail {
+
+/**
+ * The encoder used by ::Encode function.
+ *
+ * It currently uses https://github.com/nlohmann/json library.
+ */
+class Encoder {
+public:
+ Encoder(const EncodeOptions& options)
+ : options_{options}
+ {
+ }
+
+ void Encode(
+ const google::protobuf::Message& msg,
+ std::string& output
+ ) {
+ nlohmann::json json = nlohmann::json::object();
+ encodeMessage(json, msg);
+ output = json.dump(options_.Indent);
+ }
+
+private:
+ void encodeMessage(nlohmann::json& json, const google::protobuf::Message& msg) {
+ const google::protobuf::Descriptor* desc = msg.GetDescriptor();
+ const google::protobuf::Reflection* refl = msg.GetReflection();
+ int field_cnt = desc->field_count();
+ for (int i = 0; i < field_cnt; i++) {
+ const google::protobuf::FieldDescriptor* field = desc->field(i);
+ // skip non-existing onef values
+ if (field->containing_oneof() != nullptr && !refl->HasField(msg, field)) {
+ continue;
+ }
+
+ if (field->is_map()) {
+ encodeMapFieldValue(json, field->name(), msg, field, refl);
+ continue;
+ }
+
+ if (field->is_repeated()) {
+ encodeRepeatedFieldValue(json, field->name(), msg, field, refl);
+ continue;
+ }
+
+ if (!field->is_repeated()) {
+ encodeFieldValue(json, field->name(), msg, field, refl);
+ }
+ }
+ }
+
+ template <typename T>
+ void encodeNumberValue(nlohmann::json& json, const std::string& field_name, T number) {
+ if (number == 0 && options_.OmitEmpty) {
+ return;
+ }
+
+ json[field_name] = number;
+ }
+
+ void encodeFieldValue(
+ nlohmann::json& json,
+ const std::string& name,
+ const google::protobuf::Message& msg,
+ const google::protobuf::FieldDescriptor* field,
+ const google::protobuf::Reflection* refl
+ ) {
+ switch (field->type()) {
+ case google::protobuf::FieldDescriptor::TYPE_ENUM:
+ encodeNumberValue(json, name, refl->GetEnumValue(msg, field));
+ break;
+
+ case google::protobuf::FieldDescriptor::TYPE_INT32:
+ case google::protobuf::FieldDescriptor::TYPE_SINT32:
+ case google::protobuf::FieldDescriptor::TYPE_SFIXED32:
+ encodeNumberValue(json, name, refl->GetInt32(msg, field));
+ break;
+
+ case google::protobuf::FieldDescriptor::TYPE_INT64:
+ case google::protobuf::FieldDescriptor::TYPE_SINT64:
+ case google::protobuf::FieldDescriptor::TYPE_SFIXED64:
+ encodeNumberValue(json, name, refl->GetInt64(msg, field));
+ break;
+
+ case google::protobuf::FieldDescriptor::TYPE_UINT32:
+ case google::protobuf::FieldDescriptor::TYPE_FIXED32:
+ encodeNumberValue(json, name, refl->GetUInt32(msg, field));
+ break;
+
+ case google::protobuf::FieldDescriptor::TYPE_UINT64:
+ case google::protobuf::FieldDescriptor::TYPE_FIXED64:
+ encodeNumberValue(json, name, refl->GetUInt64(msg, field));
+ break;
+
+ case google::protobuf::FieldDescriptor::TYPE_FLOAT:
+ encodeNumberValue(json, name, refl->GetFloat(msg, field));
+ break;
+
+ case google::protobuf::FieldDescriptor::TYPE_DOUBLE:
+ encodeNumberValue(json, name, refl->GetDouble(msg, field));
+ break;
+
+ case google::protobuf::FieldDescriptor::TYPE_BOOL:
+ json[name] = refl->GetBool(msg, field);
+ break;
+
+ case google::protobuf::FieldDescriptor::TYPE_STRING: {
+ auto value = refl->GetString(msg, field);
+ if (value.empty() && options_.OmitEmpty) {
+ break;
+ }
+
+ json[name] = std::move(value);
+ break;
+ }
+ case google::protobuf::FieldDescriptor::TYPE_BYTES: {
+ auto bytes = refl->GetString(msg, field);
+ if (bytes.empty() && options_.OmitEmpty) {
+ break;
+ }
+
+ json[name] = base64Encode(bytes);
+ break;
+ }
+ case google::protobuf::FieldDescriptor::TYPE_MESSAGE: {
+ nlohmann::json obj;
+ encodeMessage(obj, refl->GetMessage(msg, field));
+ if (obj.empty() && options_.OmitEmpty) {
+ break;
+ }
+
+ json[name] = std::move(obj);
+ break;
+ }
+ default:
+ throw EncodeError{"unknown type " + std::string(field->type_name())};
+ }
+ }
+
+ static auto base64Encode(const std::string& src) -> std::string {
+ std::string dst;
+ dst.resize(boost::beast::detail::base64::encoded_size(src.size()));
+ dst.resize(boost::beast::detail::base64::encode((void*)dst.data(), src.data(), src.size()));
+ return dst;
+ }
+
+ template <typename T>
+ void encodeRepeatedScalar(
+ nlohmann::json& jsonArr,
+ const google::protobuf::Message& msg,
+ const google::protobuf::FieldDescriptor* field,
+ const google::protobuf::Reflection* refl
+ ) {
+ int size = refl->FieldSize(msg, field);
+ auto repeatedField = refl->GetRepeatedFieldRef<T>(msg, field);
+ for (int i = 0; i < size; i++) {
+ jsonArr.push_back(repeatedField.Get(i));
+ }
+ }
+
+ void encodeRepeatedFieldValue(
+ nlohmann::json& json,
+ const std::string& name,
+ const google::protobuf::Message& msg,
+ const google::protobuf::FieldDescriptor* field,
+ const google::protobuf::Reflection* refl
+ ) {
+ if (refl->FieldSize(msg, field) == 0) {
+ if (options_.OmitEmpty) {
+ return;
+ }
+
+ json[name] = nlohmann::json::array();
+ return;
+ }
+
+ json[name] = nlohmann::json::array();
+ auto& jsonArr = json[name];
+
+ switch (field->type()) {
+ case google::protobuf::FieldDescriptor::TYPE_ENUM:
+ encodeRepeatedScalar<int32_t>(jsonArr, msg, field, refl);
+ break;
+
+ case google::protobuf::FieldDescriptor::TYPE_INT32:
+ case google::protobuf::FieldDescriptor::TYPE_SINT32:
+ case google::protobuf::FieldDescriptor::TYPE_SFIXED32:
+ encodeRepeatedScalar<int32_t>(jsonArr, msg, field, refl);
+ break;
+
+ case google::protobuf::FieldDescriptor::TYPE_INT64:
+ case google::protobuf::FieldDescriptor::TYPE_SINT64:
+ case google::protobuf::FieldDescriptor::TYPE_SFIXED64:
+ encodeRepeatedScalar<int64_t>(jsonArr, msg, field, refl);
+ break;
+
+ case google::protobuf::FieldDescriptor::TYPE_UINT32:
+ case google::protobuf::FieldDescriptor::TYPE_FIXED32:
+ encodeRepeatedScalar<uint32_t>(jsonArr, msg, field, refl);
+ break;
+
+ case google::protobuf::FieldDescriptor::TYPE_UINT64:
+ case google::protobuf::FieldDescriptor::TYPE_FIXED64:
+ encodeRepeatedScalar<uint64_t>(jsonArr, msg, field, refl);
+ break;
+
+ case google::protobuf::FieldDescriptor::TYPE_FLOAT:
+ encodeRepeatedScalar<float>(jsonArr, msg, field, refl);
+ break;
+
+ case google::protobuf::FieldDescriptor::TYPE_DOUBLE:
+ encodeRepeatedScalar<double>(jsonArr, msg, field, refl);
+ break;
+
+ case google::protobuf::FieldDescriptor::TYPE_BOOL:
+ encodeRepeatedScalar<bool>(jsonArr, msg, field, refl);
+ break;
+
+ case google::protobuf::FieldDescriptor::TYPE_STRING:
+ encodeRepeatedScalar<std::string>(jsonArr, msg, field, refl);
+ break;
+
+ case google::protobuf::FieldDescriptor::TYPE_BYTES: {
+ int size = refl->FieldSize(msg, field);
+ for (int i = 0; i < size; i++) {
+ jsonArr.push_back(base64Encode(refl->GetRepeatedString(msg, field, i)));
+ }
+ break;
+ }
+ case google::protobuf::FieldDescriptor::TYPE_MESSAGE: {
+ int size = refl->FieldSize(msg, field);
+ for (int i = 0; i < size; i++) {
+ nlohmann::json obj = nlohmann::json::object();
+ encodeMessage(obj, refl->GetRepeatedMessage(msg, field, i));
+ jsonArr.push_back(std::move(obj));
+ }
+ break;
+ }
+ default:
+ throw EncodeError{"unknown type " + std::to_string(field->type())};
+ }
+ }
+
+ void encodeMapFieldValue(
+ nlohmann::json& json,
+ const std::string& name,
+ const google::protobuf::Message& msg,
+ const google::protobuf::FieldDescriptor* field,
+ const google::protobuf::Reflection* refl
+ ) {
+ int size = refl->FieldSize(msg, field);
+ if (size == 0 && options_.OmitEmpty) {
+ return;
+ }
+
+ json[name] = nlohmann::json::object();
+ auto& mapObj = json[name];
+
+ for (int i = 0; i < size; i++) {
+ auto& pairMsg = refl->GetRepeatedMessage(msg, field, i);
+
+ const google::protobuf::Descriptor* pairDesc = pairMsg.GetDescriptor();
+ const google::protobuf::Reflection* pairRefl = pairMsg.GetReflection();
+
+ auto valueField = pairDesc->FindFieldByName("value");
+ if (valueField == nullptr) {
+ throw EncodeError{"cannot find map value field"};
+ }
+
+ auto keyField = pairDesc->FindFieldByName("key");
+ if (keyField == nullptr) {
+ throw EncodeError{"cannot find map key field"};
+ }
+
+ encodeFieldValue(
+ mapObj,
+ getMapKey(pairMsg, keyField, pairRefl),
+ pairMsg,
+ valueField,
+ pairRefl
+ );
+ }
+ }
+
+ static auto getMapKey(
+ const google::protobuf::Message& msg,
+ const google::protobuf::FieldDescriptor* keyField,
+ const google::protobuf::Reflection* mapRefl
+ ) -> std::string {
+
+ switch (keyField->type()) {
+ case google::protobuf::FieldDescriptor::TYPE_INT32:
+ case google::protobuf::FieldDescriptor::TYPE_SINT32:
+ case google::protobuf::FieldDescriptor::TYPE_SFIXED32:
+ return std::to_string(mapRefl->GetInt32(msg, keyField));
+
+ case google::protobuf::FieldDescriptor::TYPE_INT64:
+ case google::protobuf::FieldDescriptor::TYPE_SINT64:
+ case google::protobuf::FieldDescriptor::TYPE_SFIXED64:
+ return std::to_string(mapRefl->GetInt64(msg, keyField));
+
+ case google::protobuf::FieldDescriptor::TYPE_UINT32:
+ case google::protobuf::FieldDescriptor::TYPE_FIXED32:
+ return std::to_string(mapRefl->GetUInt32(msg, keyField));
+
+ case google::protobuf::FieldDescriptor::TYPE_UINT64:
+ case google::protobuf::FieldDescriptor::TYPE_FIXED64:
+ return std::to_string(mapRefl->GetUInt64(msg, keyField));
+
+ case google::protobuf::FieldDescriptor::TYPE_STRING:
+ return mapRefl->GetString(msg, keyField);
+
+ default:
+ throw EncodeError{"unsupported map key type " + std::string(keyField->type_name())};
+ }
+ }
+
+private:
+ const EncodeOptions& options_;
+}; // class Encoder
+
+}
+
+void Encode(const google::protobuf::Message& msg, std::string& json, const EncodeOptions& options) {
+ detail::Encoder{options}.Encode(msg, json);
+}
+
+} // namespace json
+} // namespace grpc
+} // namespace vereign
diff --git a/cpp/src/vereign/grpc/json/encoder.hh b/cpp/src/vereign/grpc/json/encoder.hh
new file mode 100644
index 0000000000000000000000000000000000000000..272c4593706a18f4e75d1bb95ab18bb9cf73ed32
--- /dev/null
+++ b/cpp/src/vereign/grpc/json/encoder.hh
@@ -0,0 +1,80 @@
+#ifndef __VEREIGN_GRPC_JSON_HH
+#define __VEREIGN_GRPC_JSON_HH
+
+#include <google/protobuf/message.h>
+
+namespace vereign {
+namespace grpc {
+namespace json {
+
+/**
+ * EncodeError is thrown from ::Encode function upon encode failures.
+ */
+class EncodeError: public std::runtime_error {
+public:
+ EncodeError(const std::string& what) : std::runtime_error{what} {}
+};
+
+/**
+ * Encode options for the ::Encode function.
+ */
+struct EncodeOptions {
+ /**
+ * Constructs the default options.
+ *
+ * The defaults are:
+ * ```
+ * OmitEmpty: false // empty values will be encoded
+ * Indent: -1 // indentation is disabled
+ * ```
+ */
+ EncodeOptions()
+ : OmitEmpty{false},
+ Indent{-1}
+ {}
+
+ /**
+ * Enables pretty printing with the provided indentation.
+ *
+ * @param indent Number of spaces to use for the pretty printing.
+ */
+ auto Pretty(int indent) -> EncodeOptions& {
+ Indent = indent;
+ return *this;
+ }
+
+ /**
+ * Enables omit empty option.
+ *
+ * Empty values will not be encoded.
+ */
+ auto WithOmitEmpty() -> EncodeOptions& {
+ OmitEmpty = true;
+ return *this;
+ }
+
+ //! When true the empty values will not be encoded.
+ bool OmitEmpty;
+
+ //! When greater than 0, ::Encode will encode with the specified number of spaces.
+ int Indent;
+};
+
+/**
+ * Encodes given protobuf message into json string.
+ *
+ * This was written, because the protobuf's own implementation encodes 64bit numbers as strings,
+ * and there is no capability to configure that.
+ *
+ * @param msg The protobuf message to encode.
+ * @param json The result of the encoding.
+ * @param options Encode options for things like pretty json and omitting empty values.
+ * @throws EncodeError when the encoding fails.
+ */
+void Encode(const google::protobuf::Message& msg, std::string& json, const EncodeOptions& options);
+
+} // namespace json
+} // namespace grpc
+} // namespace vereign
+
+#endif // __VEREIGN_GRPC_JSON_HH
diff --git a/cpp/src/vereign/restapi/client_session.hh b/cpp/src/vereign/restapi/client_session.hh
index 67226ff830ef8cd4015365e9893a2c519ec4d07e..28e848a7e270c52f09e083132a862c51e08caded 100644
--- a/cpp/src/vereign/restapi/client_session.hh
+++ b/cpp/src/vereign/restapi/client_session.hh
@@ -317,6 +317,15 @@ private:
{"publicKey", pub_key_}
},
[this, cf = std::move(cf)] (ResultType&& result) mutable {
+ if (result.Response->code() != "200") {
+ cf(detail::AuthErrorType{
+ result.Response->code(),
+ result.Response->status(),
+ result.Response->error()
+ });
+ return;
+ }
+
if (!result.Response->has_data()) {
cf(detail::AuthErrorType{
"500",
diff --git a/cpp/src/vereign/restapi/detail/post_task.hh b/cpp/src/vereign/restapi/detail/post_task.hh
index 78bb4398e399951c2a8177d892df79801c5d4187..74f1ea70ae57b105207529f64c86aa27aaaa48bc 100644
--- a/cpp/src/vereign/restapi/detail/post_task.hh
+++ b/cpp/src/vereign/restapi/detail/post_task.hh
@@ -1,16 +1,16 @@
#ifndef __VEREIGN_RESTAPI_DETAIL_POST_TASK_HH
#define __VEREIGN_RESTAPI_DETAIL_POST_TASK_HH
-#include "boost/type_traits/function_traits.hpp"
#include <vereign/restapi/http_header.hh>
#include <vereign/restapi/post_result.hh>
+#include <vereign/client_library/common_types.pb.h>
+#include <vereign/grpc/json/encoder.hh>
#include <google/protobuf/message.h>
#include <boost/optional.hpp>
#include <boost/beast/http.hpp>
#include <google/protobuf/util/json_util.h>
#include <fmt/core.h>
-#include <vereign/client_library/common_types.pb.h>
namespace vereign {
namespace restapi {
@@ -28,10 +28,10 @@ using PostError = boost::optional<std::string>;
class PostTaskBase {
public:
virtual void Complete(const PostError& err) = 0;
- virtual const std::string& Path() const = 0;
- virtual PostError EncodeRequest(HttpRequest& req) = 0;
+ virtual auto Path() const -> const std::string& = 0;
+ virtual auto EncodeRequest(HttpRequest& req) -> PostError = 0;
virtual void DecodeResponse(const HttpResponse& resp) = 0;
- virtual ~PostTaskBase() {}
+ virtual ~PostTaskBase() = default;
};
using PostTaskBasePtr = std::unique_ptr<PostTaskBase>;
@@ -40,36 +40,36 @@ template <class RequestPtr, class ResponsePtr, class CompletionFunc>
class PostTask: public PostTaskBase {
public:
PostTask(
- const std::string& path,
+ std::string path,
RequestPtr&& req,
ResponsePtr&& resp,
CompletionFunc&& completion_func
)
- : path_{path},
+ : path_{std::move(path)},
req_{std::move(req)},
resp_{std::move(resp)},
func_{std::move(completion_func)}
{}
PostTask(
- const std::string& path,
+ std::string path,
RequestPtr&& req,
ResponsePtr&& resp,
std::vector<HttpHeader>&& headers,
CompletionFunc&& completion_func
)
- : path_{path},
+ : path_{std::move(path)},
req_{std::move(req)},
resp_{std::move(resp)},
headers_{std::move(headers)},
func_{std::move(completion_func)}
{}
- ~PostTask() = default;
+ ~PostTask() override = default;
PostTask(PostTask&&) = default;
PostTask(const PostTask&) = delete;
- PostTask& operator=(const PostTask&) = delete;
+ auto operator=(const PostTask&) -> PostTask& = delete;
void DecodeResponse(const HttpResponse& httpResp) override {
if (httpResp.result() != beast::http::status::ok) {
@@ -94,25 +94,17 @@ public:
}
}
- PostError EncodeRequest(HttpRequest& req) override {
+ auto EncodeRequest(HttpRequest& req) -> PostError override {
for (auto& header : headers_) {
req.insert(header.Key, header.Value);
}
- google::protobuf::util::JsonPrintOptions options;
- options.preserve_proto_field_names = true;
- options.always_print_primitive_fields = false;
- options.always_print_enums_as_ints = true;
- auto status = google::protobuf::util::MessageToJsonString(*req_, &req.body(), options);
-
- if (!status.ok()) {
- return fmt::format(
- "request json encode failed: {}",
- std::string(status.error_message())
- );
+ try {
+ grpc::json::Encode(*req_, req.body(), grpc::json::EncodeOptions{}.WithOmitEmpty());
+ return boost::none;
+ } catch (const std::exception& err) {
+ return fmt::format("request json encode failed: {}", err.what());
}
-
- return boost::none;
}
void Complete(const PostError& err) override {
@@ -126,7 +118,7 @@ public:
});
}
- const std::string& Path() const override {
+ auto Path() const -> const std::string& override {
return path_;
}
diff --git a/cpp/tests/CMakeLists.txt b/cpp/tests/CMakeLists.txt
index f6aaf77a116e3dde272f68d65ca95d2951fc1ef3..522c6333935b69525d9e1a2d21b105a610882d5e 100644
--- a/cpp/tests/CMakeLists.txt
+++ b/cpp/tests/CMakeLists.txt
@@ -1,6 +1,6 @@
include_directories(
- "./"
+ ${CMAKE_CURRENT_SOURCE_DIR}
"${VENDOR_INSTALL_DIR}/boost/include"
)
diff --git a/cpp/tests/catch.hpp b/cpp/tests/catch2/catch.hpp
similarity index 99%
rename from cpp/tests/catch.hpp
rename to cpp/tests/catch2/catch.hpp
index 6beb0eadb3a402a3c18ecec1d3c2793b066a3c07..fc1f54d6dc7e9ee509defe9da2c41cdb1bf289e0 100644
--- a/cpp/tests/catch.hpp
+++ b/cpp/tests/catch2/catch.hpp
@@ -9910,10 +9910,15 @@ namespace Catch {
}
std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
+ // Strip ../ from tests file paths
+ const char * fileInfo = info.file;
+ if (strlen(info.file) > 2 && info.file[0] == '.' && info.file[1] == '.') {
+ fileInfo = fileInfo+3;
+ }
#ifndef __GNUG__
- os << info.file << '(' << info.line << ')';
+ os << fileInfo << '(' << info.line << ')';
#else
- os << info.file << ':' << info.line;
+ os << fileInfo << ':' << info.line;
#endif
return os;
}
diff --git a/cpp/tests/init_tests.cc b/cpp/tests/init_tests.cc
index 80cc48cc58ac2be5443a27d80108703374d4e05c..5a65d6b6b5f54924a8202147817972e0c3af3d99 100644
--- a/cpp/tests/init_tests.cc
+++ b/cpp/tests/init_tests.cc
@@ -1,2 +1,2 @@
#define CATCH_CONFIG_MAIN
-#include "catch.hpp"
\ No newline at end of file
+#include <catch2/catch.hpp>
diff --git a/cpp/tests/protobuf/json_test.cc b/cpp/tests/protobuf/json_test.cc
index 6e9d4ef19633e9372aba9ebbf99527162979f7ef..45758d5727b0f22b89d375be7587dbf530ce2686 100644
--- a/cpp/tests/protobuf/json_test.cc
+++ b/cpp/tests/protobuf/json_test.cc
@@ -1,4 +1,4 @@
-#include "catch.hpp"
+#include <catch2/catch.hpp>
#include <google/protobuf/util/json_util.h>
#include <testpb/messages.pb.h>
@@ -10,8 +10,8 @@ TEST_CASE("simple struct", "[protobuf]") {
"int_arr": [4, 2],
"string_arr": ["foo", "bar", "baz"],
"int_map": {
- "foo": 4,
- "bar": 2,
+ "42": 4,
+ "72": 2,
},
"string_map": {
"foo": "foo_value",
@@ -44,8 +44,8 @@ TEST_CASE("simple struct", "[protobuf]") {
);
CHECK(msg.int_map_size() == 2);
- CHECK(msg.int_map().at("foo") == 4);
- CHECK(msg.int_map().at("bar") == 2);
+ CHECK(msg.int_map().at(42) == 4);
+ CHECK(msg.int_map().at(72) == 2);
CHECK(msg.string_map_size() == 2);
CHECK(msg.string_map().at("foo") == "foo_value");
@@ -53,6 +53,24 @@ TEST_CASE("simple struct", "[protobuf]") {
CHECK(msg.double_value() == 42);
}
+TEST_CASE("unmarshal bytes", "[protobuf]") {
+ auto json = R"(
+{
+ "bytes_value": "AEJmb29iYXI=",
+}
+)";
+
+ testproto::BytesType msg;
+
+ google::protobuf::util::JsonParseOptions options;
+ auto status = google::protobuf::util::JsonStringToMessage(json, &msg, options);
+
+ CHECK(status.error_message() == "");
+ REQUIRE(status.ok());
+ using namespace std::string_literals;
+ CHECK(msg.bytes_value() == "\x00\x42"s "foobar");
+}
+
TEST_CASE("two dimensional array", "[protobuf]") {
auto json = R"(
{
@@ -303,3 +321,18 @@ TEST_CASE("oneof marshal", "[protobuf]") {
}
}
+
+TEST_CASE("empty messages with OmitEmpty", "[protobuf]") {
+ testproto::MessageType msg;
+ msg.add_foo_arr();
+
+ google::protobuf::util::JsonPrintOptions options;
+ options.preserve_proto_field_names = true;
+ options.always_print_primitive_fields = true;
+ std::string json;
+ auto status = google::protobuf::util::MessageToJsonString(msg, &json, options);
+
+ auto expected = R"({"foo_arr":[{}]})";
+
+ CHECK(json == expected);
+}
diff --git a/cpp/tests/protobuf/proto/messages.proto b/cpp/tests/protobuf/proto/messages.proto
index 1e1e0e367fea46f605768c2d4b553a4098e36e8d..1b036cbfc30330bcb4e972ea4fea56d8c5b2b3af 100644
--- a/cpp/tests/protobuf/proto/messages.proto
+++ b/cpp/tests/protobuf/proto/messages.proto
@@ -7,12 +7,26 @@ message SimpleStruct {
string string_value = 2;
repeated int64 int_arr = 3;
repeated string string_arr = 4;
- map<string, int32> int_map = 5;
+ map<int32, int32> int_map = 5;
map<string, string> string_map = 6;
double double_value = 7;
uint64 uint64_value = 8;
}
+message Bar {
+ string value = 2;
+}
+
+message Foo {
+ string value = 1;
+ Bar bar = 2;
+}
+
+message MessageType {
+ Foo foo = 1;
+ repeated Foo foo_arr = 2;
+}
+
message JsonNaming {
float foo_value = 1;
float barValue = 2;
@@ -34,3 +48,7 @@ message StringArray {
message TwoDimensionalArray {
repeated StringArray arr = 1;
}
+
+message BytesType {
+ bytes bytes_value = 1;
+}
diff --git a/cpp/tests/protobuf/testpb/messages.pb.cc b/cpp/tests/protobuf/testpb/messages.pb.cc
index 0721f36d416de5573a5166ffee9093684ceff0fc..6d9de6ebdab26d1ce4eb4c989fca1f698e3f6df5 100644
--- a/cpp/tests/protobuf/testpb/messages.pb.cc
+++ b/cpp/tests/protobuf/testpb/messages.pb.cc
@@ -14,6 +14,8 @@
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
+extern PROTOBUF_INTERNAL_EXPORT_messages_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Bar_messages_2eproto;
+extern PROTOBUF_INTERNAL_EXPORT_messages_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_Foo_messages_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_messages_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_SimpleStruct_messages_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_messages_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_SimpleStruct_IntMapEntry_DoNotUse_messages_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_messages_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_SimpleStruct_StringMapEntry_DoNotUse_messages_2eproto;
@@ -31,6 +33,18 @@ class SimpleStructDefaultTypeInternal {
public:
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<SimpleStruct> _instance;
} _SimpleStruct_default_instance_;
+class BarDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Bar> _instance;
+} _Bar_default_instance_;
+class FooDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Foo> _instance;
+} _Foo_default_instance_;
+class MessageTypeDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<MessageType> _instance;
+} _MessageType_default_instance_;
class JsonNamingDefaultTypeInternal {
public:
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<JsonNaming> _instance;
@@ -49,7 +63,54 @@ class TwoDimensionalArrayDefaultTypeInternal {
public:
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TwoDimensionalArray> _instance;
} _TwoDimensionalArray_default_instance_;
+class BytesTypeDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<BytesType> _instance;
+} _BytesType_default_instance_;
} // namespace testproto
+static void InitDefaultsscc_info_Bar_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::testproto::_Bar_default_instance_;
+ new (ptr) ::testproto::Bar();
+ ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+ }
+ ::testproto::Bar::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Bar_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_Bar_messages_2eproto}, {}};
+
+static void InitDefaultsscc_info_BytesType_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::testproto::_BytesType_default_instance_;
+ new (ptr) ::testproto::BytesType();
+ ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+ }
+ ::testproto::BytesType::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_BytesType_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_BytesType_messages_2eproto}, {}};
+
+static void InitDefaultsscc_info_Foo_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::testproto::_Foo_default_instance_;
+ new (ptr) ::testproto::Foo();
+ ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+ }
+ ::testproto::Foo::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_Foo_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_Foo_messages_2eproto}, {
+ &scc_info_Bar_messages_2eproto.base,}};
+
static void InitDefaultsscc_info_JsonNaming_messages_2eproto() {
GOOGLE_PROTOBUF_VERIFY_VERSION;
@@ -64,6 +125,21 @@ static void InitDefaultsscc_info_JsonNaming_messages_2eproto() {
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_JsonNaming_messages_2eproto =
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_JsonNaming_messages_2eproto}, {}};
+static void InitDefaultsscc_info_MessageType_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::testproto::_MessageType_default_instance_;
+ new (ptr) ::testproto::MessageType();
+ ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+ }
+ ::testproto::MessageType::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_MessageType_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_MessageType_messages_2eproto}, {
+ &scc_info_Foo_messages_2eproto.base,}};
+
static void InitDefaultsscc_info_OneofValue_messages_2eproto() {
GOOGLE_PROTOBUF_VERIFY_VERSION;
@@ -150,7 +226,7 @@ static void InitDefaultsscc_info_TwoDimensionalArray_messages_2eproto() {
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_TwoDimensionalArray_messages_2eproto}, {
&scc_info_StringArray_messages_2eproto.base,}};
-static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_messages_2eproto[7];
+static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_messages_2eproto[11];
static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_messages_2eproto = nullptr;
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_messages_2eproto = nullptr;
@@ -187,6 +263,26 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_messages_2eproto::offsets[] PR
PROTOBUF_FIELD_OFFSET(::testproto::SimpleStruct, double_value_),
PROTOBUF_FIELD_OFFSET(::testproto::SimpleStruct, uint64_value_),
~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::testproto::Bar, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::testproto::Bar, value_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::testproto::Foo, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::testproto::Foo, value_),
+ PROTOBUF_FIELD_OFFSET(::testproto::Foo, bar_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::testproto::MessageType, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::testproto::MessageType, foo_),
+ PROTOBUF_FIELD_OFFSET(::testproto::MessageType, foo_arr_),
+ ~0u, // no _has_bits_
PROTOBUF_FIELD_OFFSET(::testproto::JsonNaming, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
@@ -215,25 +311,39 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_messages_2eproto::offsets[] PR
~0u, // no _oneof_case_
~0u, // no _weak_field_map_
PROTOBUF_FIELD_OFFSET(::testproto::TwoDimensionalArray, arr_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::testproto::BytesType, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::testproto::BytesType, bytes_value_),
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
{ 0, 7, sizeof(::testproto::SimpleStruct_IntMapEntry_DoNotUse)},
{ 9, 16, sizeof(::testproto::SimpleStruct_StringMapEntry_DoNotUse)},
{ 18, -1, sizeof(::testproto::SimpleStruct)},
- { 31, -1, sizeof(::testproto::JsonNaming)},
- { 40, -1, sizeof(::testproto::OneofValue)},
- { 48, -1, sizeof(::testproto::StringArray)},
- { 54, -1, sizeof(::testproto::TwoDimensionalArray)},
+ { 31, -1, sizeof(::testproto::Bar)},
+ { 37, -1, sizeof(::testproto::Foo)},
+ { 44, -1, sizeof(::testproto::MessageType)},
+ { 51, -1, sizeof(::testproto::JsonNaming)},
+ { 60, -1, sizeof(::testproto::OneofValue)},
+ { 68, -1, sizeof(::testproto::StringArray)},
+ { 74, -1, sizeof(::testproto::TwoDimensionalArray)},
+ { 80, -1, sizeof(::testproto::BytesType)},
};
static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::testproto::_SimpleStruct_IntMapEntry_DoNotUse_default_instance_),
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::testproto::_SimpleStruct_StringMapEntry_DoNotUse_default_instance_),
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::testproto::_SimpleStruct_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::testproto::_Bar_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::testproto::_Foo_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::testproto::_MessageType_default_instance_),
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::testproto::_JsonNaming_default_instance_),
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::testproto::_OneofValue_default_instance_),
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::testproto::_StringArray_default_instance_),
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::testproto::_TwoDimensionalArray_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::testproto::_BytesType_default_instance_),
};
const char descriptor_table_protodef_messages_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
@@ -244,21 +354,30 @@ const char descriptor_table_protodef_messages_2eproto[] PROTOBUF_SECTION_VARIABL
"ruct.IntMapEntry\022:\n\nstring_map\030\006 \003(\0132&.t"
"estproto.SimpleStruct.StringMapEntry\022\024\n\014"
"double_value\030\007 \001(\001\022\024\n\014uint64_value\030\010 \001(\004"
- "\032-\n\013IntMapEntry\022\013\n\003key\030\001 \001(\t\022\r\n\005value\030\002 "
+ "\032-\n\013IntMapEntry\022\013\n\003key\030\001 \001(\005\022\r\n\005value\030\002 "
"\001(\005:\0028\001\0320\n\016StringMapEntry\022\013\n\003key\030\001 \001(\t\022\r"
- "\n\005value\030\002 \001(\t:\0028\001\"V\n\nJsonNaming\022\021\n\tfoo_v"
- "alue\030\001 \001(\002\022\020\n\010barValue\030\002 \001(\002\022\020\n\010BazValue"
- "\030\003 \001(\002\022\021\n\tquX_Value\030\004 \001(\002\"]\n\nOneofValue\022"
- "\026\n\014string_value\030\001 \001(\tH\000\022/\n\014struct_value\030"
- "\002 \001(\0132\027.testproto.SimpleStructH\000B\006\n\004data"
- "\"\036\n\013StringArray\022\017\n\007str_arr\030\001 \003(\t\":\n\023TwoD"
- "imensionalArray\022#\n\003arr\030\001 \003(\0132\026.testproto"
- ".StringArrayb\006proto3"
+ "\n\005value\030\002 \001(\t:\0028\001\"\024\n\003Bar\022\r\n\005value\030\002 \001(\t\""
+ "1\n\003Foo\022\r\n\005value\030\001 \001(\t\022\033\n\003bar\030\002 \001(\0132\016.tes"
+ "tproto.Bar\"K\n\013MessageType\022\033\n\003foo\030\001 \001(\0132\016"
+ ".testproto.Foo\022\037\n\007foo_arr\030\002 \003(\0132\016.testpr"
+ "oto.Foo\"V\n\nJsonNaming\022\021\n\tfoo_value\030\001 \001(\002"
+ "\022\020\n\010barValue\030\002 \001(\002\022\020\n\010BazValue\030\003 \001(\002\022\021\n\t"
+ "quX_Value\030\004 \001(\002\"]\n\nOneofValue\022\026\n\014string_"
+ "value\030\001 \001(\tH\000\022/\n\014struct_value\030\002 \001(\0132\027.te"
+ "stproto.SimpleStructH\000B\006\n\004data\"\036\n\013String"
+ "Array\022\017\n\007str_arr\030\001 \003(\t\":\n\023TwoDimensional"
+ "Array\022#\n\003arr\030\001 \003(\0132\026.testproto.StringArr"
+ "ay\" \n\tBytesType\022\023\n\013bytes_value\030\001 \001(\014b\006pr"
+ "oto3"
;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_messages_2eproto_deps[1] = {
};
-static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_messages_2eproto_sccs[7] = {
+static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_messages_2eproto_sccs[11] = {
+ &scc_info_Bar_messages_2eproto.base,
+ &scc_info_BytesType_messages_2eproto.base,
+ &scc_info_Foo_messages_2eproto.base,
&scc_info_JsonNaming_messages_2eproto.base,
+ &scc_info_MessageType_messages_2eproto.base,
&scc_info_OneofValue_messages_2eproto.base,
&scc_info_SimpleStruct_messages_2eproto.base,
&scc_info_SimpleStruct_IntMapEntry_DoNotUse_messages_2eproto.base,
@@ -269,10 +388,10 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_mes
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_messages_2eproto_once;
static bool descriptor_table_messages_2eproto_initialized = false;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_messages_2eproto = {
- &descriptor_table_messages_2eproto_initialized, descriptor_table_protodef_messages_2eproto, "messages.proto", 660,
- &descriptor_table_messages_2eproto_once, descriptor_table_messages_2eproto_sccs, descriptor_table_messages_2eproto_deps, 7, 0,
+ &descriptor_table_messages_2eproto_initialized, descriptor_table_protodef_messages_2eproto, "messages.proto", 844,
+ &descriptor_table_messages_2eproto_once, descriptor_table_messages_2eproto_sccs, descriptor_table_messages_2eproto_deps, 11, 0,
schemas, file_default_instances, TableStruct_messages_2eproto::offsets,
- file_level_metadata_messages_2eproto, 7, file_level_enum_descriptors_messages_2eproto, file_level_service_descriptors_messages_2eproto,
+ file_level_metadata_messages_2eproto, 11, file_level_enum_descriptors_messages_2eproto, file_level_service_descriptors_messages_2eproto,
};
// Force running AddDescriptors() at dynamic initialization time.
@@ -434,7 +553,7 @@ const char* SimpleStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I
} while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
} else goto handle_unusual;
continue;
- // map<string, int32> int_map = 5;
+ // map<int32, int32> int_map = 5;
case 5:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
ptr -= 1;
@@ -533,43 +652,33 @@ failure:
target = stream->WriteString(4, s, target);
}
- // map<string, int32> int_map = 5;
+ // map<int32, int32> int_map = 5;
if (!this->_internal_int_map().empty()) {
- typedef ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::int32 >::const_pointer
+ typedef ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::int32 >::const_pointer
ConstPtr;
- typedef ConstPtr SortItem;
- typedef ::PROTOBUF_NAMESPACE_ID::internal::CompareByDerefFirst<SortItem> Less;
- struct Utf8Check {
- static void Check(ConstPtr p) {
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
- p->first.data(), static_cast<int>(p->first.length()),
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
- "testproto.SimpleStruct.IntMapEntry.key");
- }
- };
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::SortItem< ::PROTOBUF_NAMESPACE_ID::int32, ConstPtr > SortItem;
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::CompareByFirstField<SortItem> Less;
if (stream->IsSerializationDeterministic() &&
this->_internal_int_map().size() > 1) {
::std::unique_ptr<SortItem[]> items(
new SortItem[this->_internal_int_map().size()]);
- typedef ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::int32 >::size_type size_type;
+ typedef ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::int32 >::size_type size_type;
size_type n = 0;
- for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::int32 >::const_iterator
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::int32 >::const_iterator
it = this->_internal_int_map().begin();
it != this->_internal_int_map().end(); ++it, ++n) {
items[static_cast<ptrdiff_t>(n)] = SortItem(&*it);
}
::std::sort(&items[0], &items[static_cast<ptrdiff_t>(n)], Less());
for (size_type i = 0; i < n; i++) {
- target = SimpleStruct_IntMapEntry_DoNotUse::Funcs::InternalSerialize(5, items[static_cast<ptrdiff_t>(i)]->first, items[static_cast<ptrdiff_t>(i)]->second, target, stream);
- Utf8Check::Check(&(*items[static_cast<ptrdiff_t>(i)]));
+ target = SimpleStruct_IntMapEntry_DoNotUse::Funcs::InternalSerialize(5, items[static_cast<ptrdiff_t>(i)].second->first, items[static_cast<ptrdiff_t>(i)].second->second, target, stream);
}
} else {
- for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::int32 >::const_iterator
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::int32 >::const_iterator
it = this->_internal_int_map().begin();
it != this->_internal_int_map().end(); ++it) {
target = SimpleStruct_IntMapEntry_DoNotUse::Funcs::InternalSerialize(5, it->first, it->second, target, stream);
- Utf8Check::Check(&(*it));
}
}
}
@@ -622,96 +731,793 @@ failure:
// double double_value = 7;
if (!(this->double_value() <= 0 && this->double_value() >= 0)) {
target = stream->EnsureSpace(target);
- target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(7, this->_internal_double_value(), target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(7, this->_internal_double_value(), target);
+ }
+
+ // uint64 uint64_value = 8;
+ if (this->uint64_value() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(8, this->_internal_uint64_value(), target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields(), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:testproto.SimpleStruct)
+ return target;
+}
+
+size_t SimpleStruct::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:testproto.SimpleStruct)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // repeated int64 int_arr = 3;
+ {
+ size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ Int64Size(this->int_arr_);
+ if (data_size > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+ static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
+ _int_arr_cached_byte_size_.store(cached_size,
+ std::memory_order_relaxed);
+ total_size += data_size;
+ }
+
+ // repeated string string_arr = 4;
+ total_size += 1 *
+ ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(string_arr_.size());
+ for (int i = 0, n = string_arr_.size(); i < n; i++) {
+ total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ string_arr_.Get(i));
+ }
+
+ // map<int32, int32> int_map = 5;
+ total_size += 1 *
+ ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_int_map_size());
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::int32 >::const_iterator
+ it = this->_internal_int_map().begin();
+ it != this->_internal_int_map().end(); ++it) {
+ total_size += SimpleStruct_IntMapEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
+ }
+
+ // map<string, string> string_map = 6;
+ total_size += 1 *
+ ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_string_map_size());
+ for (::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::const_iterator
+ it = this->_internal_string_map().begin();
+ it != this->_internal_string_map().end(); ++it) {
+ total_size += SimpleStruct_StringMapEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
+ }
+
+ // string string_value = 2;
+ if (this->string_value().size() > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ this->_internal_string_value());
+ }
+
+ // int64 int_value = 1;
+ if (this->int_value() != 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
+ this->_internal_int_value());
+ }
+
+ // double double_value = 7;
+ if (!(this->double_value() <= 0 && this->double_value() >= 0)) {
+ total_size += 1 + 8;
+ }
+
+ // uint64 uint64_value = 8;
+ if (this->uint64_value() != 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
+ this->_internal_uint64_value());
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+ _internal_metadata_, total_size, &_cached_size_);
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void SimpleStruct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:testproto.SimpleStruct)
+ GOOGLE_DCHECK_NE(&from, this);
+ const SimpleStruct* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<SimpleStruct>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:testproto.SimpleStruct)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:testproto.SimpleStruct)
+ MergeFrom(*source);
+ }
+}
+
+void SimpleStruct::MergeFrom(const SimpleStruct& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:testproto.SimpleStruct)
+ GOOGLE_DCHECK_NE(&from, this);
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ int_arr_.MergeFrom(from.int_arr_);
+ string_arr_.MergeFrom(from.string_arr_);
+ int_map_.MergeFrom(from.int_map_);
+ string_map_.MergeFrom(from.string_map_);
+ if (from.string_value().size() > 0) {
+
+ string_value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.string_value_);
+ }
+ if (from.int_value() != 0) {
+ _internal_set_int_value(from._internal_int_value());
+ }
+ if (!(from.double_value() <= 0 && from.double_value() >= 0)) {
+ _internal_set_double_value(from._internal_double_value());
+ }
+ if (from.uint64_value() != 0) {
+ _internal_set_uint64_value(from._internal_uint64_value());
+ }
+}
+
+void SimpleStruct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:testproto.SimpleStruct)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void SimpleStruct::CopyFrom(const SimpleStruct& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:testproto.SimpleStruct)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool SimpleStruct::IsInitialized() const {
+ return true;
+}
+
+void SimpleStruct::InternalSwap(SimpleStruct* other) {
+ using std::swap;
+ _internal_metadata_.Swap(&other->_internal_metadata_);
+ int_arr_.InternalSwap(&other->int_arr_);
+ string_arr_.InternalSwap(&other->string_arr_);
+ int_map_.Swap(&other->int_map_);
+ string_map_.Swap(&other->string_map_);
+ string_value_.Swap(&other->string_value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ GetArenaNoVirtual());
+ swap(int_value_, other->int_value_);
+ swap(double_value_, other->double_value_);
+ swap(uint64_value_, other->uint64_value_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SimpleStruct::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void Bar::InitAsDefaultInstance() {
+}
+class Bar::_Internal {
+ public:
+};
+
+Bar::Bar()
+ : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+ SharedCtor();
+ // @@protoc_insertion_point(constructor:testproto.Bar)
+}
+Bar::Bar(const Bar& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message(),
+ _internal_metadata_(nullptr) {
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_value().empty()) {
+ value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.value_);
+ }
+ // @@protoc_insertion_point(copy_constructor:testproto.Bar)
+}
+
+void Bar::SharedCtor() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Bar_messages_2eproto.base);
+ value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+Bar::~Bar() {
+ // @@protoc_insertion_point(destructor:testproto.Bar)
+ SharedDtor();
+}
+
+void Bar::SharedDtor() {
+ value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void Bar::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+const Bar& Bar::default_instance() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Bar_messages_2eproto.base);
+ return *internal_default_instance();
+}
+
+
+void Bar::Clear() {
+// @@protoc_insertion_point(message_clear_start:testproto.Bar)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ _internal_metadata_.Clear();
+}
+
+const char* Bar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ CHK_(ptr);
+ switch (tag >> 3) {
+ // string value = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ auto str = _internal_mutable_value();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "testproto.Bar.value"));
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag & 7) == 4 || tag == 0) {
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* Bar::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:testproto.Bar)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // string value = 2;
+ if (this->value().size() > 0) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ this->_internal_value().data(), static_cast<int>(this->_internal_value().length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "testproto.Bar.value");
+ target = stream->WriteStringMaybeAliased(
+ 2, this->_internal_value(), target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields(), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:testproto.Bar)
+ return target;
+}
+
+size_t Bar::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:testproto.Bar)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // string value = 2;
+ if (this->value().size() > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ this->_internal_value());
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+ _internal_metadata_, total_size, &_cached_size_);
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void Bar::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:testproto.Bar)
+ GOOGLE_DCHECK_NE(&from, this);
+ const Bar* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Bar>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:testproto.Bar)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:testproto.Bar)
+ MergeFrom(*source);
+ }
+}
+
+void Bar::MergeFrom(const Bar& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:testproto.Bar)
+ GOOGLE_DCHECK_NE(&from, this);
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from.value().size() > 0) {
+
+ value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.value_);
+ }
+}
+
+void Bar::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:testproto.Bar)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void Bar::CopyFrom(const Bar& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:testproto.Bar)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool Bar::IsInitialized() const {
+ return true;
+}
+
+void Bar::InternalSwap(Bar* other) {
+ using std::swap;
+ _internal_metadata_.Swap(&other->_internal_metadata_);
+ value_.Swap(&other->value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ GetArenaNoVirtual());
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Bar::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void Foo::InitAsDefaultInstance() {
+ ::testproto::_Foo_default_instance_._instance.get_mutable()->bar_ = const_cast< ::testproto::Bar*>(
+ ::testproto::Bar::internal_default_instance());
+}
+class Foo::_Internal {
+ public:
+ static const ::testproto::Bar& bar(const Foo* msg);
+};
+
+const ::testproto::Bar&
+Foo::_Internal::bar(const Foo* msg) {
+ return *msg->bar_;
+}
+Foo::Foo()
+ : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+ SharedCtor();
+ // @@protoc_insertion_point(constructor:testproto.Foo)
+}
+Foo::Foo(const Foo& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message(),
+ _internal_metadata_(nullptr) {
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_value().empty()) {
+ value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.value_);
+ }
+ if (from._internal_has_bar()) {
+ bar_ = new ::testproto::Bar(*from.bar_);
+ } else {
+ bar_ = nullptr;
+ }
+ // @@protoc_insertion_point(copy_constructor:testproto.Foo)
+}
+
+void Foo::SharedCtor() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Foo_messages_2eproto.base);
+ value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ bar_ = nullptr;
+}
+
+Foo::~Foo() {
+ // @@protoc_insertion_point(destructor:testproto.Foo)
+ SharedDtor();
+}
+
+void Foo::SharedDtor() {
+ value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (this != internal_default_instance()) delete bar_;
+}
+
+void Foo::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+const Foo& Foo::default_instance() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Foo_messages_2eproto.base);
+ return *internal_default_instance();
+}
+
+
+void Foo::Clear() {
+// @@protoc_insertion_point(message_clear_start:testproto.Foo)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (GetArenaNoVirtual() == nullptr && bar_ != nullptr) {
+ delete bar_;
+ }
+ bar_ = nullptr;
+ _internal_metadata_.Clear();
+}
+
+const char* Foo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ CHK_(ptr);
+ switch (tag >> 3) {
+ // string value = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ auto str = _internal_mutable_value();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "testproto.Foo.value"));
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // .testproto.Bar bar = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ ptr = ctx->ParseMessage(_internal_mutable_bar(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag & 7) == 4 || tag == 0) {
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* Foo::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:testproto.Foo)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // string value = 1;
+ if (this->value().size() > 0) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ this->_internal_value().data(), static_cast<int>(this->_internal_value().length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "testproto.Foo.value");
+ target = stream->WriteStringMaybeAliased(
+ 1, this->_internal_value(), target);
+ }
+
+ // .testproto.Bar bar = 2;
+ if (this->has_bar()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 2, _Internal::bar(this), target, stream);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields(), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:testproto.Foo)
+ return target;
+}
+
+size_t Foo::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:testproto.Foo)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // string value = 1;
+ if (this->value().size() > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ this->_internal_value());
+ }
+
+ // .testproto.Bar bar = 2;
+ if (this->has_bar()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *bar_);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+ _internal_metadata_, total_size, &_cached_size_);
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void Foo::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:testproto.Foo)
+ GOOGLE_DCHECK_NE(&from, this);
+ const Foo* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Foo>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:testproto.Foo)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:testproto.Foo)
+ MergeFrom(*source);
+ }
+}
+
+void Foo::MergeFrom(const Foo& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:testproto.Foo)
+ GOOGLE_DCHECK_NE(&from, this);
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from.value().size() > 0) {
+
+ value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.value_);
+ }
+ if (from.has_bar()) {
+ _internal_mutable_bar()->::testproto::Bar::MergeFrom(from._internal_bar());
+ }
+}
+
+void Foo::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:testproto.Foo)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void Foo::CopyFrom(const Foo& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:testproto.Foo)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool Foo::IsInitialized() const {
+ return true;
+}
+
+void Foo::InternalSwap(Foo* other) {
+ using std::swap;
+ _internal_metadata_.Swap(&other->_internal_metadata_);
+ value_.Swap(&other->value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ GetArenaNoVirtual());
+ swap(bar_, other->bar_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Foo::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void MessageType::InitAsDefaultInstance() {
+ ::testproto::_MessageType_default_instance_._instance.get_mutable()->foo_ = const_cast< ::testproto::Foo*>(
+ ::testproto::Foo::internal_default_instance());
+}
+class MessageType::_Internal {
+ public:
+ static const ::testproto::Foo& foo(const MessageType* msg);
+};
+
+const ::testproto::Foo&
+MessageType::_Internal::foo(const MessageType* msg) {
+ return *msg->foo_;
+}
+MessageType::MessageType()
+ : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+ SharedCtor();
+ // @@protoc_insertion_point(constructor:testproto.MessageType)
+}
+MessageType::MessageType(const MessageType& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message(),
+ _internal_metadata_(nullptr),
+ foo_arr_(from.foo_arr_) {
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ if (from._internal_has_foo()) {
+ foo_ = new ::testproto::Foo(*from.foo_);
+ } else {
+ foo_ = nullptr;
+ }
+ // @@protoc_insertion_point(copy_constructor:testproto.MessageType)
+}
+
+void MessageType::SharedCtor() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_MessageType_messages_2eproto.base);
+ foo_ = nullptr;
+}
+
+MessageType::~MessageType() {
+ // @@protoc_insertion_point(destructor:testproto.MessageType)
+ SharedDtor();
+}
+
+void MessageType::SharedDtor() {
+ if (this != internal_default_instance()) delete foo_;
+}
+
+void MessageType::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+const MessageType& MessageType::default_instance() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_MessageType_messages_2eproto.base);
+ return *internal_default_instance();
+}
+
+
+void MessageType::Clear() {
+// @@protoc_insertion_point(message_clear_start:testproto.MessageType)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ foo_arr_.Clear();
+ if (GetArenaNoVirtual() == nullptr && foo_ != nullptr) {
+ delete foo_;
+ }
+ foo_ = nullptr;
+ _internal_metadata_.Clear();
+}
+
+const char* MessageType::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ CHK_(ptr);
+ switch (tag >> 3) {
+ // .testproto.Foo foo = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ ptr = ctx->ParseMessage(_internal_mutable_foo(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // repeated .testproto.Foo foo_arr = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ ptr = ctx->ParseMessage(_internal_add_foo_arr(), ptr);
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag & 7) == 4 || tag == 0) {
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* MessageType::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:testproto.MessageType)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // .testproto.Foo foo = 1;
+ if (this->has_foo()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::foo(this), target, stream);
}
- // uint64 uint64_value = 8;
- if (this->uint64_value() != 0) {
+ // repeated .testproto.Foo foo_arr = 2;
+ for (unsigned int i = 0,
+ n = static_cast<unsigned int>(this->_internal_foo_arr_size()); i < n; i++) {
target = stream->EnsureSpace(target);
- target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(8, this->_internal_uint64_value(), target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(2, this->_internal_foo_arr(i), target, stream);
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
_internal_metadata_.unknown_fields(), target, stream);
}
- // @@protoc_insertion_point(serialize_to_array_end:testproto.SimpleStruct)
+ // @@protoc_insertion_point(serialize_to_array_end:testproto.MessageType)
return target;
}
-size_t SimpleStruct::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:testproto.SimpleStruct)
+size_t MessageType::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:testproto.MessageType)
size_t total_size = 0;
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
- // repeated int64 int_arr = 3;
- {
- size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
- Int64Size(this->int_arr_);
- if (data_size > 0) {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
- static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
- }
- int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
- _int_arr_cached_byte_size_.store(cached_size,
- std::memory_order_relaxed);
- total_size += data_size;
- }
-
- // repeated string string_arr = 4;
- total_size += 1 *
- ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(string_arr_.size());
- for (int i = 0, n = string_arr_.size(); i < n; i++) {
- total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
- string_arr_.Get(i));
- }
-
- // map<string, int32> int_map = 5;
- total_size += 1 *
- ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_int_map_size());
- for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::int32 >::const_iterator
- it = this->_internal_int_map().begin();
- it != this->_internal_int_map().end(); ++it) {
- total_size += SimpleStruct_IntMapEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
- }
-
- // map<string, string> string_map = 6;
- total_size += 1 *
- ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_string_map_size());
- for (::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::const_iterator
- it = this->_internal_string_map().begin();
- it != this->_internal_string_map().end(); ++it) {
- total_size += SimpleStruct_StringMapEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
- }
-
- // string string_value = 2;
- if (this->string_value().size() > 0) {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
- this->_internal_string_value());
- }
-
- // int64 int_value = 1;
- if (this->int_value() != 0) {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
- this->_internal_int_value());
- }
-
- // double double_value = 7;
- if (!(this->double_value() <= 0 && this->double_value() >= 0)) {
- total_size += 1 + 8;
+ // repeated .testproto.Foo foo_arr = 2;
+ total_size += 1UL * this->_internal_foo_arr_size();
+ for (const auto& msg : this->foo_arr_) {
+ total_size +=
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
}
- // uint64 uint64_value = 8;
- if (this->uint64_value() != 0) {
+ // .testproto.Foo foo = 1;
+ if (this->has_foo()) {
total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
- this->_internal_uint64_value());
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *foo_);
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
@@ -723,80 +1529,60 @@ size_t SimpleStruct::ByteSizeLong() const {
return total_size;
}
-void SimpleStruct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:testproto.SimpleStruct)
+void MessageType::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:testproto.MessageType)
GOOGLE_DCHECK_NE(&from, this);
- const SimpleStruct* source =
- ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<SimpleStruct>(
+ const MessageType* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<MessageType>(
&from);
if (source == nullptr) {
- // @@protoc_insertion_point(generalized_merge_from_cast_fail:testproto.SimpleStruct)
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:testproto.MessageType)
::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
} else {
- // @@protoc_insertion_point(generalized_merge_from_cast_success:testproto.SimpleStruct)
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:testproto.MessageType)
MergeFrom(*source);
}
}
-void SimpleStruct::MergeFrom(const SimpleStruct& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:testproto.SimpleStruct)
+void MessageType::MergeFrom(const MessageType& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:testproto.MessageType)
GOOGLE_DCHECK_NE(&from, this);
_internal_metadata_.MergeFrom(from._internal_metadata_);
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
(void) cached_has_bits;
- int_arr_.MergeFrom(from.int_arr_);
- string_arr_.MergeFrom(from.string_arr_);
- int_map_.MergeFrom(from.int_map_);
- string_map_.MergeFrom(from.string_map_);
- if (from.string_value().size() > 0) {
-
- string_value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.string_value_);
- }
- if (from.int_value() != 0) {
- _internal_set_int_value(from._internal_int_value());
- }
- if (!(from.double_value() <= 0 && from.double_value() >= 0)) {
- _internal_set_double_value(from._internal_double_value());
- }
- if (from.uint64_value() != 0) {
- _internal_set_uint64_value(from._internal_uint64_value());
+ foo_arr_.MergeFrom(from.foo_arr_);
+ if (from.has_foo()) {
+ _internal_mutable_foo()->::testproto::Foo::MergeFrom(from._internal_foo());
}
}
-void SimpleStruct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:testproto.SimpleStruct)
+void MessageType::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:testproto.MessageType)
if (&from == this) return;
Clear();
MergeFrom(from);
}
-void SimpleStruct::CopyFrom(const SimpleStruct& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:testproto.SimpleStruct)
+void MessageType::CopyFrom(const MessageType& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:testproto.MessageType)
if (&from == this) return;
Clear();
MergeFrom(from);
}
-bool SimpleStruct::IsInitialized() const {
+bool MessageType::IsInitialized() const {
return true;
}
-void SimpleStruct::InternalSwap(SimpleStruct* other) {
+void MessageType::InternalSwap(MessageType* other) {
using std::swap;
_internal_metadata_.Swap(&other->_internal_metadata_);
- int_arr_.InternalSwap(&other->int_arr_);
- string_arr_.InternalSwap(&other->string_arr_);
- int_map_.Swap(&other->int_map_);
- string_map_.Swap(&other->string_map_);
- string_value_.Swap(&other->string_value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
- GetArenaNoVirtual());
- swap(int_value_, other->int_value_);
- swap(double_value_, other->double_value_);
- swap(uint64_value_, other->uint64_value_);
+ foo_arr_.InternalSwap(&other->foo_arr_);
+ swap(foo_, other->foo_);
}
-::PROTOBUF_NAMESPACE_ID::Metadata SimpleStruct::GetMetadata() const {
+::PROTOBUF_NAMESPACE_ID::Metadata MessageType::GetMetadata() const {
return GetMetadataStatic();
}
@@ -1733,6 +2519,200 @@ void TwoDimensionalArray::InternalSwap(TwoDimensionalArray* other) {
}
+// ===================================================================
+
+void BytesType::InitAsDefaultInstance() {
+}
+class BytesType::_Internal {
+ public:
+};
+
+BytesType::BytesType()
+ : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+ SharedCtor();
+ // @@protoc_insertion_point(constructor:testproto.BytesType)
+}
+BytesType::BytesType(const BytesType& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message(),
+ _internal_metadata_(nullptr) {
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ bytes_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_bytes_value().empty()) {
+ bytes_value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.bytes_value_);
+ }
+ // @@protoc_insertion_point(copy_constructor:testproto.BytesType)
+}
+
+void BytesType::SharedCtor() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_BytesType_messages_2eproto.base);
+ bytes_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+BytesType::~BytesType() {
+ // @@protoc_insertion_point(destructor:testproto.BytesType)
+ SharedDtor();
+}
+
+void BytesType::SharedDtor() {
+ bytes_value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void BytesType::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+const BytesType& BytesType::default_instance() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_BytesType_messages_2eproto.base);
+ return *internal_default_instance();
+}
+
+
+void BytesType::Clear() {
+// @@protoc_insertion_point(message_clear_start:testproto.BytesType)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ bytes_value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ _internal_metadata_.Clear();
+}
+
+const char* BytesType::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ CHK_(ptr);
+ switch (tag >> 3) {
+ // bytes bytes_value = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ auto str = _internal_mutable_bytes_value();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag & 7) == 4 || tag == 0) {
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* BytesType::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:testproto.BytesType)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // bytes bytes_value = 1;
+ if (this->bytes_value().size() > 0) {
+ target = stream->WriteBytesMaybeAliased(
+ 1, this->_internal_bytes_value(), target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields(), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:testproto.BytesType)
+ return target;
+}
+
+size_t BytesType::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:testproto.BytesType)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // bytes bytes_value = 1;
+ if (this->bytes_value().size() > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_bytes_value());
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+ _internal_metadata_, total_size, &_cached_size_);
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void BytesType::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:testproto.BytesType)
+ GOOGLE_DCHECK_NE(&from, this);
+ const BytesType* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<BytesType>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:testproto.BytesType)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:testproto.BytesType)
+ MergeFrom(*source);
+ }
+}
+
+void BytesType::MergeFrom(const BytesType& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:testproto.BytesType)
+ GOOGLE_DCHECK_NE(&from, this);
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from.bytes_value().size() > 0) {
+
+ bytes_value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.bytes_value_);
+ }
+}
+
+void BytesType::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:testproto.BytesType)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void BytesType::CopyFrom(const BytesType& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:testproto.BytesType)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool BytesType::IsInitialized() const {
+ return true;
+}
+
+void BytesType::InternalSwap(BytesType* other) {
+ using std::swap;
+ _internal_metadata_.Swap(&other->_internal_metadata_);
+ bytes_value_.Swap(&other->bytes_value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ GetArenaNoVirtual());
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata BytesType::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
// @@protoc_insertion_point(namespace_scope)
} // namespace testproto
PROTOBUF_NAMESPACE_OPEN
@@ -1745,6 +2725,15 @@ template<> PROTOBUF_NOINLINE ::testproto::SimpleStruct_StringMapEntry_DoNotUse*
template<> PROTOBUF_NOINLINE ::testproto::SimpleStruct* Arena::CreateMaybeMessage< ::testproto::SimpleStruct >(Arena* arena) {
return Arena::CreateInternal< ::testproto::SimpleStruct >(arena);
}
+template<> PROTOBUF_NOINLINE ::testproto::Bar* Arena::CreateMaybeMessage< ::testproto::Bar >(Arena* arena) {
+ return Arena::CreateInternal< ::testproto::Bar >(arena);
+}
+template<> PROTOBUF_NOINLINE ::testproto::Foo* Arena::CreateMaybeMessage< ::testproto::Foo >(Arena* arena) {
+ return Arena::CreateInternal< ::testproto::Foo >(arena);
+}
+template<> PROTOBUF_NOINLINE ::testproto::MessageType* Arena::CreateMaybeMessage< ::testproto::MessageType >(Arena* arena) {
+ return Arena::CreateInternal< ::testproto::MessageType >(arena);
+}
template<> PROTOBUF_NOINLINE ::testproto::JsonNaming* Arena::CreateMaybeMessage< ::testproto::JsonNaming >(Arena* arena) {
return Arena::CreateInternal< ::testproto::JsonNaming >(arena);
}
@@ -1757,6 +2746,9 @@ template<> PROTOBUF_NOINLINE ::testproto::StringArray* Arena::CreateMaybeMessage
template<> PROTOBUF_NOINLINE ::testproto::TwoDimensionalArray* Arena::CreateMaybeMessage< ::testproto::TwoDimensionalArray >(Arena* arena) {
return Arena::CreateInternal< ::testproto::TwoDimensionalArray >(arena);
}
+template<> PROTOBUF_NOINLINE ::testproto::BytesType* Arena::CreateMaybeMessage< ::testproto::BytesType >(Arena* arena) {
+ return Arena::CreateInternal< ::testproto::BytesType >(arena);
+}
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
diff --git a/cpp/tests/protobuf/testpb/messages.pb.h b/cpp/tests/protobuf/testpb/messages.pb.h
index d1acd7c958fb6b3e2072e23c55d017094786ba87..a786e2477199350f1c8e56c1990e0dabfecd5b98 100644
--- a/cpp/tests/protobuf/testpb/messages.pb.h
+++ b/cpp/tests/protobuf/testpb/messages.pb.h
@@ -50,7 +50,7 @@ struct TableStruct_messages_2eproto {
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
- static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[7]
+ static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[11]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
@@ -58,9 +58,21 @@ struct TableStruct_messages_2eproto {
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_messages_2eproto;
namespace testproto {
+class Bar;
+class BarDefaultTypeInternal;
+extern BarDefaultTypeInternal _Bar_default_instance_;
+class BytesType;
+class BytesTypeDefaultTypeInternal;
+extern BytesTypeDefaultTypeInternal _BytesType_default_instance_;
+class Foo;
+class FooDefaultTypeInternal;
+extern FooDefaultTypeInternal _Foo_default_instance_;
class JsonNaming;
class JsonNamingDefaultTypeInternal;
extern JsonNamingDefaultTypeInternal _JsonNaming_default_instance_;
+class MessageType;
+class MessageTypeDefaultTypeInternal;
+extern MessageTypeDefaultTypeInternal _MessageType_default_instance_;
class OneofValue;
class OneofValueDefaultTypeInternal;
extern OneofValueDefaultTypeInternal _OneofValue_default_instance_;
@@ -81,7 +93,11 @@ class TwoDimensionalArrayDefaultTypeInternal;
extern TwoDimensionalArrayDefaultTypeInternal _TwoDimensionalArray_default_instance_;
} // namespace testproto
PROTOBUF_NAMESPACE_OPEN
+template<> ::testproto::Bar* Arena::CreateMaybeMessage<::testproto::Bar>(Arena*);
+template<> ::testproto::BytesType* Arena::CreateMaybeMessage<::testproto::BytesType>(Arena*);
+template<> ::testproto::Foo* Arena::CreateMaybeMessage<::testproto::Foo>(Arena*);
template<> ::testproto::JsonNaming* Arena::CreateMaybeMessage<::testproto::JsonNaming>(Arena*);
+template<> ::testproto::MessageType* Arena::CreateMaybeMessage<::testproto::MessageType>(Arena*);
template<> ::testproto::OneofValue* Arena::CreateMaybeMessage<::testproto::OneofValue>(Arena*);
template<> ::testproto::SimpleStruct* Arena::CreateMaybeMessage<::testproto::SimpleStruct>(Arena*);
template<> ::testproto::SimpleStruct_IntMapEntry_DoNotUse* Arena::CreateMaybeMessage<::testproto::SimpleStruct_IntMapEntry_DoNotUse>(Arena*);
@@ -94,23 +110,21 @@ namespace testproto {
// ===================================================================
class SimpleStruct_IntMapEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<SimpleStruct_IntMapEntry_DoNotUse,
- std::string, ::PROTOBUF_NAMESPACE_ID::int32,
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::int32,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32,
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32,
0 > {
public:
typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<SimpleStruct_IntMapEntry_DoNotUse,
- std::string, ::PROTOBUF_NAMESPACE_ID::int32,
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::int32,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32,
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32,
0 > SuperType;
SimpleStruct_IntMapEntry_DoNotUse();
SimpleStruct_IntMapEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
void MergeFrom(const SimpleStruct_IntMapEntry_DoNotUse& other);
static const SimpleStruct_IntMapEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const SimpleStruct_IntMapEntry_DoNotUse*>(&_SimpleStruct_IntMapEntry_DoNotUse_default_instance_); }
- static bool ValidateKey(std::string* s) {
- return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "testproto.SimpleStruct.IntMapEntry.key");
- }
+ static bool ValidateKey(void*) { return true; }
static bool ValidateValue(void*) { return true; }
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& other) final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
@@ -321,21 +335,21 @@ class SimpleStruct :
std::string* _internal_add_string_arr();
public:
- // map<string, int32> int_map = 5;
+ // map<int32, int32> int_map = 5;
int int_map_size() const;
private:
int _internal_int_map_size() const;
public:
void clear_int_map();
private:
- const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::int32 >&
+ const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::int32 >&
_internal_int_map() const;
- ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::int32 >*
+ ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::int32 >*
_internal_mutable_int_map();
public:
- const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::int32 >&
+ const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::int32 >&
int_map() const;
- ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::int32 >*
+ ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::int32 >*
mutable_int_map();
// map<string, string> string_map = 6;
@@ -408,8 +422,8 @@ class SimpleStruct :
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> string_arr_;
::PROTOBUF_NAMESPACE_ID::internal::MapField<
SimpleStruct_IntMapEntry_DoNotUse,
- std::string, ::PROTOBUF_NAMESPACE_ID::int32,
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::int32,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32,
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32,
0 > int_map_;
::PROTOBUF_NAMESPACE_ID::internal::MapField<
@@ -427,6 +441,447 @@ class SimpleStruct :
};
// -------------------------------------------------------------------
+class Bar :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:testproto.Bar) */ {
+ public:
+ Bar();
+ virtual ~Bar();
+
+ Bar(const Bar& from);
+ Bar(Bar&& from) noexcept
+ : Bar() {
+ *this = ::std::move(from);
+ }
+
+ inline Bar& operator=(const Bar& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline Bar& operator=(Bar&& from) noexcept {
+ if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+ if (this != &from) InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return GetMetadataStatic().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return GetMetadataStatic().reflection;
+ }
+ static const Bar& default_instance();
+
+ static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
+ static inline const Bar* internal_default_instance() {
+ return reinterpret_cast<const Bar*>(
+ &_Bar_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 3;
+
+ friend void swap(Bar& a, Bar& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(Bar* other) {
+ if (other == this) return;
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline Bar* New() const final {
+ return CreateMaybeMessage<Bar>(nullptr);
+ }
+
+ Bar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<Bar>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const Bar& from);
+ void MergeFrom(const Bar& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ inline void SharedCtor();
+ inline void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(Bar* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "testproto.Bar";
+ }
+ private:
+ inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+ return nullptr;
+ }
+ inline void* MaybeArenaPtr() const {
+ return nullptr;
+ }
+ public:
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_messages_2eproto);
+ return ::descriptor_table_messages_2eproto.file_level_metadata[kIndexInFileMessages];
+ }
+
+ public:
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kValueFieldNumber = 2,
+ };
+ // string value = 2;
+ void clear_value();
+ const std::string& value() const;
+ void set_value(const std::string& value);
+ void set_value(std::string&& value);
+ void set_value(const char* value);
+ void set_value(const char* value, size_t size);
+ std::string* mutable_value();
+ std::string* release_value();
+ void set_allocated_value(std::string* value);
+ private:
+ const std::string& _internal_value() const;
+ void _internal_set_value(const std::string& value);
+ std::string* _internal_mutable_value();
+ public:
+
+ // @@protoc_insertion_point(class_scope:testproto.Bar)
+ private:
+ class _Internal;
+
+ ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Foo :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:testproto.Foo) */ {
+ public:
+ Foo();
+ virtual ~Foo();
+
+ Foo(const Foo& from);
+ Foo(Foo&& from) noexcept
+ : Foo() {
+ *this = ::std::move(from);
+ }
+
+ inline Foo& operator=(const Foo& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline Foo& operator=(Foo&& from) noexcept {
+ if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+ if (this != &from) InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return GetMetadataStatic().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return GetMetadataStatic().reflection;
+ }
+ static const Foo& default_instance();
+
+ static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
+ static inline const Foo* internal_default_instance() {
+ return reinterpret_cast<const Foo*>(
+ &_Foo_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 4;
+
+ friend void swap(Foo& a, Foo& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(Foo* other) {
+ if (other == this) return;
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline Foo* New() const final {
+ return CreateMaybeMessage<Foo>(nullptr);
+ }
+
+ Foo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<Foo>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const Foo& from);
+ void MergeFrom(const Foo& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ inline void SharedCtor();
+ inline void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(Foo* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "testproto.Foo";
+ }
+ private:
+ inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+ return nullptr;
+ }
+ inline void* MaybeArenaPtr() const {
+ return nullptr;
+ }
+ public:
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_messages_2eproto);
+ return ::descriptor_table_messages_2eproto.file_level_metadata[kIndexInFileMessages];
+ }
+
+ public:
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kValueFieldNumber = 1,
+ kBarFieldNumber = 2,
+ };
+ // string value = 1;
+ void clear_value();
+ const std::string& value() const;
+ void set_value(const std::string& value);
+ void set_value(std::string&& value);
+ void set_value(const char* value);
+ void set_value(const char* value, size_t size);
+ std::string* mutable_value();
+ std::string* release_value();
+ void set_allocated_value(std::string* value);
+ private:
+ const std::string& _internal_value() const;
+ void _internal_set_value(const std::string& value);
+ std::string* _internal_mutable_value();
+ public:
+
+ // .testproto.Bar bar = 2;
+ bool has_bar() const;
+ private:
+ bool _internal_has_bar() const;
+ public:
+ void clear_bar();
+ const ::testproto::Bar& bar() const;
+ ::testproto::Bar* release_bar();
+ ::testproto::Bar* mutable_bar();
+ void set_allocated_bar(::testproto::Bar* bar);
+ private:
+ const ::testproto::Bar& _internal_bar() const;
+ ::testproto::Bar* _internal_mutable_bar();
+ public:
+
+ // @@protoc_insertion_point(class_scope:testproto.Foo)
+ private:
+ class _Internal;
+
+ ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
+ ::testproto::Bar* bar_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MessageType :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:testproto.MessageType) */ {
+ public:
+ MessageType();
+ virtual ~MessageType();
+
+ MessageType(const MessageType& from);
+ MessageType(MessageType&& from) noexcept
+ : MessageType() {
+ *this = ::std::move(from);
+ }
+
+ inline MessageType& operator=(const MessageType& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline MessageType& operator=(MessageType&& from) noexcept {
+ if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+ if (this != &from) InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return GetMetadataStatic().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return GetMetadataStatic().reflection;
+ }
+ static const MessageType& default_instance();
+
+ static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
+ static inline const MessageType* internal_default_instance() {
+ return reinterpret_cast<const MessageType*>(
+ &_MessageType_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 5;
+
+ friend void swap(MessageType& a, MessageType& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(MessageType* other) {
+ if (other == this) return;
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline MessageType* New() const final {
+ return CreateMaybeMessage<MessageType>(nullptr);
+ }
+
+ MessageType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<MessageType>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const MessageType& from);
+ void MergeFrom(const MessageType& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ inline void SharedCtor();
+ inline void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(MessageType* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "testproto.MessageType";
+ }
+ private:
+ inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+ return nullptr;
+ }
+ inline void* MaybeArenaPtr() const {
+ return nullptr;
+ }
+ public:
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_messages_2eproto);
+ return ::descriptor_table_messages_2eproto.file_level_metadata[kIndexInFileMessages];
+ }
+
+ public:
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kFooArrFieldNumber = 2,
+ kFooFieldNumber = 1,
+ };
+ // repeated .testproto.Foo foo_arr = 2;
+ int foo_arr_size() const;
+ private:
+ int _internal_foo_arr_size() const;
+ public:
+ void clear_foo_arr();
+ ::testproto::Foo* mutable_foo_arr(int index);
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::testproto::Foo >*
+ mutable_foo_arr();
+ private:
+ const ::testproto::Foo& _internal_foo_arr(int index) const;
+ ::testproto::Foo* _internal_add_foo_arr();
+ public:
+ const ::testproto::Foo& foo_arr(int index) const;
+ ::testproto::Foo* add_foo_arr();
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::testproto::Foo >&
+ foo_arr() const;
+
+ // .testproto.Foo foo = 1;
+ bool has_foo() const;
+ private:
+ bool _internal_has_foo() const;
+ public:
+ void clear_foo();
+ const ::testproto::Foo& foo() const;
+ ::testproto::Foo* release_foo();
+ ::testproto::Foo* mutable_foo();
+ void set_allocated_foo(::testproto::Foo* foo);
+ private:
+ const ::testproto::Foo& _internal_foo() const;
+ ::testproto::Foo* _internal_mutable_foo();
+ public:
+
+ // @@protoc_insertion_point(class_scope:testproto.MessageType)
+ private:
+ class _Internal;
+
+ ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::testproto::Foo > foo_arr_;
+ ::testproto::Foo* foo_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
class JsonNaming :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:testproto.JsonNaming) */ {
public:
@@ -469,7 +924,7 @@ class JsonNaming :
&_JsonNaming_default_instance_);
}
static constexpr int kIndexInFileMessages =
- 3;
+ 6;
friend void swap(JsonNaming& a, JsonNaming& b) {
a.Swap(&b);
@@ -636,7 +1091,7 @@ class OneofValue :
&_OneofValue_default_instance_);
}
static constexpr int kIndexInFileMessages =
- 4;
+ 7;
friend void swap(OneofValue& a, OneofValue& b) {
a.Swap(&b);
@@ -803,7 +1258,7 @@ class StringArray :
&_StringArray_default_instance_);
}
static constexpr int kIndexInFileMessages =
- 5;
+ 8;
friend void swap(StringArray& a, StringArray& b) {
a.Swap(&b);
@@ -946,7 +1401,7 @@ class TwoDimensionalArray :
&_TwoDimensionalArray_default_instance_);
}
static constexpr int kIndexInFileMessages =
- 6;
+ 9;
friend void swap(TwoDimensionalArray& a, TwoDimensionalArray& b) {
a.Swap(&b);
@@ -1039,6 +1494,141 @@ class TwoDimensionalArray :
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_messages_2eproto;
};
+// -------------------------------------------------------------------
+
+class BytesType :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:testproto.BytesType) */ {
+ public:
+ BytesType();
+ virtual ~BytesType();
+
+ BytesType(const BytesType& from);
+ BytesType(BytesType&& from) noexcept
+ : BytesType() {
+ *this = ::std::move(from);
+ }
+
+ inline BytesType& operator=(const BytesType& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline BytesType& operator=(BytesType&& from) noexcept {
+ if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+ if (this != &from) InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return GetMetadataStatic().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return GetMetadataStatic().reflection;
+ }
+ static const BytesType& default_instance();
+
+ static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
+ static inline const BytesType* internal_default_instance() {
+ return reinterpret_cast<const BytesType*>(
+ &_BytesType_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 10;
+
+ friend void swap(BytesType& a, BytesType& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(BytesType* other) {
+ if (other == this) return;
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline BytesType* New() const final {
+ return CreateMaybeMessage<BytesType>(nullptr);
+ }
+
+ BytesType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<BytesType>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const BytesType& from);
+ void MergeFrom(const BytesType& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ inline void SharedCtor();
+ inline void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(BytesType* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "testproto.BytesType";
+ }
+ private:
+ inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+ return nullptr;
+ }
+ inline void* MaybeArenaPtr() const {
+ return nullptr;
+ }
+ public:
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_messages_2eproto);
+ return ::descriptor_table_messages_2eproto.file_level_metadata[kIndexInFileMessages];
+ }
+
+ public:
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kBytesValueFieldNumber = 1,
+ };
+ // bytes bytes_value = 1;
+ void clear_bytes_value();
+ const std::string& bytes_value() const;
+ void set_bytes_value(const std::string& value);
+ void set_bytes_value(std::string&& value);
+ void set_bytes_value(const char* value);
+ void set_bytes_value(const void* value, size_t size);
+ std::string* mutable_bytes_value();
+ std::string* release_bytes_value();
+ void set_allocated_bytes_value(std::string* bytes_value);
+ private:
+ const std::string& _internal_bytes_value() const;
+ void _internal_set_bytes_value(const std::string& value);
+ std::string* _internal_mutable_bytes_value();
+ public:
+
+ // @@protoc_insertion_point(class_scope:testproto.BytesType)
+ private:
+ class _Internal;
+
+ ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bytes_value_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_messages_2eproto;
+};
// ===================================================================
@@ -1255,7 +1845,7 @@ SimpleStruct::mutable_string_arr() {
return &string_arr_;
}
-// map<string, int32> int_map = 5;
+// map<int32, int32> int_map = 5;
inline int SimpleStruct::_internal_int_map_size() const {
return int_map_.size();
}
@@ -1265,20 +1855,20 @@ inline int SimpleStruct::int_map_size() const {
inline void SimpleStruct::clear_int_map() {
int_map_.Clear();
}
-inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::int32 >&
+inline const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::int32 >&
SimpleStruct::_internal_int_map() const {
return int_map_.GetMap();
}
-inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::int32 >&
+inline const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::int32 >&
SimpleStruct::int_map() const {
// @@protoc_insertion_point(field_map:testproto.SimpleStruct.int_map)
return _internal_int_map();
}
-inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::int32 >*
+inline ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::int32 >*
SimpleStruct::_internal_mutable_int_map() {
return int_map_.MutableMap();
}
-inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::int32 >*
+inline ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::int32 >*
SimpleStruct::mutable_int_map() {
// @@protoc_insertion_point(field_mutable_map:testproto.SimpleStruct.int_map)
return _internal_mutable_int_map();
@@ -1355,6 +1945,297 @@ inline void SimpleStruct::set_uint64_value(::PROTOBUF_NAMESPACE_ID::uint64 value
// -------------------------------------------------------------------
+// Bar
+
+// string value = 2;
+inline void Bar::clear_value() {
+ value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline const std::string& Bar::value() const {
+ // @@protoc_insertion_point(field_get:testproto.Bar.value)
+ return _internal_value();
+}
+inline void Bar::set_value(const std::string& value) {
+ _internal_set_value(value);
+ // @@protoc_insertion_point(field_set:testproto.Bar.value)
+}
+inline std::string* Bar::mutable_value() {
+ // @@protoc_insertion_point(field_mutable:testproto.Bar.value)
+ return _internal_mutable_value();
+}
+inline const std::string& Bar::_internal_value() const {
+ return value_.GetNoArena();
+}
+inline void Bar::_internal_set_value(const std::string& value) {
+
+ value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+}
+inline void Bar::set_value(std::string&& value) {
+
+ value_.SetNoArena(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+ // @@protoc_insertion_point(field_set_rvalue:testproto.Bar.value)
+}
+inline void Bar::set_value(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+
+ value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+ // @@protoc_insertion_point(field_set_char:testproto.Bar.value)
+}
+inline void Bar::set_value(const char* value, size_t size) {
+
+ value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ ::std::string(reinterpret_cast<const char*>(value), size));
+ // @@protoc_insertion_point(field_set_pointer:testproto.Bar.value)
+}
+inline std::string* Bar::_internal_mutable_value() {
+
+ return value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline std::string* Bar::release_value() {
+ // @@protoc_insertion_point(field_release:testproto.Bar.value)
+
+ return value_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline void Bar::set_allocated_value(std::string* value) {
+ if (value != nullptr) {
+
+ } else {
+
+ }
+ value_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+ // @@protoc_insertion_point(field_set_allocated:testproto.Bar.value)
+}
+
+// -------------------------------------------------------------------
+
+// Foo
+
+// string value = 1;
+inline void Foo::clear_value() {
+ value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline const std::string& Foo::value() const {
+ // @@protoc_insertion_point(field_get:testproto.Foo.value)
+ return _internal_value();
+}
+inline void Foo::set_value(const std::string& value) {
+ _internal_set_value(value);
+ // @@protoc_insertion_point(field_set:testproto.Foo.value)
+}
+inline std::string* Foo::mutable_value() {
+ // @@protoc_insertion_point(field_mutable:testproto.Foo.value)
+ return _internal_mutable_value();
+}
+inline const std::string& Foo::_internal_value() const {
+ return value_.GetNoArena();
+}
+inline void Foo::_internal_set_value(const std::string& value) {
+
+ value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+}
+inline void Foo::set_value(std::string&& value) {
+
+ value_.SetNoArena(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+ // @@protoc_insertion_point(field_set_rvalue:testproto.Foo.value)
+}
+inline void Foo::set_value(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+
+ value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+ // @@protoc_insertion_point(field_set_char:testproto.Foo.value)
+}
+inline void Foo::set_value(const char* value, size_t size) {
+
+ value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ ::std::string(reinterpret_cast<const char*>(value), size));
+ // @@protoc_insertion_point(field_set_pointer:testproto.Foo.value)
+}
+inline std::string* Foo::_internal_mutable_value() {
+
+ return value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline std::string* Foo::release_value() {
+ // @@protoc_insertion_point(field_release:testproto.Foo.value)
+
+ return value_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline void Foo::set_allocated_value(std::string* value) {
+ if (value != nullptr) {
+
+ } else {
+
+ }
+ value_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+ // @@protoc_insertion_point(field_set_allocated:testproto.Foo.value)
+}
+
+// .testproto.Bar bar = 2;
+inline bool Foo::_internal_has_bar() const {
+ return this != internal_default_instance() && bar_ != nullptr;
+}
+inline bool Foo::has_bar() const {
+ return _internal_has_bar();
+}
+inline void Foo::clear_bar() {
+ if (GetArenaNoVirtual() == nullptr && bar_ != nullptr) {
+ delete bar_;
+ }
+ bar_ = nullptr;
+}
+inline const ::testproto::Bar& Foo::_internal_bar() const {
+ const ::testproto::Bar* p = bar_;
+ return p != nullptr ? *p : *reinterpret_cast<const ::testproto::Bar*>(
+ &::testproto::_Bar_default_instance_);
+}
+inline const ::testproto::Bar& Foo::bar() const {
+ // @@protoc_insertion_point(field_get:testproto.Foo.bar)
+ return _internal_bar();
+}
+inline ::testproto::Bar* Foo::release_bar() {
+ // @@protoc_insertion_point(field_release:testproto.Foo.bar)
+
+ ::testproto::Bar* temp = bar_;
+ bar_ = nullptr;
+ return temp;
+}
+inline ::testproto::Bar* Foo::_internal_mutable_bar() {
+
+ if (bar_ == nullptr) {
+ auto* p = CreateMaybeMessage<::testproto::Bar>(GetArenaNoVirtual());
+ bar_ = p;
+ }
+ return bar_;
+}
+inline ::testproto::Bar* Foo::mutable_bar() {
+ // @@protoc_insertion_point(field_mutable:testproto.Foo.bar)
+ return _internal_mutable_bar();
+}
+inline void Foo::set_allocated_bar(::testproto::Bar* bar) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
+ if (message_arena == nullptr) {
+ delete bar_;
+ }
+ if (bar) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
+ if (message_arena != submessage_arena) {
+ bar = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, bar, submessage_arena);
+ }
+
+ } else {
+
+ }
+ bar_ = bar;
+ // @@protoc_insertion_point(field_set_allocated:testproto.Foo.bar)
+}
+
+// -------------------------------------------------------------------
+
+// MessageType
+
+// .testproto.Foo foo = 1;
+inline bool MessageType::_internal_has_foo() const {
+ return this != internal_default_instance() && foo_ != nullptr;
+}
+inline bool MessageType::has_foo() const {
+ return _internal_has_foo();
+}
+inline void MessageType::clear_foo() {
+ if (GetArenaNoVirtual() == nullptr && foo_ != nullptr) {
+ delete foo_;
+ }
+ foo_ = nullptr;
+}
+inline const ::testproto::Foo& MessageType::_internal_foo() const {
+ const ::testproto::Foo* p = foo_;
+ return p != nullptr ? *p : *reinterpret_cast<const ::testproto::Foo*>(
+ &::testproto::_Foo_default_instance_);
+}
+inline const ::testproto::Foo& MessageType::foo() const {
+ // @@protoc_insertion_point(field_get:testproto.MessageType.foo)
+ return _internal_foo();
+}
+inline ::testproto::Foo* MessageType::release_foo() {
+ // @@protoc_insertion_point(field_release:testproto.MessageType.foo)
+
+ ::testproto::Foo* temp = foo_;
+ foo_ = nullptr;
+ return temp;
+}
+inline ::testproto::Foo* MessageType::_internal_mutable_foo() {
+
+ if (foo_ == nullptr) {
+ auto* p = CreateMaybeMessage<::testproto::Foo>(GetArenaNoVirtual());
+ foo_ = p;
+ }
+ return foo_;
+}
+inline ::testproto::Foo* MessageType::mutable_foo() {
+ // @@protoc_insertion_point(field_mutable:testproto.MessageType.foo)
+ return _internal_mutable_foo();
+}
+inline void MessageType::set_allocated_foo(::testproto::Foo* foo) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
+ if (message_arena == nullptr) {
+ delete foo_;
+ }
+ if (foo) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
+ if (message_arena != submessage_arena) {
+ foo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, foo, submessage_arena);
+ }
+
+ } else {
+
+ }
+ foo_ = foo;
+ // @@protoc_insertion_point(field_set_allocated:testproto.MessageType.foo)
+}
+
+// repeated .testproto.Foo foo_arr = 2;
+inline int MessageType::_internal_foo_arr_size() const {
+ return foo_arr_.size();
+}
+inline int MessageType::foo_arr_size() const {
+ return _internal_foo_arr_size();
+}
+inline void MessageType::clear_foo_arr() {
+ foo_arr_.Clear();
+}
+inline ::testproto::Foo* MessageType::mutable_foo_arr(int index) {
+ // @@protoc_insertion_point(field_mutable:testproto.MessageType.foo_arr)
+ return foo_arr_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::testproto::Foo >*
+MessageType::mutable_foo_arr() {
+ // @@protoc_insertion_point(field_mutable_list:testproto.MessageType.foo_arr)
+ return &foo_arr_;
+}
+inline const ::testproto::Foo& MessageType::_internal_foo_arr(int index) const {
+ return foo_arr_.Get(index);
+}
+inline const ::testproto::Foo& MessageType::foo_arr(int index) const {
+ // @@protoc_insertion_point(field_get:testproto.MessageType.foo_arr)
+ return _internal_foo_arr(index);
+}
+inline ::testproto::Foo* MessageType::_internal_add_foo_arr() {
+ return foo_arr_.Add();
+}
+inline ::testproto::Foo* MessageType::add_foo_arr() {
+ // @@protoc_insertion_point(field_add:testproto.MessageType.foo_arr)
+ return _internal_add_foo_arr();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::testproto::Foo >&
+MessageType::foo_arr() const {
+ // @@protoc_insertion_point(field_list:testproto.MessageType.foo_arr)
+ return foo_arr_;
+}
+
+// -------------------------------------------------------------------
+
// JsonNaming
// float foo_value = 1;
@@ -1719,6 +2600,70 @@ TwoDimensionalArray::arr() const {
return arr_;
}
+// -------------------------------------------------------------------
+
+// BytesType
+
+// bytes bytes_value = 1;
+inline void BytesType::clear_bytes_value() {
+ bytes_value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline const std::string& BytesType::bytes_value() const {
+ // @@protoc_insertion_point(field_get:testproto.BytesType.bytes_value)
+ return _internal_bytes_value();
+}
+inline void BytesType::set_bytes_value(const std::string& value) {
+ _internal_set_bytes_value(value);
+ // @@protoc_insertion_point(field_set:testproto.BytesType.bytes_value)
+}
+inline std::string* BytesType::mutable_bytes_value() {
+ // @@protoc_insertion_point(field_mutable:testproto.BytesType.bytes_value)
+ return _internal_mutable_bytes_value();
+}
+inline const std::string& BytesType::_internal_bytes_value() const {
+ return bytes_value_.GetNoArena();
+}
+inline void BytesType::_internal_set_bytes_value(const std::string& value) {
+
+ bytes_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+}
+inline void BytesType::set_bytes_value(std::string&& value) {
+
+ bytes_value_.SetNoArena(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+ // @@protoc_insertion_point(field_set_rvalue:testproto.BytesType.bytes_value)
+}
+inline void BytesType::set_bytes_value(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+
+ bytes_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+ // @@protoc_insertion_point(field_set_char:testproto.BytesType.bytes_value)
+}
+inline void BytesType::set_bytes_value(const void* value, size_t size) {
+
+ bytes_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ ::std::string(reinterpret_cast<const char*>(value), size));
+ // @@protoc_insertion_point(field_set_pointer:testproto.BytesType.bytes_value)
+}
+inline std::string* BytesType::_internal_mutable_bytes_value() {
+
+ return bytes_value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline std::string* BytesType::release_bytes_value() {
+ // @@protoc_insertion_point(field_release:testproto.BytesType.bytes_value)
+
+ return bytes_value_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline void BytesType::set_allocated_bytes_value(std::string* bytes_value) {
+ if (bytes_value != nullptr) {
+
+ } else {
+
+ }
+ bytes_value_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), bytes_value);
+ // @@protoc_insertion_point(field_set_allocated:testproto.BytesType.bytes_value)
+}
+
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif // __GNUC__
@@ -1734,6 +2679,14 @@ TwoDimensionalArray::arr() const {
// -------------------------------------------------------------------
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
// @@protoc_insertion_point(namespace_scope)
diff --git a/cpp/tests/util/env.hh b/cpp/tests/util/env.hh
index a568743550e6e9cb6c036b8d5dc3ba07fdb71595..cb01a8c1de742a59e95935f5342de7e68fbf900c 100644
--- a/cpp/tests/util/env.hh
+++ b/cpp/tests/util/env.hh
@@ -3,7 +3,7 @@
#include <string>
-#include "catch.hpp"
+#include <catch2/catch.hpp>
#include <fmt/core.h>
namespace vereign {
diff --git a/cpp/tests/util/protobuf.cc b/cpp/tests/util/protobuf.cc
index c8a1ae96c0d491510a158236161f8dc843cea08d..544c5770d1b70a5a06192488cdcbc85adfd0731b 100644
--- a/cpp/tests/util/protobuf.cc
+++ b/cpp/tests/util/protobuf.cc
@@ -1,37 +1,19 @@
+#include "vereign/grpc/json/encoder.hh"
#include <util/protobuf.hh>
#include <google/protobuf/util/json_util.h>
#include <fmt/core.h>
-#include "catch.hpp"
+#include <catch2/catch.hpp>
namespace vereign {
namespace test {
-std::string ProtobufToJson(const google::protobuf::Message& msg) {
- google::protobuf::util::JsonPrintOptions options;
- options.preserve_proto_field_names = true;
- options.always_print_primitive_fields = true;
- options.always_print_enums_as_ints = true;
- options.add_whitespace = true;
+auto ProtobufToJson(const google::protobuf::Message& msg) -> std::string {
+ std::string result;
+ grpc::json::Encode(msg, result, grpc::json::EncodeOptions{}.Pretty(2));
- std::string json;
- auto status = google::protobuf::util::MessageToJsonString(
- msg,
- &json,
- options
- );
-
- if (!status.ok()) {
- FAIL(
- fmt::format(
- "request json encode failed: {}",
- std::string(status.error_message())
- )
- );
- }
-
- return json;
+ return result;
}
} // namespace vereign
diff --git a/cpp/tests/vereign/CMakeLists.txt b/cpp/tests/vereign/CMakeLists.txt
index 16cfb8cd3fef6e4b115b02849e6c4a95c336706c..4deb797f1635045a7c356cbcfa1f0fcd8eae940c 100644
--- a/cpp/tests/vereign/CMakeLists.txt
+++ b/cpp/tests/vereign/CMakeLists.txt
@@ -6,8 +6,9 @@ include_directories(
${CMAKE_SOURCE_DIR}/proto/cpp
)
+
list(APPEND tests_src
- ../init_tests.cc
+ init_tests.cc
../util/protobuf.cc
../experiment/array.cc
@@ -16,26 +17,40 @@ list(APPEND tests_src
restapi/client_session_test.cc
service/gen/passport_service_test.cc
grpc/server_test.cc
+ grpc/json/encoder_test.cc
)
add_executable(tests ${tests_src})
+
+target_proto_generate(
+ TARGET tests
+ SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/grpc/json/proto
+ GEN_DIR ${CMAKE_CURRENT_SOURCE_DIR}/grpc/json/pb
+ DEFINITIONS
+ grpc/json/proto/messages.proto
+)
+
target_link_libraries(tests
vereignlib
Threads::Threads
)
+if (VEREIGN_ENABLE_BENCHMARKING)
+ target_compile_definitions(tests PRIVATE CATCH_CONFIG_ENABLE_BENCHMARKING)
+endif()
+
if (VEREIGN_USE_TIME_TRACE AND CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
target_compile_options(tests
PRIVATE "-ftime-trace"
)
endif()
-#add_custom_command(
-# TARGET protobuf_tests
-# COMMENT "Run protobuf tests"
-# POST_BUILD
-# WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
-# COMMAND ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/protobuf_tests
-#)
+# add_custom_command(
+ # TARGET tests
+ # COMMENT "Run vereign tests"
+ # POST_BUILD
+ # WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+ # COMMAND ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/tests "Encode"
+# )
add_test(
NAME tests
diff --git a/cpp/tests/vereign/grpc/json/encoder_test.cc b/cpp/tests/vereign/grpc/json/encoder_test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..c11b41e95013417b294c28f454a9722c50c510d5
--- /dev/null
+++ b/cpp/tests/vereign/grpc/json/encoder_test.cc
@@ -0,0 +1,652 @@
+#include <vereign/grpc/json/encoder.hh>
+#include <vereign/grpc/json/pb/messages.pb.h>
+#include <boost/math/constants/constants.hpp>
+
+#include <vereign/core/hex.hh>
+
+#include <catch2/catch.hpp>
+
+using namespace vereign;
+namespace pb = test::vereign::grpc::json::pb;
+
+TEST_CASE("grpc::json::Encode scalars", "[vereign/grpc/json]") {
+ pb::SimpleStruct msg;
+ msg.set_int32_value(2147483647);
+ msg.set_int64_value(9223372036854775807);
+
+ msg.set_uint32_value(4294967295);
+ msg.set_uint64_value(18446744073709551615ULL);
+
+ msg.set_sint32_value(2147483647);
+ msg.set_sint64_value(9223372036854775807);
+
+ msg.set_fixed32_value(4294967295);
+ msg.set_fixed64_value(18446744073709551615ULL);
+
+ msg.set_sfixed32_value(2147483647);
+ msg.set_sfixed64_value(9223372036854775807);
+
+ msg.set_float_value(boost::math::constants::pi<float>());
+ msg.set_double_value(boost::math::constants::pi<double>());
+
+ msg.set_bool_value(true);
+ msg.set_string_value("foo");
+
+ std::string result;
+ grpc::json::Encode(msg, result, grpc::json::EncodeOptions{}.Pretty(2));
+
+ auto expected = R"({
+ "bool_value": true,
+ "double_value": 3.141592653589793,
+ "fixed32_value": 4294967295,
+ "fixed64_value": 18446744073709551615,
+ "float_value": 3.1415927410125732,
+ "int32_value": 2147483647,
+ "int64_value": 9223372036854775807,
+ "sfixed32_value": 2147483647,
+ "sfixed64_value": 9223372036854775807,
+ "sint32_value": 2147483647,
+ "sint64_value": 9223372036854775807,
+ "string_value": "foo",
+ "uint32_value": 4294967295,
+ "uint64_value": 18446744073709551615
+})";
+
+ CHECK(result == expected);
+}
+
+TEST_CASE("grpc::json::Encode scalars with OmitEmpty", "[vereign/grpc/json]") {
+ pb::SimpleStruct msg;
+
+ std::string result;
+ grpc::json::Encode(msg, result, grpc::json::EncodeOptions{}.WithOmitEmpty());
+
+ auto expected = R"({"bool_value":false})";
+
+ CHECK(result == expected);
+}
+
+TEST_CASE("grpc::json::Encode repeated scalars", "[vereign/grpc/json]") {
+ pb::RepeatedTypes msg;
+ msg.add_int32_arr(1);
+ msg.add_int32_arr(2147483647);
+
+ msg.add_int64_arr(2);
+ msg.add_int64_arr(9223372036854775807);
+
+ msg.add_uint32_arr(3);
+ msg.add_uint32_arr(4294967295);
+
+ msg.add_uint64_arr(4);
+ msg.add_uint64_arr(18446744073709551615ULL);
+
+ msg.add_sint32_arr(5);
+ msg.add_sint32_arr(2147483647);
+
+ msg.add_sint64_arr(6);
+ msg.add_sint64_arr(9223372036854775807);
+
+ msg.add_fixed32_arr(7);
+ msg.add_fixed32_arr(4294967295);
+
+ msg.add_fixed64_arr(8);
+ msg.add_fixed64_arr(18446744073709551615ULL);
+
+ msg.add_sfixed32_arr(9);
+ msg.add_sfixed32_arr(2147483647);
+
+ msg.add_sfixed64_arr(10);
+ msg.add_sfixed64_arr(9223372036854775807);
+
+ msg.add_float_arr(11.5);
+ msg.add_float_arr(boost::math::constants::pi<float>());
+
+ msg.add_double_arr(12.5);
+ msg.add_double_arr(boost::math::constants::pi<double>());
+
+ msg.add_bool_arr(false);
+ msg.add_bool_arr(true);
+
+ msg.add_string_arr("foo");
+ msg.add_string_arr("bar");
+
+ std::string result;
+ grpc::json::Encode(msg, result, grpc::json::EncodeOptions{}.Pretty(2));
+
+ auto expected = R"({
+ "bool_arr": [
+ false,
+ true
+ ],
+ "double_arr": [
+ 12.5,
+ 3.141592653589793
+ ],
+ "fixed32_arr": [
+ 7,
+ 4294967295
+ ],
+ "fixed64_arr": [
+ 8,
+ 18446744073709551615
+ ],
+ "float_arr": [
+ 11.5,
+ 3.1415927410125732
+ ],
+ "int32_arr": [
+ 1,
+ 2147483647
+ ],
+ "int64_arr": [
+ 2,
+ 9223372036854775807
+ ],
+ "sfixed32_arr": [
+ 9,
+ 2147483647
+ ],
+ "sfixed64_arr": [
+ 10,
+ 9223372036854775807
+ ],
+ "sint32_arr": [
+ 5,
+ 2147483647
+ ],
+ "sint64_arr": [
+ 6,
+ 9223372036854775807
+ ],
+ "string_arr": [
+ "foo",
+ "bar"
+ ],
+ "uint32_arr": [
+ 3,
+ 4294967295
+ ],
+ "uint64_arr": [
+ 4,
+ 18446744073709551615
+ ]
+})";
+
+ CHECK(result == expected);
+}
+
+TEST_CASE("grpc::json::Encode empty repeated scalars without OmitEmpty", "[vereign/grpc/json]") {
+ pb::RepeatedTypes msg;
+
+ std::string result;
+ grpc::json::Encode(msg, result, grpc::json::EncodeOptions{}.Pretty(2));
+
+ auto expected = R"({
+ "bool_arr": [],
+ "double_arr": [],
+ "fixed32_arr": [],
+ "fixed64_arr": [],
+ "float_arr": [],
+ "int32_arr": [],
+ "int64_arr": [],
+ "sfixed32_arr": [],
+ "sfixed64_arr": [],
+ "sint32_arr": [],
+ "sint64_arr": [],
+ "string_arr": [],
+ "uint32_arr": [],
+ "uint64_arr": []
+})";
+
+ CHECK(result == expected);
+}
+
+TEST_CASE("grpc::json::Encode empty repeated scalars with OmitEmpty", "[vereign/grpc/json]") {
+ pb::RepeatedTypes msg;
+ msg.add_int32_arr(0);
+
+ std::string result;
+ grpc::json::Encode(msg, result, grpc::json::EncodeOptions{}.WithOmitEmpty());
+
+ auto expected = R"({"int32_arr":[0]})";
+
+ CHECK(result == expected);
+}
+
+TEST_CASE("grpc::json::Encode nested messages", "[vereign/grpc/json]") {
+ pb::MessageType msg;
+ msg.mutable_foo()->set_value("foo");
+ msg.mutable_foo()->mutable_bar()->set_value("bar");
+
+ auto foo_arr = msg.add_foo_arr();
+ foo_arr->set_value("foo1");
+ foo_arr->mutable_bar()->set_value("bar1");
+
+ foo_arr = msg.add_foo_arr();
+ foo_arr->set_value("foo2");
+ foo_arr->mutable_bar()->set_value("bar2");
+
+ std::string result;
+ grpc::json::Encode(msg, result, grpc::json::EncodeOptions{}.Pretty(2));
+
+ auto expected = R"({
+ "foo": {
+ "bar": {
+ "value": "bar"
+ },
+ "value": "foo"
+ },
+ "foo_arr": [
+ {
+ "bar": {
+ "value": "bar1"
+ },
+ "value": "foo1"
+ },
+ {
+ "bar": {
+ "value": "bar2"
+ },
+ "value": "foo2"
+ }
+ ]
+})";
+
+ CHECK(result == expected);
+}
+
+TEST_CASE("grpc::json::Encode empty messages without OmitEmpty", "[vereign/grpc/json]") {
+ pb::MessageType msg;
+
+ std::string result;
+ grpc::json::Encode(msg, result, grpc::json::EncodeOptions{}.Pretty(2));
+
+
+ auto expected = R"({
+ "foo": {
+ "bar": {
+ "value": ""
+ },
+ "value": ""
+ },
+ "foo_arr": []
+})";
+
+ CHECK(result == expected);
+}
+
+TEST_CASE("grpc::json::Encode empty messages with OmitEmpty", "[vereign/grpc/json]") {
+ pb::MessageType msg;
+ msg.add_foo_arr();
+
+ std::string result;
+ grpc::json::Encode(msg, result, grpc::json::EncodeOptions{}.WithOmitEmpty().Pretty(2));
+
+ auto expected = R"({
+ "foo_arr": [
+ {}
+ ]
+})";
+
+ CHECK(result == expected);
+}
+
+TEST_CASE("grpc::json::Encode map", "[vereign/grpc/json]") {
+ pb::MapType msg;
+ auto& map = *msg.mutable_int32_key();
+ map[2147483647] = "foo";
+ map[-1] = "bar";
+ (*msg.mutable_int64_key())[9223372036854775807] = "foo";
+
+ (*msg.mutable_uint32_key())[4294967295] = "foo";
+ (*msg.mutable_uint64_key())[18446744073709551615ULL] = "foo";
+
+ (*msg.mutable_sint32_key())[2147483647] = "foo";
+ (*msg.mutable_sint64_key())[9223372036854775807] = "foo";
+
+ (*msg.mutable_fixed32_key())[4294967295] = "foo";
+ (*msg.mutable_fixed64_key())[18446744073709551615ULL] = "foo";
+
+ (*msg.mutable_sfixed32_key())[2147483647] = "foo";
+ (*msg.mutable_sfixed64_key())[9223372036854775807] = "foo";
+
+ (*msg.mutable_string_key())["bar"] = "foo";
+ (*msg.mutable_string_key())["baz"] = "qux";
+
+ std::string result;
+ grpc::json::Encode(msg, result, grpc::json::EncodeOptions{}.Pretty(2).WithOmitEmpty());
+
+ auto expected = R"({
+ "fixed32_key": {
+ "4294967295": "foo"
+ },
+ "fixed64_key": {
+ "18446744073709551615": "foo"
+ },
+ "int32_key": {
+ "-1": "bar",
+ "2147483647": "foo"
+ },
+ "int64_key": {
+ "9223372036854775807": "foo"
+ },
+ "sfixed32_key": {
+ "2147483647": "foo"
+ },
+ "sfixed64_key": {
+ "9223372036854775807": "foo"
+ },
+ "sint32_key": {
+ "2147483647": "foo"
+ },
+ "sint64_key": {
+ "9223372036854775807": "foo"
+ },
+ "string_key": {
+ "bar": "foo",
+ "baz": "qux"
+ },
+ "uint32_key": {
+ "4294967295": "foo"
+ },
+ "uint64_key": {
+ "18446744073709551615": "foo"
+ }
+})";
+
+ CHECK(result == expected);
+}
+
+TEST_CASE("grpc::json::Encode empty map without OmitEmpty", "[vereign/grpc/json]") {
+ pb::MapType msg;
+
+ std::string result;
+ grpc::json::Encode(msg, result, grpc::json::EncodeOptions{}.Pretty(2));
+
+ auto expected = R"({
+ "fixed32_key": {},
+ "fixed64_key": {},
+ "int32_key": {},
+ "int64_key": {},
+ "sfixed32_key": {},
+ "sfixed64_key": {},
+ "sint32_key": {},
+ "sint64_key": {},
+ "string_key": {},
+ "uint32_key": {},
+ "uint64_key": {}
+})";
+
+ CHECK(result == expected);
+}
+
+TEST_CASE("grpc::json::Encode empty map with OmitEmpty", "[vereign/grpc/json]") {
+ pb::MapType msg;
+
+ std::string result;
+ grpc::json::Encode(msg, result, grpc::json::EncodeOptions{}.WithOmitEmpty());
+
+ auto expected = R"({})";
+
+ CHECK(result == expected);
+}
+
+TEST_CASE("grpc::json::Encode map with Message value", "[vereign/grpc/json]") {
+ pb::MapMessageType msg;
+
+ auto& map = *msg.mutable_msg();
+ map["fred"].mutable_foo()->set_value("foo");
+ map["fred"].mutable_foo()->mutable_bar()->set_value("bar");
+
+ auto fred_arr = map["fred"].add_foo_arr();
+ fred_arr->set_value("fred.foo1");
+ fred_arr->mutable_bar()->set_value("fred.bar1");
+
+ fred_arr = map["fred"].add_foo_arr();
+ fred_arr->set_value("fred.foo2");
+ fred_arr->mutable_bar()->set_value("fred.bar2");
+
+ auto barney_arr = map["barney"].add_foo_arr();
+ barney_arr->set_value("barney.foo1");
+ barney_arr->mutable_bar()->set_value("barney.bar1");
+
+ barney_arr = map["barney"].add_foo_arr();
+ barney_arr->set_value("barney.foo2");
+ barney_arr->mutable_bar()->set_value("barney.bar2");
+
+ std::string result;
+ grpc::json::Encode(msg, result, grpc::json::EncodeOptions{}.Pretty(2));
+
+ auto expected = R"({
+ "msg": {
+ "barney": {
+ "foo": {
+ "bar": {
+ "value": ""
+ },
+ "value": ""
+ },
+ "foo_arr": [
+ {
+ "bar": {
+ "value": "barney.bar1"
+ },
+ "value": "barney.foo1"
+ },
+ {
+ "bar": {
+ "value": "barney.bar2"
+ },
+ "value": "barney.foo2"
+ }
+ ]
+ },
+ "fred": {
+ "foo": {
+ "bar": {
+ "value": "bar"
+ },
+ "value": "foo"
+ },
+ "foo_arr": [
+ {
+ "bar": {
+ "value": "fred.bar1"
+ },
+ "value": "fred.foo1"
+ },
+ {
+ "bar": {
+ "value": "fred.bar2"
+ },
+ "value": "fred.foo2"
+ }
+ ]
+ }
+ }
+})";
+
+ CHECK(result == expected);
+}
+
+TEST_CASE("grpc::json::Encode bytes", "[vereign/grpc/json]") {
+ SECTION("bytes") {
+ pb::BytesType msg;
+
+ using namespace std::string_literals;
+ msg.set_bytes_value("\x00\x42"s "foobar");
+
+ std::string result;
+ grpc::json::Encode(msg, result, grpc::json::EncodeOptions{}.Pretty(2).WithOmitEmpty());
+
+ auto expected = R"({
+ "bytes_value": "AEJmb29iYXI="
+})";
+
+ CHECK(result == expected);
+ }
+
+ SECTION("repeated bytes") {
+ using namespace std::string_literals;
+
+ pb::BytesType msg;
+ msg.add_bytes_arr("\x00\x42"s "foobar");
+ msg.add_bytes_arr("\x00\x42"s "foobar");
+ msg.add_bytes_arr("");
+
+ std::string result;
+ grpc::json::Encode(msg, result, grpc::json::EncodeOptions{}.Pretty(2).WithOmitEmpty());
+
+ auto expected = R"({
+ "bytes_arr": [
+ "AEJmb29iYXI=",
+ "AEJmb29iYXI=",
+ ""
+ ]
+})";
+
+ CHECK(result == expected);
+ }
+}
+
+TEST_CASE("grpc::json::Encode naming", "[vereign/grpc/json]") {
+ pb::JsonNaming msg;
+ msg.set_foo_value(1);
+ msg.set_barvalue(2);
+ msg.set_bazvalue(3);
+ msg.set_qux_value(4);
+
+ std::string result;
+ grpc::json::Encode(msg, result, grpc::json::EncodeOptions{}.Pretty(2));
+
+ auto expected = R"({
+ "BazValue": 3,
+ "barValue": 2,
+ "foo_value": 1,
+ "quX_Value": 4
+})";
+
+ REQUIRE(result == expected);
+}
+
+TEST_CASE("grpc::json::Encode oneof", "[vereign/grpc/json]") {
+ SECTION("marshal string value") {
+ pb::OneofValue msg;
+ msg.set_string_value("foo bar");
+
+ std::string result;
+ grpc::json::Encode(msg, result, grpc::json::EncodeOptions{});
+
+ auto expected = R"({"string_value":"foo bar"})";
+
+ CHECK(result == expected);
+ }
+
+ SECTION("marshal struct value") {
+ pb::OneofValue msg;
+ msg.mutable_struct_value()->set_int32_value(42);
+
+ std::string result;
+ grpc::json::Encode(msg, result, grpc::json::EncodeOptions{}.WithOmitEmpty());
+
+ auto expected = R"({"struct_value":{"bool_value":false,"int32_value":42}})";
+
+ CHECK(result == expected);
+ }
+}
+
+TEST_CASE("grpc::json::Encode nested message", "[vereign/grpc/json]") {
+ SECTION("without OmitEmpty") {
+ pb::NestedType msg;
+ msg.set_value("nested value");
+ msg.mutable_foo_value()->set_value("nested foo");
+ msg.mutable_foo_value()->mutable_bar_value()->set_value("nested bar");
+
+ std::string result;
+ grpc::json::Encode(msg, result, grpc::json::EncodeOptions{}.Pretty(2));
+
+ auto expected = R"({
+ "foo_value": {
+ "bar_value": {
+ "Value": "nested bar"
+ },
+ "value": "nested foo"
+ },
+ "value": "nested value"
+})";
+
+ CHECK(result == expected);
+ }
+
+ SECTION("with OmitEmpty") {
+ pb::NestedType msg;
+ msg.set_value("nested value");
+ msg.mutable_foo_value()->set_value("nested foo");
+
+ std::string result;
+ grpc::json::Encode(msg, result, grpc::json::EncodeOptions{}.Pretty(2).WithOmitEmpty());
+
+ auto expected = R"({
+ "foo_value": {
+ "value": "nested foo"
+ },
+ "value": "nested value"
+})";
+
+ CHECK(result == expected);
+ }
+}
+
+TEST_CASE("grpc::json::Encode enum", "[vereign/grpc/json]") {
+ SECTION("non-zero value") {
+ pb::EnumType msg;
+ msg.set_corpus(pb::EnumType::Corpus::EnumType_Corpus_PRODUCTS);
+
+ std::string result;
+ grpc::json::Encode(msg, result, grpc::json::EncodeOptions{}.WithOmitEmpty());
+
+ auto expected = R"({"corpus":5})";
+
+ CHECK(result == expected);
+ }
+
+ SECTION("zero enum value with OmitEmpty") {
+ pb::EnumType msg;
+ msg.set_corpus(pb::EnumType::Corpus::EnumType_Corpus_UNIVERSAL);
+
+ std::string result;
+ grpc::json::Encode(msg, result, grpc::json::EncodeOptions{}.WithOmitEmpty());
+
+ auto expected = R"({})";
+
+ CHECK(result == expected);
+ }
+
+ SECTION("repeated") {
+ pb::RepeatedEnumType msg;
+ msg.add_corpus(pb::RepeatedEnumType::Corpus::RepeatedEnumType_Corpus_UNIVERSAL);
+ msg.add_corpus(pb::RepeatedEnumType::Corpus::RepeatedEnumType_Corpus_PRODUCTS);
+
+ std::string result;
+ grpc::json::Encode(msg, result, grpc::json::EncodeOptions{}.WithOmitEmpty());
+
+ auto expected = R"({"corpus":[0,5]})";
+
+ CHECK(result == expected);
+ }
+}
+
+#ifdef CATCH_CONFIG_ENABLE_BENCHMARKING
+
+TEST_CASE("grpc::json::Encode nested messages benchmark", "[vereign/grpc/json]") {
+ BENCHMARK("nested messages") {
+ pb::MessageType msg;
+ msg.mutable_foo()->set_value("foo");
+ msg.mutable_foo()->mutable_bar()->set_value("bar");
+
+ std::string result;
+ grpc::json::Encode(msg, result, grpc::json::EncodeOptions{}.Pretty(2));
+ };
+}
+
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
diff --git a/cpp/tests/vereign/grpc/json/pb/messages.pb.cc b/cpp/tests/vereign/grpc/json/pb/messages.pb.cc
new file mode 100644
index 0000000000000000000000000000000000000000..99aa41e099abeed695f18fb6ef397cf3a0692800
--- /dev/null
+++ b/cpp/tests/vereign/grpc/json/pb/messages.pb.cc
@@ -0,0 +1,6149 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: messages.proto
+
+#include "messages.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+extern PROTOBUF_INTERNAL_EXPORT_messages_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Bar_messages_2eproto;
+extern PROTOBUF_INTERNAL_EXPORT_messages_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_Foo_messages_2eproto;
+extern PROTOBUF_INTERNAL_EXPORT_messages_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_MapMessageType_MsgEntry_DoNotUse_messages_2eproto;
+extern PROTOBUF_INTERNAL_EXPORT_messages_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_MapType_Fixed32KeyEntry_DoNotUse_messages_2eproto;
+extern PROTOBUF_INTERNAL_EXPORT_messages_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_MapType_Fixed64KeyEntry_DoNotUse_messages_2eproto;
+extern PROTOBUF_INTERNAL_EXPORT_messages_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_MapType_Int32KeyEntry_DoNotUse_messages_2eproto;
+extern PROTOBUF_INTERNAL_EXPORT_messages_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_MapType_Int64KeyEntry_DoNotUse_messages_2eproto;
+extern PROTOBUF_INTERNAL_EXPORT_messages_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_MapType_Sfixed32KeyEntry_DoNotUse_messages_2eproto;
+extern PROTOBUF_INTERNAL_EXPORT_messages_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_MapType_Sfixed64KeyEntry_DoNotUse_messages_2eproto;
+extern PROTOBUF_INTERNAL_EXPORT_messages_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_MapType_Sint32KeyEntry_DoNotUse_messages_2eproto;
+extern PROTOBUF_INTERNAL_EXPORT_messages_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_MapType_Sint64KeyEntry_DoNotUse_messages_2eproto;
+extern PROTOBUF_INTERNAL_EXPORT_messages_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_MapType_StringKeyEntry_DoNotUse_messages_2eproto;
+extern PROTOBUF_INTERNAL_EXPORT_messages_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_MapType_Uint32KeyEntry_DoNotUse_messages_2eproto;
+extern PROTOBUF_INTERNAL_EXPORT_messages_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_MapType_Uint64KeyEntry_DoNotUse_messages_2eproto;
+extern PROTOBUF_INTERNAL_EXPORT_messages_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_MessageType_messages_2eproto;
+extern PROTOBUF_INTERNAL_EXPORT_messages_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_NestedType_NestedFoo_messages_2eproto;
+extern PROTOBUF_INTERNAL_EXPORT_messages_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_NestedType_NestedFoo_NestedBar_messages_2eproto;
+extern PROTOBUF_INTERNAL_EXPORT_messages_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_SimpleStruct_messages_2eproto;
+namespace test {
+namespace vereign {
+namespace grpc {
+namespace json {
+namespace pb {
+class SimpleStructDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<SimpleStruct> _instance;
+} _SimpleStruct_default_instance_;
+class RepeatedTypesDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RepeatedTypes> _instance;
+} _RepeatedTypes_default_instance_;
+class BarDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Bar> _instance;
+} _Bar_default_instance_;
+class FooDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Foo> _instance;
+} _Foo_default_instance_;
+class MessageTypeDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<MessageType> _instance;
+} _MessageType_default_instance_;
+class MapType_Int32KeyEntry_DoNotUseDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<MapType_Int32KeyEntry_DoNotUse> _instance;
+} _MapType_Int32KeyEntry_DoNotUse_default_instance_;
+class MapType_Int64KeyEntry_DoNotUseDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<MapType_Int64KeyEntry_DoNotUse> _instance;
+} _MapType_Int64KeyEntry_DoNotUse_default_instance_;
+class MapType_Uint32KeyEntry_DoNotUseDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<MapType_Uint32KeyEntry_DoNotUse> _instance;
+} _MapType_Uint32KeyEntry_DoNotUse_default_instance_;
+class MapType_Uint64KeyEntry_DoNotUseDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<MapType_Uint64KeyEntry_DoNotUse> _instance;
+} _MapType_Uint64KeyEntry_DoNotUse_default_instance_;
+class MapType_Sint32KeyEntry_DoNotUseDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<MapType_Sint32KeyEntry_DoNotUse> _instance;
+} _MapType_Sint32KeyEntry_DoNotUse_default_instance_;
+class MapType_Sint64KeyEntry_DoNotUseDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<MapType_Sint64KeyEntry_DoNotUse> _instance;
+} _MapType_Sint64KeyEntry_DoNotUse_default_instance_;
+class MapType_Fixed32KeyEntry_DoNotUseDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<MapType_Fixed32KeyEntry_DoNotUse> _instance;
+} _MapType_Fixed32KeyEntry_DoNotUse_default_instance_;
+class MapType_Fixed64KeyEntry_DoNotUseDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<MapType_Fixed64KeyEntry_DoNotUse> _instance;
+} _MapType_Fixed64KeyEntry_DoNotUse_default_instance_;
+class MapType_Sfixed32KeyEntry_DoNotUseDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<MapType_Sfixed32KeyEntry_DoNotUse> _instance;
+} _MapType_Sfixed32KeyEntry_DoNotUse_default_instance_;
+class MapType_Sfixed64KeyEntry_DoNotUseDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<MapType_Sfixed64KeyEntry_DoNotUse> _instance;
+} _MapType_Sfixed64KeyEntry_DoNotUse_default_instance_;
+class MapType_StringKeyEntry_DoNotUseDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<MapType_StringKeyEntry_DoNotUse> _instance;
+} _MapType_StringKeyEntry_DoNotUse_default_instance_;
+class MapTypeDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<MapType> _instance;
+} _MapType_default_instance_;
+class MapMessageType_MsgEntry_DoNotUseDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<MapMessageType_MsgEntry_DoNotUse> _instance;
+} _MapMessageType_MsgEntry_DoNotUse_default_instance_;
+class MapMessageTypeDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<MapMessageType> _instance;
+} _MapMessageType_default_instance_;
+class BytesTypeDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<BytesType> _instance;
+} _BytesType_default_instance_;
+class JsonNamingDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<JsonNaming> _instance;
+} _JsonNaming_default_instance_;
+class OneofValueDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<OneofValue> _instance;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_value_;
+ const ::test::vereign::grpc::json::pb::SimpleStruct* struct_value_;
+} _OneofValue_default_instance_;
+class EnumTypeDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<EnumType> _instance;
+} _EnumType_default_instance_;
+class RepeatedEnumTypeDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RepeatedEnumType> _instance;
+} _RepeatedEnumType_default_instance_;
+class NestedType_NestedFoo_NestedBarDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<NestedType_NestedFoo_NestedBar> _instance;
+} _NestedType_NestedFoo_NestedBar_default_instance_;
+class NestedType_NestedFooDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<NestedType_NestedFoo> _instance;
+} _NestedType_NestedFoo_default_instance_;
+class NestedTypeDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<NestedType> _instance;
+} _NestedType_default_instance_;
+} // namespace pb
+} // namespace json
+} // namespace grpc
+} // namespace vereign
+} // namespace test
+static void InitDefaultsscc_info_Bar_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::test::vereign::grpc::json::pb::_Bar_default_instance_;
+ new (ptr) ::test::vereign::grpc::json::pb::Bar();
+ ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+ }
+ ::test::vereign::grpc::json::pb::Bar::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Bar_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_Bar_messages_2eproto}, {}};
+
+static void InitDefaultsscc_info_BytesType_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::test::vereign::grpc::json::pb::_BytesType_default_instance_;
+ new (ptr) ::test::vereign::grpc::json::pb::BytesType();
+ ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+ }
+ ::test::vereign::grpc::json::pb::BytesType::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_BytesType_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_BytesType_messages_2eproto}, {}};
+
+static void InitDefaultsscc_info_EnumType_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::test::vereign::grpc::json::pb::_EnumType_default_instance_;
+ new (ptr) ::test::vereign::grpc::json::pb::EnumType();
+ ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+ }
+ ::test::vereign::grpc::json::pb::EnumType::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_EnumType_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_EnumType_messages_2eproto}, {}};
+
+static void InitDefaultsscc_info_Foo_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::test::vereign::grpc::json::pb::_Foo_default_instance_;
+ new (ptr) ::test::vereign::grpc::json::pb::Foo();
+ ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+ }
+ ::test::vereign::grpc::json::pb::Foo::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_Foo_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_Foo_messages_2eproto}, {
+ &scc_info_Bar_messages_2eproto.base,}};
+
+static void InitDefaultsscc_info_JsonNaming_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::test::vereign::grpc::json::pb::_JsonNaming_default_instance_;
+ new (ptr) ::test::vereign::grpc::json::pb::JsonNaming();
+ ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+ }
+ ::test::vereign::grpc::json::pb::JsonNaming::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_JsonNaming_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_JsonNaming_messages_2eproto}, {}};
+
+static void InitDefaultsscc_info_MapMessageType_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::test::vereign::grpc::json::pb::_MapMessageType_default_instance_;
+ new (ptr) ::test::vereign::grpc::json::pb::MapMessageType();
+ ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+ }
+ ::test::vereign::grpc::json::pb::MapMessageType::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_MapMessageType_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_MapMessageType_messages_2eproto}, {
+ &scc_info_MapMessageType_MsgEntry_DoNotUse_messages_2eproto.base,}};
+
+static void InitDefaultsscc_info_MapMessageType_MsgEntry_DoNotUse_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::test::vereign::grpc::json::pb::_MapMessageType_MsgEntry_DoNotUse_default_instance_;
+ new (ptr) ::test::vereign::grpc::json::pb::MapMessageType_MsgEntry_DoNotUse();
+ }
+ ::test::vereign::grpc::json::pb::MapMessageType_MsgEntry_DoNotUse::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_MapMessageType_MsgEntry_DoNotUse_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_MapMessageType_MsgEntry_DoNotUse_messages_2eproto}, {
+ &scc_info_MessageType_messages_2eproto.base,}};
+
+static void InitDefaultsscc_info_MapType_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::test::vereign::grpc::json::pb::_MapType_default_instance_;
+ new (ptr) ::test::vereign::grpc::json::pb::MapType();
+ ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+ }
+ ::test::vereign::grpc::json::pb::MapType::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<11> scc_info_MapType_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 11, 0, InitDefaultsscc_info_MapType_messages_2eproto}, {
+ &scc_info_MapType_Int32KeyEntry_DoNotUse_messages_2eproto.base,
+ &scc_info_MapType_Int64KeyEntry_DoNotUse_messages_2eproto.base,
+ &scc_info_MapType_Uint32KeyEntry_DoNotUse_messages_2eproto.base,
+ &scc_info_MapType_Uint64KeyEntry_DoNotUse_messages_2eproto.base,
+ &scc_info_MapType_Sint32KeyEntry_DoNotUse_messages_2eproto.base,
+ &scc_info_MapType_Sint64KeyEntry_DoNotUse_messages_2eproto.base,
+ &scc_info_MapType_Fixed32KeyEntry_DoNotUse_messages_2eproto.base,
+ &scc_info_MapType_Fixed64KeyEntry_DoNotUse_messages_2eproto.base,
+ &scc_info_MapType_Sfixed32KeyEntry_DoNotUse_messages_2eproto.base,
+ &scc_info_MapType_Sfixed64KeyEntry_DoNotUse_messages_2eproto.base,
+ &scc_info_MapType_StringKeyEntry_DoNotUse_messages_2eproto.base,}};
+
+static void InitDefaultsscc_info_MapType_Fixed32KeyEntry_DoNotUse_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::test::vereign::grpc::json::pb::_MapType_Fixed32KeyEntry_DoNotUse_default_instance_;
+ new (ptr) ::test::vereign::grpc::json::pb::MapType_Fixed32KeyEntry_DoNotUse();
+ }
+ ::test::vereign::grpc::json::pb::MapType_Fixed32KeyEntry_DoNotUse::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_MapType_Fixed32KeyEntry_DoNotUse_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_MapType_Fixed32KeyEntry_DoNotUse_messages_2eproto}, {}};
+
+static void InitDefaultsscc_info_MapType_Fixed64KeyEntry_DoNotUse_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::test::vereign::grpc::json::pb::_MapType_Fixed64KeyEntry_DoNotUse_default_instance_;
+ new (ptr) ::test::vereign::grpc::json::pb::MapType_Fixed64KeyEntry_DoNotUse();
+ }
+ ::test::vereign::grpc::json::pb::MapType_Fixed64KeyEntry_DoNotUse::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_MapType_Fixed64KeyEntry_DoNotUse_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_MapType_Fixed64KeyEntry_DoNotUse_messages_2eproto}, {}};
+
+static void InitDefaultsscc_info_MapType_Int32KeyEntry_DoNotUse_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::test::vereign::grpc::json::pb::_MapType_Int32KeyEntry_DoNotUse_default_instance_;
+ new (ptr) ::test::vereign::grpc::json::pb::MapType_Int32KeyEntry_DoNotUse();
+ }
+ ::test::vereign::grpc::json::pb::MapType_Int32KeyEntry_DoNotUse::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_MapType_Int32KeyEntry_DoNotUse_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_MapType_Int32KeyEntry_DoNotUse_messages_2eproto}, {}};
+
+static void InitDefaultsscc_info_MapType_Int64KeyEntry_DoNotUse_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::test::vereign::grpc::json::pb::_MapType_Int64KeyEntry_DoNotUse_default_instance_;
+ new (ptr) ::test::vereign::grpc::json::pb::MapType_Int64KeyEntry_DoNotUse();
+ }
+ ::test::vereign::grpc::json::pb::MapType_Int64KeyEntry_DoNotUse::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_MapType_Int64KeyEntry_DoNotUse_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_MapType_Int64KeyEntry_DoNotUse_messages_2eproto}, {}};
+
+static void InitDefaultsscc_info_MapType_Sfixed32KeyEntry_DoNotUse_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::test::vereign::grpc::json::pb::_MapType_Sfixed32KeyEntry_DoNotUse_default_instance_;
+ new (ptr) ::test::vereign::grpc::json::pb::MapType_Sfixed32KeyEntry_DoNotUse();
+ }
+ ::test::vereign::grpc::json::pb::MapType_Sfixed32KeyEntry_DoNotUse::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_MapType_Sfixed32KeyEntry_DoNotUse_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_MapType_Sfixed32KeyEntry_DoNotUse_messages_2eproto}, {}};
+
+static void InitDefaultsscc_info_MapType_Sfixed64KeyEntry_DoNotUse_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::test::vereign::grpc::json::pb::_MapType_Sfixed64KeyEntry_DoNotUse_default_instance_;
+ new (ptr) ::test::vereign::grpc::json::pb::MapType_Sfixed64KeyEntry_DoNotUse();
+ }
+ ::test::vereign::grpc::json::pb::MapType_Sfixed64KeyEntry_DoNotUse::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_MapType_Sfixed64KeyEntry_DoNotUse_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_MapType_Sfixed64KeyEntry_DoNotUse_messages_2eproto}, {}};
+
+static void InitDefaultsscc_info_MapType_Sint32KeyEntry_DoNotUse_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::test::vereign::grpc::json::pb::_MapType_Sint32KeyEntry_DoNotUse_default_instance_;
+ new (ptr) ::test::vereign::grpc::json::pb::MapType_Sint32KeyEntry_DoNotUse();
+ }
+ ::test::vereign::grpc::json::pb::MapType_Sint32KeyEntry_DoNotUse::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_MapType_Sint32KeyEntry_DoNotUse_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_MapType_Sint32KeyEntry_DoNotUse_messages_2eproto}, {}};
+
+static void InitDefaultsscc_info_MapType_Sint64KeyEntry_DoNotUse_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::test::vereign::grpc::json::pb::_MapType_Sint64KeyEntry_DoNotUse_default_instance_;
+ new (ptr) ::test::vereign::grpc::json::pb::MapType_Sint64KeyEntry_DoNotUse();
+ }
+ ::test::vereign::grpc::json::pb::MapType_Sint64KeyEntry_DoNotUse::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_MapType_Sint64KeyEntry_DoNotUse_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_MapType_Sint64KeyEntry_DoNotUse_messages_2eproto}, {}};
+
+static void InitDefaultsscc_info_MapType_StringKeyEntry_DoNotUse_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::test::vereign::grpc::json::pb::_MapType_StringKeyEntry_DoNotUse_default_instance_;
+ new (ptr) ::test::vereign::grpc::json::pb::MapType_StringKeyEntry_DoNotUse();
+ }
+ ::test::vereign::grpc::json::pb::MapType_StringKeyEntry_DoNotUse::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_MapType_StringKeyEntry_DoNotUse_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_MapType_StringKeyEntry_DoNotUse_messages_2eproto}, {}};
+
+static void InitDefaultsscc_info_MapType_Uint32KeyEntry_DoNotUse_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::test::vereign::grpc::json::pb::_MapType_Uint32KeyEntry_DoNotUse_default_instance_;
+ new (ptr) ::test::vereign::grpc::json::pb::MapType_Uint32KeyEntry_DoNotUse();
+ }
+ ::test::vereign::grpc::json::pb::MapType_Uint32KeyEntry_DoNotUse::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_MapType_Uint32KeyEntry_DoNotUse_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_MapType_Uint32KeyEntry_DoNotUse_messages_2eproto}, {}};
+
+static void InitDefaultsscc_info_MapType_Uint64KeyEntry_DoNotUse_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::test::vereign::grpc::json::pb::_MapType_Uint64KeyEntry_DoNotUse_default_instance_;
+ new (ptr) ::test::vereign::grpc::json::pb::MapType_Uint64KeyEntry_DoNotUse();
+ }
+ ::test::vereign::grpc::json::pb::MapType_Uint64KeyEntry_DoNotUse::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_MapType_Uint64KeyEntry_DoNotUse_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_MapType_Uint64KeyEntry_DoNotUse_messages_2eproto}, {}};
+
+static void InitDefaultsscc_info_MessageType_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::test::vereign::grpc::json::pb::_MessageType_default_instance_;
+ new (ptr) ::test::vereign::grpc::json::pb::MessageType();
+ ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+ }
+ ::test::vereign::grpc::json::pb::MessageType::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_MessageType_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_MessageType_messages_2eproto}, {
+ &scc_info_Foo_messages_2eproto.base,}};
+
+static void InitDefaultsscc_info_NestedType_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::test::vereign::grpc::json::pb::_NestedType_default_instance_;
+ new (ptr) ::test::vereign::grpc::json::pb::NestedType();
+ ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+ }
+ ::test::vereign::grpc::json::pb::NestedType::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_NestedType_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_NestedType_messages_2eproto}, {
+ &scc_info_NestedType_NestedFoo_messages_2eproto.base,}};
+
+static void InitDefaultsscc_info_NestedType_NestedFoo_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::test::vereign::grpc::json::pb::_NestedType_NestedFoo_default_instance_;
+ new (ptr) ::test::vereign::grpc::json::pb::NestedType_NestedFoo();
+ ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+ }
+ ::test::vereign::grpc::json::pb::NestedType_NestedFoo::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_NestedType_NestedFoo_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_NestedType_NestedFoo_messages_2eproto}, {
+ &scc_info_NestedType_NestedFoo_NestedBar_messages_2eproto.base,}};
+
+static void InitDefaultsscc_info_NestedType_NestedFoo_NestedBar_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::test::vereign::grpc::json::pb::_NestedType_NestedFoo_NestedBar_default_instance_;
+ new (ptr) ::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar();
+ ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+ }
+ ::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_NestedType_NestedFoo_NestedBar_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_NestedType_NestedFoo_NestedBar_messages_2eproto}, {}};
+
+static void InitDefaultsscc_info_OneofValue_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::test::vereign::grpc::json::pb::_OneofValue_default_instance_;
+ new (ptr) ::test::vereign::grpc::json::pb::OneofValue();
+ ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+ }
+ ::test::vereign::grpc::json::pb::OneofValue::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_OneofValue_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_OneofValue_messages_2eproto}, {
+ &scc_info_SimpleStruct_messages_2eproto.base,}};
+
+static void InitDefaultsscc_info_RepeatedEnumType_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::test::vereign::grpc::json::pb::_RepeatedEnumType_default_instance_;
+ new (ptr) ::test::vereign::grpc::json::pb::RepeatedEnumType();
+ ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+ }
+ ::test::vereign::grpc::json::pb::RepeatedEnumType::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RepeatedEnumType_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_RepeatedEnumType_messages_2eproto}, {}};
+
+static void InitDefaultsscc_info_RepeatedTypes_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::test::vereign::grpc::json::pb::_RepeatedTypes_default_instance_;
+ new (ptr) ::test::vereign::grpc::json::pb::RepeatedTypes();
+ ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+ }
+ ::test::vereign::grpc::json::pb::RepeatedTypes::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RepeatedTypes_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_RepeatedTypes_messages_2eproto}, {}};
+
+static void InitDefaultsscc_info_SimpleStruct_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::test::vereign::grpc::json::pb::_SimpleStruct_default_instance_;
+ new (ptr) ::test::vereign::grpc::json::pb::SimpleStruct();
+ ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+ }
+ ::test::vereign::grpc::json::pb::SimpleStruct::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_SimpleStruct_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_SimpleStruct_messages_2eproto}, {}};
+
+static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_messages_2eproto[27];
+static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_messages_2eproto[2];
+static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_messages_2eproto = nullptr;
+
+const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_messages_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::SimpleStruct, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::SimpleStruct, int32_value_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::SimpleStruct, int64_value_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::SimpleStruct, uint32_value_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::SimpleStruct, uint64_value_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::SimpleStruct, sint32_value_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::SimpleStruct, sint64_value_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::SimpleStruct, fixed32_value_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::SimpleStruct, fixed64_value_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::SimpleStruct, sfixed32_value_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::SimpleStruct, sfixed64_value_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::SimpleStruct, float_value_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::SimpleStruct, double_value_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::SimpleStruct, bool_value_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::SimpleStruct, string_value_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::RepeatedTypes, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::RepeatedTypes, int32_arr_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::RepeatedTypes, int64_arr_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::RepeatedTypes, uint32_arr_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::RepeatedTypes, uint64_arr_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::RepeatedTypes, sint32_arr_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::RepeatedTypes, sint64_arr_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::RepeatedTypes, fixed32_arr_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::RepeatedTypes, fixed64_arr_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::RepeatedTypes, sfixed32_arr_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::RepeatedTypes, sfixed64_arr_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::RepeatedTypes, float_arr_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::RepeatedTypes, double_arr_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::RepeatedTypes, bool_arr_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::RepeatedTypes, string_arr_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::Bar, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::Bar, value_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::Foo, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::Foo, value_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::Foo, bar_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MessageType, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MessageType, foo_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MessageType, foo_arr_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Int32KeyEntry_DoNotUse, _has_bits_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Int32KeyEntry_DoNotUse, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Int32KeyEntry_DoNotUse, key_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Int32KeyEntry_DoNotUse, value_),
+ 0,
+ 1,
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Int64KeyEntry_DoNotUse, _has_bits_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Int64KeyEntry_DoNotUse, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Int64KeyEntry_DoNotUse, key_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Int64KeyEntry_DoNotUse, value_),
+ 0,
+ 1,
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Uint32KeyEntry_DoNotUse, _has_bits_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Uint32KeyEntry_DoNotUse, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Uint32KeyEntry_DoNotUse, key_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Uint32KeyEntry_DoNotUse, value_),
+ 0,
+ 1,
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Uint64KeyEntry_DoNotUse, _has_bits_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Uint64KeyEntry_DoNotUse, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Uint64KeyEntry_DoNotUse, key_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Uint64KeyEntry_DoNotUse, value_),
+ 0,
+ 1,
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Sint32KeyEntry_DoNotUse, _has_bits_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Sint32KeyEntry_DoNotUse, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Sint32KeyEntry_DoNotUse, key_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Sint32KeyEntry_DoNotUse, value_),
+ 0,
+ 1,
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Sint64KeyEntry_DoNotUse, _has_bits_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Sint64KeyEntry_DoNotUse, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Sint64KeyEntry_DoNotUse, key_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Sint64KeyEntry_DoNotUse, value_),
+ 0,
+ 1,
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Fixed32KeyEntry_DoNotUse, _has_bits_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Fixed32KeyEntry_DoNotUse, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Fixed32KeyEntry_DoNotUse, key_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Fixed32KeyEntry_DoNotUse, value_),
+ 0,
+ 1,
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Fixed64KeyEntry_DoNotUse, _has_bits_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Fixed64KeyEntry_DoNotUse, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Fixed64KeyEntry_DoNotUse, key_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Fixed64KeyEntry_DoNotUse, value_),
+ 0,
+ 1,
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Sfixed32KeyEntry_DoNotUse, _has_bits_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Sfixed32KeyEntry_DoNotUse, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Sfixed32KeyEntry_DoNotUse, key_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Sfixed32KeyEntry_DoNotUse, value_),
+ 0,
+ 1,
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Sfixed64KeyEntry_DoNotUse, _has_bits_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Sfixed64KeyEntry_DoNotUse, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Sfixed64KeyEntry_DoNotUse, key_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_Sfixed64KeyEntry_DoNotUse, value_),
+ 0,
+ 1,
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_StringKeyEntry_DoNotUse, _has_bits_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_StringKeyEntry_DoNotUse, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_StringKeyEntry_DoNotUse, key_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType_StringKeyEntry_DoNotUse, value_),
+ 0,
+ 1,
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType, int32_key_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType, int64_key_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType, uint32_key_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType, uint64_key_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType, sint32_key_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType, sint64_key_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType, fixed32_key_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType, fixed64_key_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType, sfixed32_key_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType, sfixed64_key_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapType, string_key_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapMessageType_MsgEntry_DoNotUse, _has_bits_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapMessageType_MsgEntry_DoNotUse, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapMessageType_MsgEntry_DoNotUse, key_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapMessageType_MsgEntry_DoNotUse, value_),
+ 0,
+ 1,
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapMessageType, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::MapMessageType, msg_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::BytesType, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::BytesType, bytes_value_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::BytesType, bytes_arr_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::JsonNaming, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::JsonNaming, foo_value_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::JsonNaming, barvalue_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::JsonNaming, bazvalue_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::JsonNaming, qux_value_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::OneofValue, _internal_metadata_),
+ ~0u, // no _extensions_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::OneofValue, _oneof_case_[0]),
+ ~0u, // no _weak_field_map_
+ offsetof(::test::vereign::grpc::json::pb::OneofValueDefaultTypeInternal, string_value_),
+ offsetof(::test::vereign::grpc::json::pb::OneofValueDefaultTypeInternal, struct_value_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::OneofValue, data_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::EnumType, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::EnumType, corpus_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::RepeatedEnumType, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::RepeatedEnumType, corpus_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar, value_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::NestedType_NestedFoo, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::NestedType_NestedFoo, value_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::NestedType_NestedFoo, bar_value_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::NestedType, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::NestedType, value_),
+ PROTOBUF_FIELD_OFFSET(::test::vereign::grpc::json::pb::NestedType, foo_value_),
+};
+static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+ { 0, -1, sizeof(::test::vereign::grpc::json::pb::SimpleStruct)},
+ { 19, -1, sizeof(::test::vereign::grpc::json::pb::RepeatedTypes)},
+ { 38, -1, sizeof(::test::vereign::grpc::json::pb::Bar)},
+ { 44, -1, sizeof(::test::vereign::grpc::json::pb::Foo)},
+ { 51, -1, sizeof(::test::vereign::grpc::json::pb::MessageType)},
+ { 58, 65, sizeof(::test::vereign::grpc::json::pb::MapType_Int32KeyEntry_DoNotUse)},
+ { 67, 74, sizeof(::test::vereign::grpc::json::pb::MapType_Int64KeyEntry_DoNotUse)},
+ { 76, 83, sizeof(::test::vereign::grpc::json::pb::MapType_Uint32KeyEntry_DoNotUse)},
+ { 85, 92, sizeof(::test::vereign::grpc::json::pb::MapType_Uint64KeyEntry_DoNotUse)},
+ { 94, 101, sizeof(::test::vereign::grpc::json::pb::MapType_Sint32KeyEntry_DoNotUse)},
+ { 103, 110, sizeof(::test::vereign::grpc::json::pb::MapType_Sint64KeyEntry_DoNotUse)},
+ { 112, 119, sizeof(::test::vereign::grpc::json::pb::MapType_Fixed32KeyEntry_DoNotUse)},
+ { 121, 128, sizeof(::test::vereign::grpc::json::pb::MapType_Fixed64KeyEntry_DoNotUse)},
+ { 130, 137, sizeof(::test::vereign::grpc::json::pb::MapType_Sfixed32KeyEntry_DoNotUse)},
+ { 139, 146, sizeof(::test::vereign::grpc::json::pb::MapType_Sfixed64KeyEntry_DoNotUse)},
+ { 148, 155, sizeof(::test::vereign::grpc::json::pb::MapType_StringKeyEntry_DoNotUse)},
+ { 157, -1, sizeof(::test::vereign::grpc::json::pb::MapType)},
+ { 173, 180, sizeof(::test::vereign::grpc::json::pb::MapMessageType_MsgEntry_DoNotUse)},
+ { 182, -1, sizeof(::test::vereign::grpc::json::pb::MapMessageType)},
+ { 188, -1, sizeof(::test::vereign::grpc::json::pb::BytesType)},
+ { 195, -1, sizeof(::test::vereign::grpc::json::pb::JsonNaming)},
+ { 204, -1, sizeof(::test::vereign::grpc::json::pb::OneofValue)},
+ { 212, -1, sizeof(::test::vereign::grpc::json::pb::EnumType)},
+ { 218, -1, sizeof(::test::vereign::grpc::json::pb::RepeatedEnumType)},
+ { 224, -1, sizeof(::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar)},
+ { 230, -1, sizeof(::test::vereign::grpc::json::pb::NestedType_NestedFoo)},
+ { 237, -1, sizeof(::test::vereign::grpc::json::pb::NestedType)},
+};
+
+static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::test::vereign::grpc::json::pb::_SimpleStruct_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::test::vereign::grpc::json::pb::_RepeatedTypes_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::test::vereign::grpc::json::pb::_Bar_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::test::vereign::grpc::json::pb::_Foo_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::test::vereign::grpc::json::pb::_MessageType_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::test::vereign::grpc::json::pb::_MapType_Int32KeyEntry_DoNotUse_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::test::vereign::grpc::json::pb::_MapType_Int64KeyEntry_DoNotUse_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::test::vereign::grpc::json::pb::_MapType_Uint32KeyEntry_DoNotUse_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::test::vereign::grpc::json::pb::_MapType_Uint64KeyEntry_DoNotUse_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::test::vereign::grpc::json::pb::_MapType_Sint32KeyEntry_DoNotUse_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::test::vereign::grpc::json::pb::_MapType_Sint64KeyEntry_DoNotUse_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::test::vereign::grpc::json::pb::_MapType_Fixed32KeyEntry_DoNotUse_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::test::vereign::grpc::json::pb::_MapType_Fixed64KeyEntry_DoNotUse_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::test::vereign::grpc::json::pb::_MapType_Sfixed32KeyEntry_DoNotUse_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::test::vereign::grpc::json::pb::_MapType_Sfixed64KeyEntry_DoNotUse_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::test::vereign::grpc::json::pb::_MapType_StringKeyEntry_DoNotUse_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::test::vereign::grpc::json::pb::_MapType_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::test::vereign::grpc::json::pb::_MapMessageType_MsgEntry_DoNotUse_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::test::vereign::grpc::json::pb::_MapMessageType_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::test::vereign::grpc::json::pb::_BytesType_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::test::vereign::grpc::json::pb::_JsonNaming_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::test::vereign::grpc::json::pb::_OneofValue_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::test::vereign::grpc::json::pb::_EnumType_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::test::vereign::grpc::json::pb::_RepeatedEnumType_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::test::vereign::grpc::json::pb::_NestedType_NestedFoo_NestedBar_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::test::vereign::grpc::json::pb::_NestedType_NestedFoo_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::test::vereign::grpc::json::pb::_NestedType_default_instance_),
+};
+
+const char descriptor_table_protodef_messages_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
+ "\n\016messages.proto\022\031test.vereign.grpc.json"
+ ".pb\"\303\002\n\014SimpleStruct\022\023\n\013int32_value\030\001 \001("
+ "\005\022\023\n\013int64_value\030\002 \001(\003\022\024\n\014uint32_value\030\003"
+ " \001(\r\022\024\n\014uint64_value\030\004 \001(\004\022\024\n\014sint32_val"
+ "ue\030\005 \001(\021\022\024\n\014sint64_value\030\006 \001(\022\022\025\n\rfixed3"
+ "2_value\030\007 \001(\007\022\025\n\rfixed64_value\030\010 \001(\006\022\026\n\016"
+ "sfixed32_value\030\t \001(\017\022\026\n\016sfixed64_value\030\n"
+ " \001(\020\022\023\n\013float_value\030\013 \001(\002\022\024\n\014double_valu"
+ "e\030\014 \001(\001\022\022\n\nbool_value\030\r \001(\010\022\024\n\014string_va"
+ "lue\030\016 \001(\t\"\250\002\n\rRepeatedTypes\022\021\n\tint32_arr"
+ "\030\001 \003(\005\022\021\n\tint64_arr\030\002 \003(\003\022\022\n\nuint32_arr\030"
+ "\003 \003(\r\022\022\n\nuint64_arr\030\004 \003(\004\022\022\n\nsint32_arr\030"
+ "\005 \003(\021\022\022\n\nsint64_arr\030\006 \003(\022\022\023\n\013fixed32_arr"
+ "\030\007 \003(\007\022\023\n\013fixed64_arr\030\010 \003(\006\022\024\n\014sfixed32_"
+ "arr\030\t \003(\017\022\024\n\014sfixed64_arr\030\n \003(\020\022\021\n\tfloat"
+ "_arr\030\013 \003(\002\022\022\n\ndouble_arr\030\014 \003(\001\022\020\n\010bool_a"
+ "rr\030\r \003(\010\022\022\n\nstring_arr\030\016 \003(\t\"\024\n\003Bar\022\r\n\005v"
+ "alue\030\002 \001(\t\"A\n\003Foo\022\r\n\005value\030\001 \001(\t\022+\n\003bar\030"
+ "\002 \001(\0132\036.test.vereign.grpc.json.pb.Bar\"k\n"
+ "\013MessageType\022+\n\003foo\030\001 \001(\0132\036.test.vereign"
+ ".grpc.json.pb.Foo\022/\n\007foo_arr\030\002 \003(\0132\036.tes"
+ "t.vereign.grpc.json.pb.Foo\"\310\n\n\007MapType\022C"
+ "\n\tint32_key\030\001 \003(\01320.test.vereign.grpc.js"
+ "on.pb.MapType.Int32KeyEntry\022C\n\tint64_key"
+ "\030\002 \003(\01320.test.vereign.grpc.json.pb.MapTy"
+ "pe.Int64KeyEntry\022E\n\nuint32_key\030\003 \003(\01321.t"
+ "est.vereign.grpc.json.pb.MapType.Uint32K"
+ "eyEntry\022E\n\nuint64_key\030\004 \003(\01321.test.verei"
+ "gn.grpc.json.pb.MapType.Uint64KeyEntry\022E"
+ "\n\nsint32_key\030\005 \003(\01321.test.vereign.grpc.j"
+ "son.pb.MapType.Sint32KeyEntry\022E\n\nsint64_"
+ "key\030\006 \003(\01321.test.vereign.grpc.json.pb.Ma"
+ "pType.Sint64KeyEntry\022G\n\013fixed32_key\030\007 \003("
+ "\01322.test.vereign.grpc.json.pb.MapType.Fi"
+ "xed32KeyEntry\022G\n\013fixed64_key\030\010 \003(\01322.tes"
+ "t.vereign.grpc.json.pb.MapType.Fixed64Ke"
+ "yEntry\022I\n\014sfixed32_key\030\t \003(\01323.test.vere"
+ "ign.grpc.json.pb.MapType.Sfixed32KeyEntr"
+ "y\022I\n\014sfixed64_key\030\n \003(\01323.test.vereign.g"
+ "rpc.json.pb.MapType.Sfixed64KeyEntry\022E\n\n"
+ "string_key\030\013 \003(\01321.test.vereign.grpc.jso"
+ "n.pb.MapType.StringKeyEntry\032/\n\rInt32KeyE"
+ "ntry\022\013\n\003key\030\001 \001(\005\022\r\n\005value\030\002 \001(\t:\0028\001\032/\n\r"
+ "Int64KeyEntry\022\013\n\003key\030\001 \001(\003\022\r\n\005value\030\002 \001("
+ "\t:\0028\001\0320\n\016Uint32KeyEntry\022\013\n\003key\030\001 \001(\r\022\r\n\005"
+ "value\030\002 \001(\t:\0028\001\0320\n\016Uint64KeyEntry\022\013\n\003key"
+ "\030\001 \001(\004\022\r\n\005value\030\002 \001(\t:\0028\001\0320\n\016Sint32KeyEn"
+ "try\022\013\n\003key\030\001 \001(\021\022\r\n\005value\030\002 \001(\t:\0028\001\0320\n\016S"
+ "int64KeyEntry\022\013\n\003key\030\001 \001(\022\022\r\n\005value\030\002 \001("
+ "\t:\0028\001\0321\n\017Fixed32KeyEntry\022\013\n\003key\030\001 \001(\007\022\r\n"
+ "\005value\030\002 \001(\t:\0028\001\0321\n\017Fixed64KeyEntry\022\013\n\003k"
+ "ey\030\001 \001(\006\022\r\n\005value\030\002 \001(\t:\0028\001\0322\n\020Sfixed32K"
+ "eyEntry\022\013\n\003key\030\001 \001(\017\022\r\n\005value\030\002 \001(\t:\0028\001\032"
+ "2\n\020Sfixed64KeyEntry\022\013\n\003key\030\001 \001(\020\022\r\n\005valu"
+ "e\030\002 \001(\t:\0028\001\0320\n\016StringKeyEntry\022\013\n\003key\030\001 \001"
+ "(\t\022\r\n\005value\030\002 \001(\t:\0028\001\"\245\001\n\016MapMessageType"
+ "\022\?\n\003msg\030\001 \003(\01322.test.vereign.grpc.json.p"
+ "b.MapMessageType.MsgEntry\032R\n\010MsgEntry\022\013\n"
+ "\003key\030\001 \001(\t\0225\n\005value\030\002 \001(\0132&.test.vereign"
+ ".grpc.json.pb.MessageType:\0028\001\"3\n\tBytesTy"
+ "pe\022\023\n\013bytes_value\030\001 \001(\014\022\021\n\tbytes_arr\030\002 \003"
+ "(\014\"V\n\nJsonNaming\022\021\n\tfoo_value\030\001 \001(\005\022\020\n\010b"
+ "arValue\030\002 \001(\005\022\020\n\010BazValue\030\003 \001(\005\022\021\n\tquX_V"
+ "alue\030\004 \001(\005\"m\n\nOneofValue\022\026\n\014string_value"
+ "\030\001 \001(\tH\000\022\?\n\014struct_value\030\002 \001(\0132\'.test.ve"
+ "reign.grpc.json.pb.SimpleStructH\000B\006\n\004dat"
+ "a\"\242\001\n\010EnumType\022:\n\006corpus\030\004 \001(\0162*.test.ve"
+ "reign.grpc.json.pb.EnumType.Corpus\"Z\n\006Co"
+ "rpus\022\r\n\tUNIVERSAL\020\000\022\007\n\003WEB\020\001\022\n\n\006IMAGES\020\002"
+ "\022\t\n\005LOCAL\020\003\022\010\n\004NEWS\020\004\022\014\n\010PRODUCTS\020\005\022\t\n\005V"
+ "IDEO\020\006\"\262\001\n\020RepeatedEnumType\022B\n\006corpus\030\004 "
+ "\003(\01622.test.vereign.grpc.json.pb.Repeated"
+ "EnumType.Corpus\"Z\n\006Corpus\022\r\n\tUNIVERSAL\020\000"
+ "\022\007\n\003WEB\020\001\022\n\n\006IMAGES\020\002\022\t\n\005LOCAL\020\003\022\010\n\004NEWS"
+ "\020\004\022\014\n\010PRODUCTS\020\005\022\t\n\005VIDEO\020\006\"\346\001\n\nNestedTy"
+ "pe\022\r\n\005value\030\001 \001(\t\022B\n\tfoo_value\030\002 \001(\0132/.t"
+ "est.vereign.grpc.json.pb.NestedType.Nest"
+ "edFoo\032\204\001\n\tNestedFoo\022\r\n\005value\030\001 \001(\t\022L\n\tba"
+ "r_value\030\002 \001(\01329.test.vereign.grpc.json.p"
+ "b.NestedType.NestedFoo.NestedBar\032\032\n\tNest"
+ "edBar\022\r\n\005Value\030\001 \001(\tb\006proto3"
+ ;
+static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_messages_2eproto_deps[1] = {
+};
+static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_messages_2eproto_sccs[27] = {
+ &scc_info_Bar_messages_2eproto.base,
+ &scc_info_BytesType_messages_2eproto.base,
+ &scc_info_EnumType_messages_2eproto.base,
+ &scc_info_Foo_messages_2eproto.base,
+ &scc_info_JsonNaming_messages_2eproto.base,
+ &scc_info_MapMessageType_messages_2eproto.base,
+ &scc_info_MapMessageType_MsgEntry_DoNotUse_messages_2eproto.base,
+ &scc_info_MapType_messages_2eproto.base,
+ &scc_info_MapType_Fixed32KeyEntry_DoNotUse_messages_2eproto.base,
+ &scc_info_MapType_Fixed64KeyEntry_DoNotUse_messages_2eproto.base,
+ &scc_info_MapType_Int32KeyEntry_DoNotUse_messages_2eproto.base,
+ &scc_info_MapType_Int64KeyEntry_DoNotUse_messages_2eproto.base,
+ &scc_info_MapType_Sfixed32KeyEntry_DoNotUse_messages_2eproto.base,
+ &scc_info_MapType_Sfixed64KeyEntry_DoNotUse_messages_2eproto.base,
+ &scc_info_MapType_Sint32KeyEntry_DoNotUse_messages_2eproto.base,
+ &scc_info_MapType_Sint64KeyEntry_DoNotUse_messages_2eproto.base,
+ &scc_info_MapType_StringKeyEntry_DoNotUse_messages_2eproto.base,
+ &scc_info_MapType_Uint32KeyEntry_DoNotUse_messages_2eproto.base,
+ &scc_info_MapType_Uint64KeyEntry_DoNotUse_messages_2eproto.base,
+ &scc_info_MessageType_messages_2eproto.base,
+ &scc_info_NestedType_messages_2eproto.base,
+ &scc_info_NestedType_NestedFoo_messages_2eproto.base,
+ &scc_info_NestedType_NestedFoo_NestedBar_messages_2eproto.base,
+ &scc_info_OneofValue_messages_2eproto.base,
+ &scc_info_RepeatedEnumType_messages_2eproto.base,
+ &scc_info_RepeatedTypes_messages_2eproto.base,
+ &scc_info_SimpleStruct_messages_2eproto.base,
+};
+static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_messages_2eproto_once;
+static bool descriptor_table_messages_2eproto_initialized = false;
+const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_messages_2eproto = {
+ &descriptor_table_messages_2eproto_initialized, descriptor_table_protodef_messages_2eproto, "messages.proto", 3228,
+ &descriptor_table_messages_2eproto_once, descriptor_table_messages_2eproto_sccs, descriptor_table_messages_2eproto_deps, 27, 0,
+ schemas, file_default_instances, TableStruct_messages_2eproto::offsets,
+ file_level_metadata_messages_2eproto, 27, file_level_enum_descriptors_messages_2eproto, file_level_service_descriptors_messages_2eproto,
+};
+
+// Force running AddDescriptors() at dynamic initialization time.
+static bool dynamic_init_dummy_messages_2eproto = ( ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_messages_2eproto), true);
+namespace test {
+namespace vereign {
+namespace grpc {
+namespace json {
+namespace pb {
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* EnumType_Corpus_descriptor() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_messages_2eproto);
+ return file_level_enum_descriptors_messages_2eproto[0];
+}
+bool EnumType_Corpus_IsValid(int value) {
+ switch (value) {
+ case 0:
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ case 5:
+ case 6:
+ return true;
+ default:
+ return false;
+ }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
+constexpr EnumType_Corpus EnumType::UNIVERSAL;
+constexpr EnumType_Corpus EnumType::WEB;
+constexpr EnumType_Corpus EnumType::IMAGES;
+constexpr EnumType_Corpus EnumType::LOCAL;
+constexpr EnumType_Corpus EnumType::NEWS;
+constexpr EnumType_Corpus EnumType::PRODUCTS;
+constexpr EnumType_Corpus EnumType::VIDEO;
+constexpr EnumType_Corpus EnumType::Corpus_MIN;
+constexpr EnumType_Corpus EnumType::Corpus_MAX;
+constexpr int EnumType::Corpus_ARRAYSIZE;
+#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* RepeatedEnumType_Corpus_descriptor() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_messages_2eproto);
+ return file_level_enum_descriptors_messages_2eproto[1];
+}
+bool RepeatedEnumType_Corpus_IsValid(int value) {
+ switch (value) {
+ case 0:
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ case 5:
+ case 6:
+ return true;
+ default:
+ return false;
+ }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
+constexpr RepeatedEnumType_Corpus RepeatedEnumType::UNIVERSAL;
+constexpr RepeatedEnumType_Corpus RepeatedEnumType::WEB;
+constexpr RepeatedEnumType_Corpus RepeatedEnumType::IMAGES;
+constexpr RepeatedEnumType_Corpus RepeatedEnumType::LOCAL;
+constexpr RepeatedEnumType_Corpus RepeatedEnumType::NEWS;
+constexpr RepeatedEnumType_Corpus RepeatedEnumType::PRODUCTS;
+constexpr RepeatedEnumType_Corpus RepeatedEnumType::VIDEO;
+constexpr RepeatedEnumType_Corpus RepeatedEnumType::Corpus_MIN;
+constexpr RepeatedEnumType_Corpus RepeatedEnumType::Corpus_MAX;
+constexpr int RepeatedEnumType::Corpus_ARRAYSIZE;
+#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
+
+// ===================================================================
+
+void SimpleStruct::InitAsDefaultInstance() {
+}
+class SimpleStruct::_Internal {
+ public:
+};
+
+SimpleStruct::SimpleStruct()
+ : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+ SharedCtor();
+ // @@protoc_insertion_point(constructor:test.vereign.grpc.json.pb.SimpleStruct)
+}
+SimpleStruct::SimpleStruct(const SimpleStruct& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message(),
+ _internal_metadata_(nullptr) {
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ string_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_string_value().empty()) {
+ string_value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.string_value_);
+ }
+ ::memcpy(&int64_value_, &from.int64_value_,
+ static_cast<size_t>(reinterpret_cast<char*>(&bool_value_) -
+ reinterpret_cast<char*>(&int64_value_)) + sizeof(bool_value_));
+ // @@protoc_insertion_point(copy_constructor:test.vereign.grpc.json.pb.SimpleStruct)
+}
+
+void SimpleStruct::SharedCtor() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SimpleStruct_messages_2eproto.base);
+ string_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ ::memset(&int64_value_, 0, static_cast<size_t>(
+ reinterpret_cast<char*>(&bool_value_) -
+ reinterpret_cast<char*>(&int64_value_)) + sizeof(bool_value_));
+}
+
+SimpleStruct::~SimpleStruct() {
+ // @@protoc_insertion_point(destructor:test.vereign.grpc.json.pb.SimpleStruct)
+ SharedDtor();
+}
+
+void SimpleStruct::SharedDtor() {
+ string_value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void SimpleStruct::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+const SimpleStruct& SimpleStruct::default_instance() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_SimpleStruct_messages_2eproto.base);
+ return *internal_default_instance();
+}
+
+
+void SimpleStruct::Clear() {
+// @@protoc_insertion_point(message_clear_start:test.vereign.grpc.json.pb.SimpleStruct)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ string_value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ ::memset(&int64_value_, 0, static_cast<size_t>(
+ reinterpret_cast<char*>(&bool_value_) -
+ reinterpret_cast<char*>(&int64_value_)) + sizeof(bool_value_));
+ _internal_metadata_.Clear();
+}
+
+const char* SimpleStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ CHK_(ptr);
+ switch (tag >> 3) {
+ // int32 int32_value = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
+ int32_value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // int64 int64_value = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
+ int64_value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // uint32 uint32_value = 3;
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
+ uint32_value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // uint64 uint64_value = 4;
+ case 4:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
+ uint64_value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // sint32 sint32_value = 5;
+ case 5:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
+ sint32_value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarintZigZag32(&ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // sint64 sint64_value = 6;
+ case 6:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
+ sint64_value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarintZigZag64(&ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // fixed32 fixed32_value = 7;
+ case 7:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 61)) {
+ fixed32_value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint32>(ptr);
+ ptr += sizeof(::PROTOBUF_NAMESPACE_ID::uint32);
+ } else goto handle_unusual;
+ continue;
+ // fixed64 fixed64_value = 8;
+ case 8:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 65)) {
+ fixed64_value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr);
+ ptr += sizeof(::PROTOBUF_NAMESPACE_ID::uint64);
+ } else goto handle_unusual;
+ continue;
+ // sfixed32 sfixed32_value = 9;
+ case 9:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 77)) {
+ sfixed32_value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::int32>(ptr);
+ ptr += sizeof(::PROTOBUF_NAMESPACE_ID::int32);
+ } else goto handle_unusual;
+ continue;
+ // sfixed64 sfixed64_value = 10;
+ case 10:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 81)) {
+ sfixed64_value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::int64>(ptr);
+ ptr += sizeof(::PROTOBUF_NAMESPACE_ID::int64);
+ } else goto handle_unusual;
+ continue;
+ // float float_value = 11;
+ case 11:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 93)) {
+ float_value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else goto handle_unusual;
+ continue;
+ // double double_value = 12;
+ case 12:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 97)) {
+ double_value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
+ ptr += sizeof(double);
+ } else goto handle_unusual;
+ continue;
+ // bool bool_value = 13;
+ case 13:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 104)) {
+ bool_value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // string string_value = 14;
+ case 14:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) {
+ auto str = _internal_mutable_string_value();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "test.vereign.grpc.json.pb.SimpleStruct.string_value"));
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag & 7) == 4 || tag == 0) {
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* SimpleStruct::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:test.vereign.grpc.json.pb.SimpleStruct)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // int32 int32_value = 1;
+ if (this->int32_value() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_int32_value(), target);
+ }
+
+ // int64 int64_value = 2;
+ if (this->int64_value() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->_internal_int64_value(), target);
+ }
+
+ // uint32 uint32_value = 3;
+ if (this->uint32_value() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_uint32_value(), target);
+ }
+
+ // uint64 uint64_value = 4;
+ if (this->uint64_value() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(4, this->_internal_uint64_value(), target);
+ }
+
+ // sint32 sint32_value = 5;
+ if (this->sint32_value() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteSInt32ToArray(5, this->_internal_sint32_value(), target);
+ }
+
+ // sint64 sint64_value = 6;
+ if (this->sint64_value() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteSInt64ToArray(6, this->_internal_sint64_value(), target);
+ }
+
+ // fixed32 fixed32_value = 7;
+ if (this->fixed32_value() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFixed32ToArray(7, this->_internal_fixed32_value(), target);
+ }
+
+ // fixed64 fixed64_value = 8;
+ if (this->fixed64_value() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFixed64ToArray(8, this->_internal_fixed64_value(), target);
+ }
+
+ // sfixed32 sfixed32_value = 9;
+ if (this->sfixed32_value() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteSFixed32ToArray(9, this->_internal_sfixed32_value(), target);
+ }
+
+ // sfixed64 sfixed64_value = 10;
+ if (this->sfixed64_value() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteSFixed64ToArray(10, this->_internal_sfixed64_value(), target);
+ }
+
+ // float float_value = 11;
+ if (!(this->float_value() <= 0 && this->float_value() >= 0)) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(11, this->_internal_float_value(), target);
+ }
+
+ // double double_value = 12;
+ if (!(this->double_value() <= 0 && this->double_value() >= 0)) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(12, this->_internal_double_value(), target);
+ }
+
+ // bool bool_value = 13;
+ if (this->bool_value() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(13, this->_internal_bool_value(), target);
+ }
+
+ // string string_value = 14;
+ if (this->string_value().size() > 0) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ this->_internal_string_value().data(), static_cast<int>(this->_internal_string_value().length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "test.vereign.grpc.json.pb.SimpleStruct.string_value");
+ target = stream->WriteStringMaybeAliased(
+ 14, this->_internal_string_value(), target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields(), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:test.vereign.grpc.json.pb.SimpleStruct)
+ return target;
+}
+
+size_t SimpleStruct::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:test.vereign.grpc.json.pb.SimpleStruct)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // string string_value = 14;
+ if (this->string_value().size() > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ this->_internal_string_value());
+ }
+
+ // int64 int64_value = 2;
+ if (this->int64_value() != 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
+ this->_internal_int64_value());
+ }
+
+ // int32 int32_value = 1;
+ if (this->int32_value() != 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+ this->_internal_int32_value());
+ }
+
+ // uint32 uint32_value = 3;
+ if (this->uint32_value() != 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
+ this->_internal_uint32_value());
+ }
+
+ // uint64 uint64_value = 4;
+ if (this->uint64_value() != 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
+ this->_internal_uint64_value());
+ }
+
+ // sint64 sint64_value = 6;
+ if (this->sint64_value() != 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SInt64Size(
+ this->_internal_sint64_value());
+ }
+
+ // sint32 sint32_value = 5;
+ if (this->sint32_value() != 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SInt32Size(
+ this->_internal_sint32_value());
+ }
+
+ // fixed32 fixed32_value = 7;
+ if (this->fixed32_value() != 0) {
+ total_size += 1 + 4;
+ }
+
+ // fixed64 fixed64_value = 8;
+ if (this->fixed64_value() != 0) {
+ total_size += 1 + 8;
+ }
+
+ // sfixed64 sfixed64_value = 10;
+ if (this->sfixed64_value() != 0) {
+ total_size += 1 + 8;
+ }
+
+ // sfixed32 sfixed32_value = 9;
+ if (this->sfixed32_value() != 0) {
+ total_size += 1 + 4;
+ }
+
+ // float float_value = 11;
+ if (!(this->float_value() <= 0 && this->float_value() >= 0)) {
+ total_size += 1 + 4;
+ }
+
+ // double double_value = 12;
+ if (!(this->double_value() <= 0 && this->double_value() >= 0)) {
+ total_size += 1 + 8;
+ }
+
+ // bool bool_value = 13;
+ if (this->bool_value() != 0) {
+ total_size += 1 + 1;
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+ _internal_metadata_, total_size, &_cached_size_);
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void SimpleStruct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:test.vereign.grpc.json.pb.SimpleStruct)
+ GOOGLE_DCHECK_NE(&from, this);
+ const SimpleStruct* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<SimpleStruct>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:test.vereign.grpc.json.pb.SimpleStruct)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:test.vereign.grpc.json.pb.SimpleStruct)
+ MergeFrom(*source);
+ }
+}
+
+void SimpleStruct::MergeFrom(const SimpleStruct& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:test.vereign.grpc.json.pb.SimpleStruct)
+ GOOGLE_DCHECK_NE(&from, this);
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from.string_value().size() > 0) {
+
+ string_value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.string_value_);
+ }
+ if (from.int64_value() != 0) {
+ _internal_set_int64_value(from._internal_int64_value());
+ }
+ if (from.int32_value() != 0) {
+ _internal_set_int32_value(from._internal_int32_value());
+ }
+ if (from.uint32_value() != 0) {
+ _internal_set_uint32_value(from._internal_uint32_value());
+ }
+ if (from.uint64_value() != 0) {
+ _internal_set_uint64_value(from._internal_uint64_value());
+ }
+ if (from.sint64_value() != 0) {
+ _internal_set_sint64_value(from._internal_sint64_value());
+ }
+ if (from.sint32_value() != 0) {
+ _internal_set_sint32_value(from._internal_sint32_value());
+ }
+ if (from.fixed32_value() != 0) {
+ _internal_set_fixed32_value(from._internal_fixed32_value());
+ }
+ if (from.fixed64_value() != 0) {
+ _internal_set_fixed64_value(from._internal_fixed64_value());
+ }
+ if (from.sfixed64_value() != 0) {
+ _internal_set_sfixed64_value(from._internal_sfixed64_value());
+ }
+ if (from.sfixed32_value() != 0) {
+ _internal_set_sfixed32_value(from._internal_sfixed32_value());
+ }
+ if (!(from.float_value() <= 0 && from.float_value() >= 0)) {
+ _internal_set_float_value(from._internal_float_value());
+ }
+ if (!(from.double_value() <= 0 && from.double_value() >= 0)) {
+ _internal_set_double_value(from._internal_double_value());
+ }
+ if (from.bool_value() != 0) {
+ _internal_set_bool_value(from._internal_bool_value());
+ }
+}
+
+void SimpleStruct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:test.vereign.grpc.json.pb.SimpleStruct)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void SimpleStruct::CopyFrom(const SimpleStruct& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:test.vereign.grpc.json.pb.SimpleStruct)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool SimpleStruct::IsInitialized() const {
+ return true;
+}
+
+void SimpleStruct::InternalSwap(SimpleStruct* other) {
+ using std::swap;
+ _internal_metadata_.Swap(&other->_internal_metadata_);
+ string_value_.Swap(&other->string_value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ GetArenaNoVirtual());
+ swap(int64_value_, other->int64_value_);
+ swap(int32_value_, other->int32_value_);
+ swap(uint32_value_, other->uint32_value_);
+ swap(uint64_value_, other->uint64_value_);
+ swap(sint64_value_, other->sint64_value_);
+ swap(sint32_value_, other->sint32_value_);
+ swap(fixed32_value_, other->fixed32_value_);
+ swap(fixed64_value_, other->fixed64_value_);
+ swap(sfixed64_value_, other->sfixed64_value_);
+ swap(sfixed32_value_, other->sfixed32_value_);
+ swap(float_value_, other->float_value_);
+ swap(double_value_, other->double_value_);
+ swap(bool_value_, other->bool_value_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SimpleStruct::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void RepeatedTypes::InitAsDefaultInstance() {
+}
+class RepeatedTypes::_Internal {
+ public:
+};
+
+RepeatedTypes::RepeatedTypes()
+ : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+ SharedCtor();
+ // @@protoc_insertion_point(constructor:test.vereign.grpc.json.pb.RepeatedTypes)
+}
+RepeatedTypes::RepeatedTypes(const RepeatedTypes& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message(),
+ _internal_metadata_(nullptr),
+ int32_arr_(from.int32_arr_),
+ int64_arr_(from.int64_arr_),
+ uint32_arr_(from.uint32_arr_),
+ uint64_arr_(from.uint64_arr_),
+ sint32_arr_(from.sint32_arr_),
+ sint64_arr_(from.sint64_arr_),
+ fixed32_arr_(from.fixed32_arr_),
+ fixed64_arr_(from.fixed64_arr_),
+ sfixed32_arr_(from.sfixed32_arr_),
+ sfixed64_arr_(from.sfixed64_arr_),
+ float_arr_(from.float_arr_),
+ double_arr_(from.double_arr_),
+ bool_arr_(from.bool_arr_),
+ string_arr_(from.string_arr_) {
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ // @@protoc_insertion_point(copy_constructor:test.vereign.grpc.json.pb.RepeatedTypes)
+}
+
+void RepeatedTypes::SharedCtor() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_RepeatedTypes_messages_2eproto.base);
+}
+
+RepeatedTypes::~RepeatedTypes() {
+ // @@protoc_insertion_point(destructor:test.vereign.grpc.json.pb.RepeatedTypes)
+ SharedDtor();
+}
+
+void RepeatedTypes::SharedDtor() {
+}
+
+void RepeatedTypes::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+const RepeatedTypes& RepeatedTypes::default_instance() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_RepeatedTypes_messages_2eproto.base);
+ return *internal_default_instance();
+}
+
+
+void RepeatedTypes::Clear() {
+// @@protoc_insertion_point(message_clear_start:test.vereign.grpc.json.pb.RepeatedTypes)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ int32_arr_.Clear();
+ int64_arr_.Clear();
+ uint32_arr_.Clear();
+ uint64_arr_.Clear();
+ sint32_arr_.Clear();
+ sint64_arr_.Clear();
+ fixed32_arr_.Clear();
+ fixed64_arr_.Clear();
+ sfixed32_arr_.Clear();
+ sfixed64_arr_.Clear();
+ float_arr_.Clear();
+ double_arr_.Clear();
+ bool_arr_.Clear();
+ string_arr_.Clear();
+ _internal_metadata_.Clear();
+}
+
+const char* RepeatedTypes::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ CHK_(ptr);
+ switch (tag >> 3) {
+ // repeated int32 int32_arr = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_int32_arr(), ptr, ctx);
+ CHK_(ptr);
+ } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8) {
+ _internal_add_int32_arr(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // repeated int64 int64_arr = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_int64_arr(), ptr, ctx);
+ CHK_(ptr);
+ } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16) {
+ _internal_add_int64_arr(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // repeated uint32 uint32_arr = 3;
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_uint32_arr(), ptr, ctx);
+ CHK_(ptr);
+ } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24) {
+ _internal_add_uint32_arr(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // repeated uint64 uint64_arr = 4;
+ case 4:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt64Parser(_internal_mutable_uint64_arr(), ptr, ctx);
+ CHK_(ptr);
+ } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32) {
+ _internal_add_uint64_arr(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // repeated sint32 sint32_arr = 5;
+ case 5:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedSInt32Parser(_internal_mutable_sint32_arr(), ptr, ctx);
+ CHK_(ptr);
+ } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40) {
+ _internal_add_sint32_arr(::PROTOBUF_NAMESPACE_ID::internal::ReadVarintZigZag32(&ptr));
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // repeated sint64 sint64_arr = 6;
+ case 6:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedSInt64Parser(_internal_mutable_sint64_arr(), ptr, ctx);
+ CHK_(ptr);
+ } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48) {
+ _internal_add_sint64_arr(::PROTOBUF_NAMESPACE_ID::internal::ReadVarintZigZag64(&ptr));
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // repeated fixed32 fixed32_arr = 7;
+ case 7:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFixed32Parser(_internal_mutable_fixed32_arr(), ptr, ctx);
+ CHK_(ptr);
+ } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 61) {
+ _internal_add_fixed32_arr(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint32>(ptr));
+ ptr += sizeof(::PROTOBUF_NAMESPACE_ID::uint32);
+ } else goto handle_unusual;
+ continue;
+ // repeated fixed64 fixed64_arr = 8;
+ case 8:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFixed64Parser(_internal_mutable_fixed64_arr(), ptr, ctx);
+ CHK_(ptr);
+ } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 65) {
+ _internal_add_fixed64_arr(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr));
+ ptr += sizeof(::PROTOBUF_NAMESPACE_ID::uint64);
+ } else goto handle_unusual;
+ continue;
+ // repeated sfixed32 sfixed32_arr = 9;
+ case 9:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedSFixed32Parser(_internal_mutable_sfixed32_arr(), ptr, ctx);
+ CHK_(ptr);
+ } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 77) {
+ _internal_add_sfixed32_arr(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::int32>(ptr));
+ ptr += sizeof(::PROTOBUF_NAMESPACE_ID::int32);
+ } else goto handle_unusual;
+ continue;
+ // repeated sfixed64 sfixed64_arr = 10;
+ case 10:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) {
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedSFixed64Parser(_internal_mutable_sfixed64_arr(), ptr, ctx);
+ CHK_(ptr);
+ } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 81) {
+ _internal_add_sfixed64_arr(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::int64>(ptr));
+ ptr += sizeof(::PROTOBUF_NAMESPACE_ID::int64);
+ } else goto handle_unusual;
+ continue;
+ // repeated float float_arr = 11;
+ case 11:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) {
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_float_arr(), ptr, ctx);
+ CHK_(ptr);
+ } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 93) {
+ _internal_add_float_arr(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
+ ptr += sizeof(float);
+ } else goto handle_unusual;
+ continue;
+ // repeated double double_arr = 12;
+ case 12:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) {
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedDoubleParser(_internal_mutable_double_arr(), ptr, ctx);
+ CHK_(ptr);
+ } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 97) {
+ _internal_add_double_arr(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr));
+ ptr += sizeof(double);
+ } else goto handle_unusual;
+ continue;
+ // repeated bool bool_arr = 13;
+ case 13:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) {
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedBoolParser(_internal_mutable_bool_arr(), ptr, ctx);
+ CHK_(ptr);
+ } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 104) {
+ _internal_add_bool_arr(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // repeated string string_arr = 14;
+ case 14:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ auto str = _internal_add_string_arr();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "test.vereign.grpc.json.pb.RepeatedTypes.string_arr"));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<114>(ptr));
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag & 7) == 4 || tag == 0) {
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* RepeatedTypes::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:test.vereign.grpc.json.pb.RepeatedTypes)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // repeated int32 int32_arr = 1;
+ {
+ int byte_size = _int32_arr_cached_byte_size_.load(std::memory_order_relaxed);
+ if (byte_size > 0) {
+ target = stream->WriteInt32Packed(
+ 1, _internal_int32_arr(), byte_size, target);
+ }
+ }
+
+ // repeated int64 int64_arr = 2;
+ {
+ int byte_size = _int64_arr_cached_byte_size_.load(std::memory_order_relaxed);
+ if (byte_size > 0) {
+ target = stream->WriteInt64Packed(
+ 2, _internal_int64_arr(), byte_size, target);
+ }
+ }
+
+ // repeated uint32 uint32_arr = 3;
+ {
+ int byte_size = _uint32_arr_cached_byte_size_.load(std::memory_order_relaxed);
+ if (byte_size > 0) {
+ target = stream->WriteUInt32Packed(
+ 3, _internal_uint32_arr(), byte_size, target);
+ }
+ }
+
+ // repeated uint64 uint64_arr = 4;
+ {
+ int byte_size = _uint64_arr_cached_byte_size_.load(std::memory_order_relaxed);
+ if (byte_size > 0) {
+ target = stream->WriteUInt64Packed(
+ 4, _internal_uint64_arr(), byte_size, target);
+ }
+ }
+
+ // repeated sint32 sint32_arr = 5;
+ {
+ int byte_size = _sint32_arr_cached_byte_size_.load(std::memory_order_relaxed);
+ if (byte_size > 0) {
+ target = stream->WriteSInt32Packed(
+ 5, _internal_sint32_arr(), byte_size, target);
+ }
+ }
+
+ // repeated sint64 sint64_arr = 6;
+ {
+ int byte_size = _sint64_arr_cached_byte_size_.load(std::memory_order_relaxed);
+ if (byte_size > 0) {
+ target = stream->WriteSInt64Packed(
+ 6, _internal_sint64_arr(), byte_size, target);
+ }
+ }
+
+ // repeated fixed32 fixed32_arr = 7;
+ if (this->_internal_fixed32_arr_size() > 0) {
+ target = stream->WriteFixedPacked(7, _internal_fixed32_arr(), target);
+ }
+
+ // repeated fixed64 fixed64_arr = 8;
+ if (this->_internal_fixed64_arr_size() > 0) {
+ target = stream->WriteFixedPacked(8, _internal_fixed64_arr(), target);
+ }
+
+ // repeated sfixed32 sfixed32_arr = 9;
+ if (this->_internal_sfixed32_arr_size() > 0) {
+ target = stream->WriteFixedPacked(9, _internal_sfixed32_arr(), target);
+ }
+
+ // repeated sfixed64 sfixed64_arr = 10;
+ if (this->_internal_sfixed64_arr_size() > 0) {
+ target = stream->WriteFixedPacked(10, _internal_sfixed64_arr(), target);
+ }
+
+ // repeated float float_arr = 11;
+ if (this->_internal_float_arr_size() > 0) {
+ target = stream->WriteFixedPacked(11, _internal_float_arr(), target);
+ }
+
+ // repeated double double_arr = 12;
+ if (this->_internal_double_arr_size() > 0) {
+ target = stream->WriteFixedPacked(12, _internal_double_arr(), target);
+ }
+
+ // repeated bool bool_arr = 13;
+ if (this->_internal_bool_arr_size() > 0) {
+ target = stream->WriteFixedPacked(13, _internal_bool_arr(), target);
+ }
+
+ // repeated string string_arr = 14;
+ for (int i = 0, n = this->_internal_string_arr_size(); i < n; i++) {
+ const auto& s = this->_internal_string_arr(i);
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ s.data(), static_cast<int>(s.length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "test.vereign.grpc.json.pb.RepeatedTypes.string_arr");
+ target = stream->WriteString(14, s, target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields(), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:test.vereign.grpc.json.pb.RepeatedTypes)
+ return target;
+}
+
+size_t RepeatedTypes::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:test.vereign.grpc.json.pb.RepeatedTypes)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // repeated int32 int32_arr = 1;
+ {
+ size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ Int32Size(this->int32_arr_);
+ if (data_size > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+ static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
+ _int32_arr_cached_byte_size_.store(cached_size,
+ std::memory_order_relaxed);
+ total_size += data_size;
+ }
+
+ // repeated int64 int64_arr = 2;
+ {
+ size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ Int64Size(this->int64_arr_);
+ if (data_size > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+ static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
+ _int64_arr_cached_byte_size_.store(cached_size,
+ std::memory_order_relaxed);
+ total_size += data_size;
+ }
+
+ // repeated uint32 uint32_arr = 3;
+ {
+ size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ UInt32Size(this->uint32_arr_);
+ if (data_size > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+ static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
+ _uint32_arr_cached_byte_size_.store(cached_size,
+ std::memory_order_relaxed);
+ total_size += data_size;
+ }
+
+ // repeated uint64 uint64_arr = 4;
+ {
+ size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ UInt64Size(this->uint64_arr_);
+ if (data_size > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+ static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
+ _uint64_arr_cached_byte_size_.store(cached_size,
+ std::memory_order_relaxed);
+ total_size += data_size;
+ }
+
+ // repeated sint32 sint32_arr = 5;
+ {
+ size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ SInt32Size(this->sint32_arr_);
+ if (data_size > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+ static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
+ _sint32_arr_cached_byte_size_.store(cached_size,
+ std::memory_order_relaxed);
+ total_size += data_size;
+ }
+
+ // repeated sint64 sint64_arr = 6;
+ {
+ size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ SInt64Size(this->sint64_arr_);
+ if (data_size > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+ static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
+ _sint64_arr_cached_byte_size_.store(cached_size,
+ std::memory_order_relaxed);
+ total_size += data_size;
+ }
+
+ // repeated fixed32 fixed32_arr = 7;
+ {
+ unsigned int count = static_cast<unsigned int>(this->_internal_fixed32_arr_size());
+ size_t data_size = 4UL * count;
+ if (data_size > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+ static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
+ _fixed32_arr_cached_byte_size_.store(cached_size,
+ std::memory_order_relaxed);
+ total_size += data_size;
+ }
+
+ // repeated fixed64 fixed64_arr = 8;
+ {
+ unsigned int count = static_cast<unsigned int>(this->_internal_fixed64_arr_size());
+ size_t data_size = 8UL * count;
+ if (data_size > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+ static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
+ _fixed64_arr_cached_byte_size_.store(cached_size,
+ std::memory_order_relaxed);
+ total_size += data_size;
+ }
+
+ // repeated sfixed32 sfixed32_arr = 9;
+ {
+ unsigned int count = static_cast<unsigned int>(this->_internal_sfixed32_arr_size());
+ size_t data_size = 4UL * count;
+ if (data_size > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+ static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
+ _sfixed32_arr_cached_byte_size_.store(cached_size,
+ std::memory_order_relaxed);
+ total_size += data_size;
+ }
+
+ // repeated sfixed64 sfixed64_arr = 10;
+ {
+ unsigned int count = static_cast<unsigned int>(this->_internal_sfixed64_arr_size());
+ size_t data_size = 8UL * count;
+ if (data_size > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+ static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
+ _sfixed64_arr_cached_byte_size_.store(cached_size,
+ std::memory_order_relaxed);
+ total_size += data_size;
+ }
+
+ // repeated float float_arr = 11;
+ {
+ unsigned int count = static_cast<unsigned int>(this->_internal_float_arr_size());
+ size_t data_size = 4UL * count;
+ if (data_size > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+ static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
+ _float_arr_cached_byte_size_.store(cached_size,
+ std::memory_order_relaxed);
+ total_size += data_size;
+ }
+
+ // repeated double double_arr = 12;
+ {
+ unsigned int count = static_cast<unsigned int>(this->_internal_double_arr_size());
+ size_t data_size = 8UL * count;
+ if (data_size > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+ static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
+ _double_arr_cached_byte_size_.store(cached_size,
+ std::memory_order_relaxed);
+ total_size += data_size;
+ }
+
+ // repeated bool bool_arr = 13;
+ {
+ unsigned int count = static_cast<unsigned int>(this->_internal_bool_arr_size());
+ size_t data_size = 1UL * count;
+ if (data_size > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+ static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
+ _bool_arr_cached_byte_size_.store(cached_size,
+ std::memory_order_relaxed);
+ total_size += data_size;
+ }
+
+ // repeated string string_arr = 14;
+ total_size += 1 *
+ ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(string_arr_.size());
+ for (int i = 0, n = string_arr_.size(); i < n; i++) {
+ total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ string_arr_.Get(i));
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+ _internal_metadata_, total_size, &_cached_size_);
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void RepeatedTypes::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:test.vereign.grpc.json.pb.RepeatedTypes)
+ GOOGLE_DCHECK_NE(&from, this);
+ const RepeatedTypes* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RepeatedTypes>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:test.vereign.grpc.json.pb.RepeatedTypes)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:test.vereign.grpc.json.pb.RepeatedTypes)
+ MergeFrom(*source);
+ }
+}
+
+void RepeatedTypes::MergeFrom(const RepeatedTypes& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:test.vereign.grpc.json.pb.RepeatedTypes)
+ GOOGLE_DCHECK_NE(&from, this);
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ int32_arr_.MergeFrom(from.int32_arr_);
+ int64_arr_.MergeFrom(from.int64_arr_);
+ uint32_arr_.MergeFrom(from.uint32_arr_);
+ uint64_arr_.MergeFrom(from.uint64_arr_);
+ sint32_arr_.MergeFrom(from.sint32_arr_);
+ sint64_arr_.MergeFrom(from.sint64_arr_);
+ fixed32_arr_.MergeFrom(from.fixed32_arr_);
+ fixed64_arr_.MergeFrom(from.fixed64_arr_);
+ sfixed32_arr_.MergeFrom(from.sfixed32_arr_);
+ sfixed64_arr_.MergeFrom(from.sfixed64_arr_);
+ float_arr_.MergeFrom(from.float_arr_);
+ double_arr_.MergeFrom(from.double_arr_);
+ bool_arr_.MergeFrom(from.bool_arr_);
+ string_arr_.MergeFrom(from.string_arr_);
+}
+
+void RepeatedTypes::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:test.vereign.grpc.json.pb.RepeatedTypes)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void RepeatedTypes::CopyFrom(const RepeatedTypes& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:test.vereign.grpc.json.pb.RepeatedTypes)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool RepeatedTypes::IsInitialized() const {
+ return true;
+}
+
+void RepeatedTypes::InternalSwap(RepeatedTypes* other) {
+ using std::swap;
+ _internal_metadata_.Swap(&other->_internal_metadata_);
+ int32_arr_.InternalSwap(&other->int32_arr_);
+ int64_arr_.InternalSwap(&other->int64_arr_);
+ uint32_arr_.InternalSwap(&other->uint32_arr_);
+ uint64_arr_.InternalSwap(&other->uint64_arr_);
+ sint32_arr_.InternalSwap(&other->sint32_arr_);
+ sint64_arr_.InternalSwap(&other->sint64_arr_);
+ fixed32_arr_.InternalSwap(&other->fixed32_arr_);
+ fixed64_arr_.InternalSwap(&other->fixed64_arr_);
+ sfixed32_arr_.InternalSwap(&other->sfixed32_arr_);
+ sfixed64_arr_.InternalSwap(&other->sfixed64_arr_);
+ float_arr_.InternalSwap(&other->float_arr_);
+ double_arr_.InternalSwap(&other->double_arr_);
+ bool_arr_.InternalSwap(&other->bool_arr_);
+ string_arr_.InternalSwap(&other->string_arr_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata RepeatedTypes::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void Bar::InitAsDefaultInstance() {
+}
+class Bar::_Internal {
+ public:
+};
+
+Bar::Bar()
+ : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+ SharedCtor();
+ // @@protoc_insertion_point(constructor:test.vereign.grpc.json.pb.Bar)
+}
+Bar::Bar(const Bar& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message(),
+ _internal_metadata_(nullptr) {
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_value().empty()) {
+ value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.value_);
+ }
+ // @@protoc_insertion_point(copy_constructor:test.vereign.grpc.json.pb.Bar)
+}
+
+void Bar::SharedCtor() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Bar_messages_2eproto.base);
+ value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+Bar::~Bar() {
+ // @@protoc_insertion_point(destructor:test.vereign.grpc.json.pb.Bar)
+ SharedDtor();
+}
+
+void Bar::SharedDtor() {
+ value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void Bar::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+const Bar& Bar::default_instance() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Bar_messages_2eproto.base);
+ return *internal_default_instance();
+}
+
+
+void Bar::Clear() {
+// @@protoc_insertion_point(message_clear_start:test.vereign.grpc.json.pb.Bar)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ _internal_metadata_.Clear();
+}
+
+const char* Bar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ CHK_(ptr);
+ switch (tag >> 3) {
+ // string value = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ auto str = _internal_mutable_value();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "test.vereign.grpc.json.pb.Bar.value"));
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag & 7) == 4 || tag == 0) {
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* Bar::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:test.vereign.grpc.json.pb.Bar)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // string value = 2;
+ if (this->value().size() > 0) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ this->_internal_value().data(), static_cast<int>(this->_internal_value().length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "test.vereign.grpc.json.pb.Bar.value");
+ target = stream->WriteStringMaybeAliased(
+ 2, this->_internal_value(), target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields(), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:test.vereign.grpc.json.pb.Bar)
+ return target;
+}
+
+size_t Bar::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:test.vereign.grpc.json.pb.Bar)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // string value = 2;
+ if (this->value().size() > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ this->_internal_value());
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+ _internal_metadata_, total_size, &_cached_size_);
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void Bar::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:test.vereign.grpc.json.pb.Bar)
+ GOOGLE_DCHECK_NE(&from, this);
+ const Bar* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Bar>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:test.vereign.grpc.json.pb.Bar)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:test.vereign.grpc.json.pb.Bar)
+ MergeFrom(*source);
+ }
+}
+
+void Bar::MergeFrom(const Bar& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:test.vereign.grpc.json.pb.Bar)
+ GOOGLE_DCHECK_NE(&from, this);
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from.value().size() > 0) {
+
+ value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.value_);
+ }
+}
+
+void Bar::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:test.vereign.grpc.json.pb.Bar)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void Bar::CopyFrom(const Bar& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:test.vereign.grpc.json.pb.Bar)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool Bar::IsInitialized() const {
+ return true;
+}
+
+void Bar::InternalSwap(Bar* other) {
+ using std::swap;
+ _internal_metadata_.Swap(&other->_internal_metadata_);
+ value_.Swap(&other->value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ GetArenaNoVirtual());
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Bar::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void Foo::InitAsDefaultInstance() {
+ ::test::vereign::grpc::json::pb::_Foo_default_instance_._instance.get_mutable()->bar_ = const_cast< ::test::vereign::grpc::json::pb::Bar*>(
+ ::test::vereign::grpc::json::pb::Bar::internal_default_instance());
+}
+class Foo::_Internal {
+ public:
+ static const ::test::vereign::grpc::json::pb::Bar& bar(const Foo* msg);
+};
+
+const ::test::vereign::grpc::json::pb::Bar&
+Foo::_Internal::bar(const Foo* msg) {
+ return *msg->bar_;
+}
+Foo::Foo()
+ : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+ SharedCtor();
+ // @@protoc_insertion_point(constructor:test.vereign.grpc.json.pb.Foo)
+}
+Foo::Foo(const Foo& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message(),
+ _internal_metadata_(nullptr) {
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_value().empty()) {
+ value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.value_);
+ }
+ if (from._internal_has_bar()) {
+ bar_ = new ::test::vereign::grpc::json::pb::Bar(*from.bar_);
+ } else {
+ bar_ = nullptr;
+ }
+ // @@protoc_insertion_point(copy_constructor:test.vereign.grpc.json.pb.Foo)
+}
+
+void Foo::SharedCtor() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Foo_messages_2eproto.base);
+ value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ bar_ = nullptr;
+}
+
+Foo::~Foo() {
+ // @@protoc_insertion_point(destructor:test.vereign.grpc.json.pb.Foo)
+ SharedDtor();
+}
+
+void Foo::SharedDtor() {
+ value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (this != internal_default_instance()) delete bar_;
+}
+
+void Foo::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+const Foo& Foo::default_instance() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Foo_messages_2eproto.base);
+ return *internal_default_instance();
+}
+
+
+void Foo::Clear() {
+// @@protoc_insertion_point(message_clear_start:test.vereign.grpc.json.pb.Foo)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (GetArenaNoVirtual() == nullptr && bar_ != nullptr) {
+ delete bar_;
+ }
+ bar_ = nullptr;
+ _internal_metadata_.Clear();
+}
+
+const char* Foo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ CHK_(ptr);
+ switch (tag >> 3) {
+ // string value = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ auto str = _internal_mutable_value();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "test.vereign.grpc.json.pb.Foo.value"));
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // .test.vereign.grpc.json.pb.Bar bar = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ ptr = ctx->ParseMessage(_internal_mutable_bar(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag & 7) == 4 || tag == 0) {
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* Foo::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:test.vereign.grpc.json.pb.Foo)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // string value = 1;
+ if (this->value().size() > 0) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ this->_internal_value().data(), static_cast<int>(this->_internal_value().length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "test.vereign.grpc.json.pb.Foo.value");
+ target = stream->WriteStringMaybeAliased(
+ 1, this->_internal_value(), target);
+ }
+
+ // .test.vereign.grpc.json.pb.Bar bar = 2;
+ if (this->has_bar()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 2, _Internal::bar(this), target, stream);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields(), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:test.vereign.grpc.json.pb.Foo)
+ return target;
+}
+
+size_t Foo::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:test.vereign.grpc.json.pb.Foo)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // string value = 1;
+ if (this->value().size() > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ this->_internal_value());
+ }
+
+ // .test.vereign.grpc.json.pb.Bar bar = 2;
+ if (this->has_bar()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *bar_);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+ _internal_metadata_, total_size, &_cached_size_);
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void Foo::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:test.vereign.grpc.json.pb.Foo)
+ GOOGLE_DCHECK_NE(&from, this);
+ const Foo* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Foo>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:test.vereign.grpc.json.pb.Foo)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:test.vereign.grpc.json.pb.Foo)
+ MergeFrom(*source);
+ }
+}
+
+void Foo::MergeFrom(const Foo& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:test.vereign.grpc.json.pb.Foo)
+ GOOGLE_DCHECK_NE(&from, this);
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from.value().size() > 0) {
+
+ value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.value_);
+ }
+ if (from.has_bar()) {
+ _internal_mutable_bar()->::test::vereign::grpc::json::pb::Bar::MergeFrom(from._internal_bar());
+ }
+}
+
+void Foo::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:test.vereign.grpc.json.pb.Foo)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void Foo::CopyFrom(const Foo& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:test.vereign.grpc.json.pb.Foo)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool Foo::IsInitialized() const {
+ return true;
+}
+
+void Foo::InternalSwap(Foo* other) {
+ using std::swap;
+ _internal_metadata_.Swap(&other->_internal_metadata_);
+ value_.Swap(&other->value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ GetArenaNoVirtual());
+ swap(bar_, other->bar_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Foo::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void MessageType::InitAsDefaultInstance() {
+ ::test::vereign::grpc::json::pb::_MessageType_default_instance_._instance.get_mutable()->foo_ = const_cast< ::test::vereign::grpc::json::pb::Foo*>(
+ ::test::vereign::grpc::json::pb::Foo::internal_default_instance());
+}
+class MessageType::_Internal {
+ public:
+ static const ::test::vereign::grpc::json::pb::Foo& foo(const MessageType* msg);
+};
+
+const ::test::vereign::grpc::json::pb::Foo&
+MessageType::_Internal::foo(const MessageType* msg) {
+ return *msg->foo_;
+}
+MessageType::MessageType()
+ : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+ SharedCtor();
+ // @@protoc_insertion_point(constructor:test.vereign.grpc.json.pb.MessageType)
+}
+MessageType::MessageType(const MessageType& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message(),
+ _internal_metadata_(nullptr),
+ foo_arr_(from.foo_arr_) {
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ if (from._internal_has_foo()) {
+ foo_ = new ::test::vereign::grpc::json::pb::Foo(*from.foo_);
+ } else {
+ foo_ = nullptr;
+ }
+ // @@protoc_insertion_point(copy_constructor:test.vereign.grpc.json.pb.MessageType)
+}
+
+void MessageType::SharedCtor() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_MessageType_messages_2eproto.base);
+ foo_ = nullptr;
+}
+
+MessageType::~MessageType() {
+ // @@protoc_insertion_point(destructor:test.vereign.grpc.json.pb.MessageType)
+ SharedDtor();
+}
+
+void MessageType::SharedDtor() {
+ if (this != internal_default_instance()) delete foo_;
+}
+
+void MessageType::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+const MessageType& MessageType::default_instance() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_MessageType_messages_2eproto.base);
+ return *internal_default_instance();
+}
+
+
+void MessageType::Clear() {
+// @@protoc_insertion_point(message_clear_start:test.vereign.grpc.json.pb.MessageType)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ foo_arr_.Clear();
+ if (GetArenaNoVirtual() == nullptr && foo_ != nullptr) {
+ delete foo_;
+ }
+ foo_ = nullptr;
+ _internal_metadata_.Clear();
+}
+
+const char* MessageType::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ CHK_(ptr);
+ switch (tag >> 3) {
+ // .test.vereign.grpc.json.pb.Foo foo = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ ptr = ctx->ParseMessage(_internal_mutable_foo(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // repeated .test.vereign.grpc.json.pb.Foo foo_arr = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ ptr = ctx->ParseMessage(_internal_add_foo_arr(), ptr);
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag & 7) == 4 || tag == 0) {
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* MessageType::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:test.vereign.grpc.json.pb.MessageType)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // .test.vereign.grpc.json.pb.Foo foo = 1;
+ if (this->has_foo()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::foo(this), target, stream);
+ }
+
+ // repeated .test.vereign.grpc.json.pb.Foo foo_arr = 2;
+ for (unsigned int i = 0,
+ n = static_cast<unsigned int>(this->_internal_foo_arr_size()); i < n; i++) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(2, this->_internal_foo_arr(i), target, stream);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields(), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:test.vereign.grpc.json.pb.MessageType)
+ return target;
+}
+
+size_t MessageType::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:test.vereign.grpc.json.pb.MessageType)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // repeated .test.vereign.grpc.json.pb.Foo foo_arr = 2;
+ total_size += 1UL * this->_internal_foo_arr_size();
+ for (const auto& msg : this->foo_arr_) {
+ total_size +=
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+ }
+
+ // .test.vereign.grpc.json.pb.Foo foo = 1;
+ if (this->has_foo()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *foo_);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+ _internal_metadata_, total_size, &_cached_size_);
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void MessageType::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:test.vereign.grpc.json.pb.MessageType)
+ GOOGLE_DCHECK_NE(&from, this);
+ const MessageType* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<MessageType>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:test.vereign.grpc.json.pb.MessageType)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:test.vereign.grpc.json.pb.MessageType)
+ MergeFrom(*source);
+ }
+}
+
+void MessageType::MergeFrom(const MessageType& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:test.vereign.grpc.json.pb.MessageType)
+ GOOGLE_DCHECK_NE(&from, this);
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ foo_arr_.MergeFrom(from.foo_arr_);
+ if (from.has_foo()) {
+ _internal_mutable_foo()->::test::vereign::grpc::json::pb::Foo::MergeFrom(from._internal_foo());
+ }
+}
+
+void MessageType::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:test.vereign.grpc.json.pb.MessageType)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void MessageType::CopyFrom(const MessageType& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:test.vereign.grpc.json.pb.MessageType)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool MessageType::IsInitialized() const {
+ return true;
+}
+
+void MessageType::InternalSwap(MessageType* other) {
+ using std::swap;
+ _internal_metadata_.Swap(&other->_internal_metadata_);
+ foo_arr_.InternalSwap(&other->foo_arr_);
+ swap(foo_, other->foo_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata MessageType::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+MapType_Int32KeyEntry_DoNotUse::MapType_Int32KeyEntry_DoNotUse() {}
+MapType_Int32KeyEntry_DoNotUse::MapType_Int32KeyEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+ : SuperType(arena) {}
+void MapType_Int32KeyEntry_DoNotUse::MergeFrom(const MapType_Int32KeyEntry_DoNotUse& other) {
+ MergeFromInternal(other);
+}
+::PROTOBUF_NAMESPACE_ID::Metadata MapType_Int32KeyEntry_DoNotUse::GetMetadata() const {
+ return GetMetadataStatic();
+}
+void MapType_Int32KeyEntry_DoNotUse::MergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::Message& other) {
+ ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom(other);
+}
+
+
+// ===================================================================
+
+MapType_Int64KeyEntry_DoNotUse::MapType_Int64KeyEntry_DoNotUse() {}
+MapType_Int64KeyEntry_DoNotUse::MapType_Int64KeyEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+ : SuperType(arena) {}
+void MapType_Int64KeyEntry_DoNotUse::MergeFrom(const MapType_Int64KeyEntry_DoNotUse& other) {
+ MergeFromInternal(other);
+}
+::PROTOBUF_NAMESPACE_ID::Metadata MapType_Int64KeyEntry_DoNotUse::GetMetadata() const {
+ return GetMetadataStatic();
+}
+void MapType_Int64KeyEntry_DoNotUse::MergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::Message& other) {
+ ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom(other);
+}
+
+
+// ===================================================================
+
+MapType_Uint32KeyEntry_DoNotUse::MapType_Uint32KeyEntry_DoNotUse() {}
+MapType_Uint32KeyEntry_DoNotUse::MapType_Uint32KeyEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+ : SuperType(arena) {}
+void MapType_Uint32KeyEntry_DoNotUse::MergeFrom(const MapType_Uint32KeyEntry_DoNotUse& other) {
+ MergeFromInternal(other);
+}
+::PROTOBUF_NAMESPACE_ID::Metadata MapType_Uint32KeyEntry_DoNotUse::GetMetadata() const {
+ return GetMetadataStatic();
+}
+void MapType_Uint32KeyEntry_DoNotUse::MergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::Message& other) {
+ ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom(other);
+}
+
+
+// ===================================================================
+
+MapType_Uint64KeyEntry_DoNotUse::MapType_Uint64KeyEntry_DoNotUse() {}
+MapType_Uint64KeyEntry_DoNotUse::MapType_Uint64KeyEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+ : SuperType(arena) {}
+void MapType_Uint64KeyEntry_DoNotUse::MergeFrom(const MapType_Uint64KeyEntry_DoNotUse& other) {
+ MergeFromInternal(other);
+}
+::PROTOBUF_NAMESPACE_ID::Metadata MapType_Uint64KeyEntry_DoNotUse::GetMetadata() const {
+ return GetMetadataStatic();
+}
+void MapType_Uint64KeyEntry_DoNotUse::MergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::Message& other) {
+ ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom(other);
+}
+
+
+// ===================================================================
+
+MapType_Sint32KeyEntry_DoNotUse::MapType_Sint32KeyEntry_DoNotUse() {}
+MapType_Sint32KeyEntry_DoNotUse::MapType_Sint32KeyEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+ : SuperType(arena) {}
+void MapType_Sint32KeyEntry_DoNotUse::MergeFrom(const MapType_Sint32KeyEntry_DoNotUse& other) {
+ MergeFromInternal(other);
+}
+::PROTOBUF_NAMESPACE_ID::Metadata MapType_Sint32KeyEntry_DoNotUse::GetMetadata() const {
+ return GetMetadataStatic();
+}
+void MapType_Sint32KeyEntry_DoNotUse::MergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::Message& other) {
+ ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom(other);
+}
+
+
+// ===================================================================
+
+MapType_Sint64KeyEntry_DoNotUse::MapType_Sint64KeyEntry_DoNotUse() {}
+MapType_Sint64KeyEntry_DoNotUse::MapType_Sint64KeyEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+ : SuperType(arena) {}
+void MapType_Sint64KeyEntry_DoNotUse::MergeFrom(const MapType_Sint64KeyEntry_DoNotUse& other) {
+ MergeFromInternal(other);
+}
+::PROTOBUF_NAMESPACE_ID::Metadata MapType_Sint64KeyEntry_DoNotUse::GetMetadata() const {
+ return GetMetadataStatic();
+}
+void MapType_Sint64KeyEntry_DoNotUse::MergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::Message& other) {
+ ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom(other);
+}
+
+
+// ===================================================================
+
+MapType_Fixed32KeyEntry_DoNotUse::MapType_Fixed32KeyEntry_DoNotUse() {}
+MapType_Fixed32KeyEntry_DoNotUse::MapType_Fixed32KeyEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+ : SuperType(arena) {}
+void MapType_Fixed32KeyEntry_DoNotUse::MergeFrom(const MapType_Fixed32KeyEntry_DoNotUse& other) {
+ MergeFromInternal(other);
+}
+::PROTOBUF_NAMESPACE_ID::Metadata MapType_Fixed32KeyEntry_DoNotUse::GetMetadata() const {
+ return GetMetadataStatic();
+}
+void MapType_Fixed32KeyEntry_DoNotUse::MergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::Message& other) {
+ ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom(other);
+}
+
+
+// ===================================================================
+
+MapType_Fixed64KeyEntry_DoNotUse::MapType_Fixed64KeyEntry_DoNotUse() {}
+MapType_Fixed64KeyEntry_DoNotUse::MapType_Fixed64KeyEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+ : SuperType(arena) {}
+void MapType_Fixed64KeyEntry_DoNotUse::MergeFrom(const MapType_Fixed64KeyEntry_DoNotUse& other) {
+ MergeFromInternal(other);
+}
+::PROTOBUF_NAMESPACE_ID::Metadata MapType_Fixed64KeyEntry_DoNotUse::GetMetadata() const {
+ return GetMetadataStatic();
+}
+void MapType_Fixed64KeyEntry_DoNotUse::MergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::Message& other) {
+ ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom(other);
+}
+
+
+// ===================================================================
+
+MapType_Sfixed32KeyEntry_DoNotUse::MapType_Sfixed32KeyEntry_DoNotUse() {}
+MapType_Sfixed32KeyEntry_DoNotUse::MapType_Sfixed32KeyEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+ : SuperType(arena) {}
+void MapType_Sfixed32KeyEntry_DoNotUse::MergeFrom(const MapType_Sfixed32KeyEntry_DoNotUse& other) {
+ MergeFromInternal(other);
+}
+::PROTOBUF_NAMESPACE_ID::Metadata MapType_Sfixed32KeyEntry_DoNotUse::GetMetadata() const {
+ return GetMetadataStatic();
+}
+void MapType_Sfixed32KeyEntry_DoNotUse::MergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::Message& other) {
+ ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom(other);
+}
+
+
+// ===================================================================
+
+MapType_Sfixed64KeyEntry_DoNotUse::MapType_Sfixed64KeyEntry_DoNotUse() {}
+MapType_Sfixed64KeyEntry_DoNotUse::MapType_Sfixed64KeyEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+ : SuperType(arena) {}
+void MapType_Sfixed64KeyEntry_DoNotUse::MergeFrom(const MapType_Sfixed64KeyEntry_DoNotUse& other) {
+ MergeFromInternal(other);
+}
+::PROTOBUF_NAMESPACE_ID::Metadata MapType_Sfixed64KeyEntry_DoNotUse::GetMetadata() const {
+ return GetMetadataStatic();
+}
+void MapType_Sfixed64KeyEntry_DoNotUse::MergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::Message& other) {
+ ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom(other);
+}
+
+
+// ===================================================================
+
+MapType_StringKeyEntry_DoNotUse::MapType_StringKeyEntry_DoNotUse() {}
+MapType_StringKeyEntry_DoNotUse::MapType_StringKeyEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+ : SuperType(arena) {}
+void MapType_StringKeyEntry_DoNotUse::MergeFrom(const MapType_StringKeyEntry_DoNotUse& other) {
+ MergeFromInternal(other);
+}
+::PROTOBUF_NAMESPACE_ID::Metadata MapType_StringKeyEntry_DoNotUse::GetMetadata() const {
+ return GetMetadataStatic();
+}
+void MapType_StringKeyEntry_DoNotUse::MergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::Message& other) {
+ ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom(other);
+}
+
+
+// ===================================================================
+
+void MapType::InitAsDefaultInstance() {
+}
+class MapType::_Internal {
+ public:
+};
+
+MapType::MapType()
+ : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+ SharedCtor();
+ // @@protoc_insertion_point(constructor:test.vereign.grpc.json.pb.MapType)
+}
+MapType::MapType(const MapType& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message(),
+ _internal_metadata_(nullptr) {
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ int32_key_.MergeFrom(from.int32_key_);
+ int64_key_.MergeFrom(from.int64_key_);
+ uint32_key_.MergeFrom(from.uint32_key_);
+ uint64_key_.MergeFrom(from.uint64_key_);
+ sint32_key_.MergeFrom(from.sint32_key_);
+ sint64_key_.MergeFrom(from.sint64_key_);
+ fixed32_key_.MergeFrom(from.fixed32_key_);
+ fixed64_key_.MergeFrom(from.fixed64_key_);
+ sfixed32_key_.MergeFrom(from.sfixed32_key_);
+ sfixed64_key_.MergeFrom(from.sfixed64_key_);
+ string_key_.MergeFrom(from.string_key_);
+ // @@protoc_insertion_point(copy_constructor:test.vereign.grpc.json.pb.MapType)
+}
+
+void MapType::SharedCtor() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_MapType_messages_2eproto.base);
+}
+
+MapType::~MapType() {
+ // @@protoc_insertion_point(destructor:test.vereign.grpc.json.pb.MapType)
+ SharedDtor();
+}
+
+void MapType::SharedDtor() {
+}
+
+void MapType::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+const MapType& MapType::default_instance() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_MapType_messages_2eproto.base);
+ return *internal_default_instance();
+}
+
+
+void MapType::Clear() {
+// @@protoc_insertion_point(message_clear_start:test.vereign.grpc.json.pb.MapType)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ int32_key_.Clear();
+ int64_key_.Clear();
+ uint32_key_.Clear();
+ uint64_key_.Clear();
+ sint32_key_.Clear();
+ sint64_key_.Clear();
+ fixed32_key_.Clear();
+ fixed64_key_.Clear();
+ sfixed32_key_.Clear();
+ sfixed64_key_.Clear();
+ string_key_.Clear();
+ _internal_metadata_.Clear();
+}
+
+const char* MapType::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ CHK_(ptr);
+ switch (tag >> 3) {
+ // map<int32, string> int32_key = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ ptr = ctx->ParseMessage(&int32_key_, ptr);
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+ } else goto handle_unusual;
+ continue;
+ // map<int64, string> int64_key = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ ptr = ctx->ParseMessage(&int64_key_, ptr);
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+ } else goto handle_unusual;
+ continue;
+ // map<uint32, string> uint32_key = 3;
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ ptr = ctx->ParseMessage(&uint32_key_, ptr);
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
+ } else goto handle_unusual;
+ continue;
+ // map<uint64, string> uint64_key = 4;
+ case 4:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ ptr = ctx->ParseMessage(&uint64_key_, ptr);
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
+ } else goto handle_unusual;
+ continue;
+ // map<sint32, string> sint32_key = 5;
+ case 5:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ ptr = ctx->ParseMessage(&sint32_key_, ptr);
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
+ } else goto handle_unusual;
+ continue;
+ // map<sint64, string> sint64_key = 6;
+ case 6:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ ptr = ctx->ParseMessage(&sint64_key_, ptr);
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr));
+ } else goto handle_unusual;
+ continue;
+ // map<fixed32, string> fixed32_key = 7;
+ case 7:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ ptr = ctx->ParseMessage(&fixed32_key_, ptr);
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<58>(ptr));
+ } else goto handle_unusual;
+ continue;
+ // map<fixed64, string> fixed64_key = 8;
+ case 8:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ ptr = ctx->ParseMessage(&fixed64_key_, ptr);
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(ptr));
+ } else goto handle_unusual;
+ continue;
+ // map<sfixed32, string> sfixed32_key = 9;
+ case 9:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ ptr = ctx->ParseMessage(&sfixed32_key_, ptr);
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<74>(ptr));
+ } else goto handle_unusual;
+ continue;
+ // map<sfixed64, string> sfixed64_key = 10;
+ case 10:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ ptr = ctx->ParseMessage(&sfixed64_key_, ptr);
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<82>(ptr));
+ } else goto handle_unusual;
+ continue;
+ // map<string, string> string_key = 11;
+ case 11:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ ptr = ctx->ParseMessage(&string_key_, ptr);
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<90>(ptr));
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag & 7) == 4 || tag == 0) {
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* MapType::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:test.vereign.grpc.json.pb.MapType)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // map<int32, string> int32_key = 1;
+ if (!this->_internal_int32_key().empty()) {
+ typedef ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >::const_pointer
+ ConstPtr;
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::SortItem< ::PROTOBUF_NAMESPACE_ID::int32, ConstPtr > SortItem;
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::CompareByFirstField<SortItem> Less;
+ struct Utf8Check {
+ static void Check(ConstPtr p) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ p->second.data(), static_cast<int>(p->second.length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "test.vereign.grpc.json.pb.MapType.Int32KeyEntry.value");
+ }
+ };
+
+ if (stream->IsSerializationDeterministic() &&
+ this->_internal_int32_key().size() > 1) {
+ ::std::unique_ptr<SortItem[]> items(
+ new SortItem[this->_internal_int32_key().size()]);
+ typedef ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >::size_type size_type;
+ size_type n = 0;
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >::const_iterator
+ it = this->_internal_int32_key().begin();
+ it != this->_internal_int32_key().end(); ++it, ++n) {
+ items[static_cast<ptrdiff_t>(n)] = SortItem(&*it);
+ }
+ ::std::sort(&items[0], &items[static_cast<ptrdiff_t>(n)], Less());
+ for (size_type i = 0; i < n; i++) {
+ target = MapType_Int32KeyEntry_DoNotUse::Funcs::InternalSerialize(1, items[static_cast<ptrdiff_t>(i)].second->first, items[static_cast<ptrdiff_t>(i)].second->second, target, stream);
+ Utf8Check::Check(&(*items[static_cast<ptrdiff_t>(i)].second));
+ }
+ } else {
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >::const_iterator
+ it = this->_internal_int32_key().begin();
+ it != this->_internal_int32_key().end(); ++it) {
+ target = MapType_Int32KeyEntry_DoNotUse::Funcs::InternalSerialize(1, it->first, it->second, target, stream);
+ Utf8Check::Check(&(*it));
+ }
+ }
+ }
+
+ // map<int64, string> int64_key = 2;
+ if (!this->_internal_int64_key().empty()) {
+ typedef ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >::const_pointer
+ ConstPtr;
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::SortItem< ::PROTOBUF_NAMESPACE_ID::int64, ConstPtr > SortItem;
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::CompareByFirstField<SortItem> Less;
+ struct Utf8Check {
+ static void Check(ConstPtr p) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ p->second.data(), static_cast<int>(p->second.length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "test.vereign.grpc.json.pb.MapType.Int64KeyEntry.value");
+ }
+ };
+
+ if (stream->IsSerializationDeterministic() &&
+ this->_internal_int64_key().size() > 1) {
+ ::std::unique_ptr<SortItem[]> items(
+ new SortItem[this->_internal_int64_key().size()]);
+ typedef ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >::size_type size_type;
+ size_type n = 0;
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >::const_iterator
+ it = this->_internal_int64_key().begin();
+ it != this->_internal_int64_key().end(); ++it, ++n) {
+ items[static_cast<ptrdiff_t>(n)] = SortItem(&*it);
+ }
+ ::std::sort(&items[0], &items[static_cast<ptrdiff_t>(n)], Less());
+ for (size_type i = 0; i < n; i++) {
+ target = MapType_Int64KeyEntry_DoNotUse::Funcs::InternalSerialize(2, items[static_cast<ptrdiff_t>(i)].second->first, items[static_cast<ptrdiff_t>(i)].second->second, target, stream);
+ Utf8Check::Check(&(*items[static_cast<ptrdiff_t>(i)].second));
+ }
+ } else {
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >::const_iterator
+ it = this->_internal_int64_key().begin();
+ it != this->_internal_int64_key().end(); ++it) {
+ target = MapType_Int64KeyEntry_DoNotUse::Funcs::InternalSerialize(2, it->first, it->second, target, stream);
+ Utf8Check::Check(&(*it));
+ }
+ }
+ }
+
+ // map<uint32, string> uint32_key = 3;
+ if (!this->_internal_uint32_key().empty()) {
+ typedef ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint32, std::string >::const_pointer
+ ConstPtr;
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::SortItem< ::PROTOBUF_NAMESPACE_ID::uint32, ConstPtr > SortItem;
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::CompareByFirstField<SortItem> Less;
+ struct Utf8Check {
+ static void Check(ConstPtr p) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ p->second.data(), static_cast<int>(p->second.length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "test.vereign.grpc.json.pb.MapType.Uint32KeyEntry.value");
+ }
+ };
+
+ if (stream->IsSerializationDeterministic() &&
+ this->_internal_uint32_key().size() > 1) {
+ ::std::unique_ptr<SortItem[]> items(
+ new SortItem[this->_internal_uint32_key().size()]);
+ typedef ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint32, std::string >::size_type size_type;
+ size_type n = 0;
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint32, std::string >::const_iterator
+ it = this->_internal_uint32_key().begin();
+ it != this->_internal_uint32_key().end(); ++it, ++n) {
+ items[static_cast<ptrdiff_t>(n)] = SortItem(&*it);
+ }
+ ::std::sort(&items[0], &items[static_cast<ptrdiff_t>(n)], Less());
+ for (size_type i = 0; i < n; i++) {
+ target = MapType_Uint32KeyEntry_DoNotUse::Funcs::InternalSerialize(3, items[static_cast<ptrdiff_t>(i)].second->first, items[static_cast<ptrdiff_t>(i)].second->second, target, stream);
+ Utf8Check::Check(&(*items[static_cast<ptrdiff_t>(i)].second));
+ }
+ } else {
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint32, std::string >::const_iterator
+ it = this->_internal_uint32_key().begin();
+ it != this->_internal_uint32_key().end(); ++it) {
+ target = MapType_Uint32KeyEntry_DoNotUse::Funcs::InternalSerialize(3, it->first, it->second, target, stream);
+ Utf8Check::Check(&(*it));
+ }
+ }
+ }
+
+ // map<uint64, string> uint64_key = 4;
+ if (!this->_internal_uint64_key().empty()) {
+ typedef ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, std::string >::const_pointer
+ ConstPtr;
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::SortItem< ::PROTOBUF_NAMESPACE_ID::uint64, ConstPtr > SortItem;
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::CompareByFirstField<SortItem> Less;
+ struct Utf8Check {
+ static void Check(ConstPtr p) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ p->second.data(), static_cast<int>(p->second.length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "test.vereign.grpc.json.pb.MapType.Uint64KeyEntry.value");
+ }
+ };
+
+ if (stream->IsSerializationDeterministic() &&
+ this->_internal_uint64_key().size() > 1) {
+ ::std::unique_ptr<SortItem[]> items(
+ new SortItem[this->_internal_uint64_key().size()]);
+ typedef ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, std::string >::size_type size_type;
+ size_type n = 0;
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, std::string >::const_iterator
+ it = this->_internal_uint64_key().begin();
+ it != this->_internal_uint64_key().end(); ++it, ++n) {
+ items[static_cast<ptrdiff_t>(n)] = SortItem(&*it);
+ }
+ ::std::sort(&items[0], &items[static_cast<ptrdiff_t>(n)], Less());
+ for (size_type i = 0; i < n; i++) {
+ target = MapType_Uint64KeyEntry_DoNotUse::Funcs::InternalSerialize(4, items[static_cast<ptrdiff_t>(i)].second->first, items[static_cast<ptrdiff_t>(i)].second->second, target, stream);
+ Utf8Check::Check(&(*items[static_cast<ptrdiff_t>(i)].second));
+ }
+ } else {
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, std::string >::const_iterator
+ it = this->_internal_uint64_key().begin();
+ it != this->_internal_uint64_key().end(); ++it) {
+ target = MapType_Uint64KeyEntry_DoNotUse::Funcs::InternalSerialize(4, it->first, it->second, target, stream);
+ Utf8Check::Check(&(*it));
+ }
+ }
+ }
+
+ // map<sint32, string> sint32_key = 5;
+ if (!this->_internal_sint32_key().empty()) {
+ typedef ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >::const_pointer
+ ConstPtr;
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::SortItem< ::PROTOBUF_NAMESPACE_ID::int32, ConstPtr > SortItem;
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::CompareByFirstField<SortItem> Less;
+ struct Utf8Check {
+ static void Check(ConstPtr p) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ p->second.data(), static_cast<int>(p->second.length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "test.vereign.grpc.json.pb.MapType.Sint32KeyEntry.value");
+ }
+ };
+
+ if (stream->IsSerializationDeterministic() &&
+ this->_internal_sint32_key().size() > 1) {
+ ::std::unique_ptr<SortItem[]> items(
+ new SortItem[this->_internal_sint32_key().size()]);
+ typedef ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >::size_type size_type;
+ size_type n = 0;
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >::const_iterator
+ it = this->_internal_sint32_key().begin();
+ it != this->_internal_sint32_key().end(); ++it, ++n) {
+ items[static_cast<ptrdiff_t>(n)] = SortItem(&*it);
+ }
+ ::std::sort(&items[0], &items[static_cast<ptrdiff_t>(n)], Less());
+ for (size_type i = 0; i < n; i++) {
+ target = MapType_Sint32KeyEntry_DoNotUse::Funcs::InternalSerialize(5, items[static_cast<ptrdiff_t>(i)].second->first, items[static_cast<ptrdiff_t>(i)].second->second, target, stream);
+ Utf8Check::Check(&(*items[static_cast<ptrdiff_t>(i)].second));
+ }
+ } else {
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >::const_iterator
+ it = this->_internal_sint32_key().begin();
+ it != this->_internal_sint32_key().end(); ++it) {
+ target = MapType_Sint32KeyEntry_DoNotUse::Funcs::InternalSerialize(5, it->first, it->second, target, stream);
+ Utf8Check::Check(&(*it));
+ }
+ }
+ }
+
+ // map<sint64, string> sint64_key = 6;
+ if (!this->_internal_sint64_key().empty()) {
+ typedef ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >::const_pointer
+ ConstPtr;
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::SortItem< ::PROTOBUF_NAMESPACE_ID::int64, ConstPtr > SortItem;
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::CompareByFirstField<SortItem> Less;
+ struct Utf8Check {
+ static void Check(ConstPtr p) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ p->second.data(), static_cast<int>(p->second.length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "test.vereign.grpc.json.pb.MapType.Sint64KeyEntry.value");
+ }
+ };
+
+ if (stream->IsSerializationDeterministic() &&
+ this->_internal_sint64_key().size() > 1) {
+ ::std::unique_ptr<SortItem[]> items(
+ new SortItem[this->_internal_sint64_key().size()]);
+ typedef ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >::size_type size_type;
+ size_type n = 0;
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >::const_iterator
+ it = this->_internal_sint64_key().begin();
+ it != this->_internal_sint64_key().end(); ++it, ++n) {
+ items[static_cast<ptrdiff_t>(n)] = SortItem(&*it);
+ }
+ ::std::sort(&items[0], &items[static_cast<ptrdiff_t>(n)], Less());
+ for (size_type i = 0; i < n; i++) {
+ target = MapType_Sint64KeyEntry_DoNotUse::Funcs::InternalSerialize(6, items[static_cast<ptrdiff_t>(i)].second->first, items[static_cast<ptrdiff_t>(i)].second->second, target, stream);
+ Utf8Check::Check(&(*items[static_cast<ptrdiff_t>(i)].second));
+ }
+ } else {
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >::const_iterator
+ it = this->_internal_sint64_key().begin();
+ it != this->_internal_sint64_key().end(); ++it) {
+ target = MapType_Sint64KeyEntry_DoNotUse::Funcs::InternalSerialize(6, it->first, it->second, target, stream);
+ Utf8Check::Check(&(*it));
+ }
+ }
+ }
+
+ // map<fixed32, string> fixed32_key = 7;
+ if (!this->_internal_fixed32_key().empty()) {
+ typedef ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint32, std::string >::const_pointer
+ ConstPtr;
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::SortItem< ::PROTOBUF_NAMESPACE_ID::uint32, ConstPtr > SortItem;
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::CompareByFirstField<SortItem> Less;
+ struct Utf8Check {
+ static void Check(ConstPtr p) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ p->second.data(), static_cast<int>(p->second.length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "test.vereign.grpc.json.pb.MapType.Fixed32KeyEntry.value");
+ }
+ };
+
+ if (stream->IsSerializationDeterministic() &&
+ this->_internal_fixed32_key().size() > 1) {
+ ::std::unique_ptr<SortItem[]> items(
+ new SortItem[this->_internal_fixed32_key().size()]);
+ typedef ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint32, std::string >::size_type size_type;
+ size_type n = 0;
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint32, std::string >::const_iterator
+ it = this->_internal_fixed32_key().begin();
+ it != this->_internal_fixed32_key().end(); ++it, ++n) {
+ items[static_cast<ptrdiff_t>(n)] = SortItem(&*it);
+ }
+ ::std::sort(&items[0], &items[static_cast<ptrdiff_t>(n)], Less());
+ for (size_type i = 0; i < n; i++) {
+ target = MapType_Fixed32KeyEntry_DoNotUse::Funcs::InternalSerialize(7, items[static_cast<ptrdiff_t>(i)].second->first, items[static_cast<ptrdiff_t>(i)].second->second, target, stream);
+ Utf8Check::Check(&(*items[static_cast<ptrdiff_t>(i)].second));
+ }
+ } else {
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint32, std::string >::const_iterator
+ it = this->_internal_fixed32_key().begin();
+ it != this->_internal_fixed32_key().end(); ++it) {
+ target = MapType_Fixed32KeyEntry_DoNotUse::Funcs::InternalSerialize(7, it->first, it->second, target, stream);
+ Utf8Check::Check(&(*it));
+ }
+ }
+ }
+
+ // map<fixed64, string> fixed64_key = 8;
+ if (!this->_internal_fixed64_key().empty()) {
+ typedef ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, std::string >::const_pointer
+ ConstPtr;
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::SortItem< ::PROTOBUF_NAMESPACE_ID::uint64, ConstPtr > SortItem;
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::CompareByFirstField<SortItem> Less;
+ struct Utf8Check {
+ static void Check(ConstPtr p) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ p->second.data(), static_cast<int>(p->second.length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "test.vereign.grpc.json.pb.MapType.Fixed64KeyEntry.value");
+ }
+ };
+
+ if (stream->IsSerializationDeterministic() &&
+ this->_internal_fixed64_key().size() > 1) {
+ ::std::unique_ptr<SortItem[]> items(
+ new SortItem[this->_internal_fixed64_key().size()]);
+ typedef ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, std::string >::size_type size_type;
+ size_type n = 0;
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, std::string >::const_iterator
+ it = this->_internal_fixed64_key().begin();
+ it != this->_internal_fixed64_key().end(); ++it, ++n) {
+ items[static_cast<ptrdiff_t>(n)] = SortItem(&*it);
+ }
+ ::std::sort(&items[0], &items[static_cast<ptrdiff_t>(n)], Less());
+ for (size_type i = 0; i < n; i++) {
+ target = MapType_Fixed64KeyEntry_DoNotUse::Funcs::InternalSerialize(8, items[static_cast<ptrdiff_t>(i)].second->first, items[static_cast<ptrdiff_t>(i)].second->second, target, stream);
+ Utf8Check::Check(&(*items[static_cast<ptrdiff_t>(i)].second));
+ }
+ } else {
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, std::string >::const_iterator
+ it = this->_internal_fixed64_key().begin();
+ it != this->_internal_fixed64_key().end(); ++it) {
+ target = MapType_Fixed64KeyEntry_DoNotUse::Funcs::InternalSerialize(8, it->first, it->second, target, stream);
+ Utf8Check::Check(&(*it));
+ }
+ }
+ }
+
+ // map<sfixed32, string> sfixed32_key = 9;
+ if (!this->_internal_sfixed32_key().empty()) {
+ typedef ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >::const_pointer
+ ConstPtr;
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::SortItem< ::PROTOBUF_NAMESPACE_ID::int32, ConstPtr > SortItem;
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::CompareByFirstField<SortItem> Less;
+ struct Utf8Check {
+ static void Check(ConstPtr p) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ p->second.data(), static_cast<int>(p->second.length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "test.vereign.grpc.json.pb.MapType.Sfixed32KeyEntry.value");
+ }
+ };
+
+ if (stream->IsSerializationDeterministic() &&
+ this->_internal_sfixed32_key().size() > 1) {
+ ::std::unique_ptr<SortItem[]> items(
+ new SortItem[this->_internal_sfixed32_key().size()]);
+ typedef ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >::size_type size_type;
+ size_type n = 0;
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >::const_iterator
+ it = this->_internal_sfixed32_key().begin();
+ it != this->_internal_sfixed32_key().end(); ++it, ++n) {
+ items[static_cast<ptrdiff_t>(n)] = SortItem(&*it);
+ }
+ ::std::sort(&items[0], &items[static_cast<ptrdiff_t>(n)], Less());
+ for (size_type i = 0; i < n; i++) {
+ target = MapType_Sfixed32KeyEntry_DoNotUse::Funcs::InternalSerialize(9, items[static_cast<ptrdiff_t>(i)].second->first, items[static_cast<ptrdiff_t>(i)].second->second, target, stream);
+ Utf8Check::Check(&(*items[static_cast<ptrdiff_t>(i)].second));
+ }
+ } else {
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >::const_iterator
+ it = this->_internal_sfixed32_key().begin();
+ it != this->_internal_sfixed32_key().end(); ++it) {
+ target = MapType_Sfixed32KeyEntry_DoNotUse::Funcs::InternalSerialize(9, it->first, it->second, target, stream);
+ Utf8Check::Check(&(*it));
+ }
+ }
+ }
+
+ // map<sfixed64, string> sfixed64_key = 10;
+ if (!this->_internal_sfixed64_key().empty()) {
+ typedef ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >::const_pointer
+ ConstPtr;
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::SortItem< ::PROTOBUF_NAMESPACE_ID::int64, ConstPtr > SortItem;
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::CompareByFirstField<SortItem> Less;
+ struct Utf8Check {
+ static void Check(ConstPtr p) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ p->second.data(), static_cast<int>(p->second.length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "test.vereign.grpc.json.pb.MapType.Sfixed64KeyEntry.value");
+ }
+ };
+
+ if (stream->IsSerializationDeterministic() &&
+ this->_internal_sfixed64_key().size() > 1) {
+ ::std::unique_ptr<SortItem[]> items(
+ new SortItem[this->_internal_sfixed64_key().size()]);
+ typedef ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >::size_type size_type;
+ size_type n = 0;
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >::const_iterator
+ it = this->_internal_sfixed64_key().begin();
+ it != this->_internal_sfixed64_key().end(); ++it, ++n) {
+ items[static_cast<ptrdiff_t>(n)] = SortItem(&*it);
+ }
+ ::std::sort(&items[0], &items[static_cast<ptrdiff_t>(n)], Less());
+ for (size_type i = 0; i < n; i++) {
+ target = MapType_Sfixed64KeyEntry_DoNotUse::Funcs::InternalSerialize(10, items[static_cast<ptrdiff_t>(i)].second->first, items[static_cast<ptrdiff_t>(i)].second->second, target, stream);
+ Utf8Check::Check(&(*items[static_cast<ptrdiff_t>(i)].second));
+ }
+ } else {
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >::const_iterator
+ it = this->_internal_sfixed64_key().begin();
+ it != this->_internal_sfixed64_key().end(); ++it) {
+ target = MapType_Sfixed64KeyEntry_DoNotUse::Funcs::InternalSerialize(10, it->first, it->second, target, stream);
+ Utf8Check::Check(&(*it));
+ }
+ }
+ }
+
+ // map<string, string> string_key = 11;
+ if (!this->_internal_string_key().empty()) {
+ typedef ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::const_pointer
+ ConstPtr;
+ typedef ConstPtr SortItem;
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::CompareByDerefFirst<SortItem> Less;
+ struct Utf8Check {
+ static void Check(ConstPtr p) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ p->first.data(), static_cast<int>(p->first.length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "test.vereign.grpc.json.pb.MapType.StringKeyEntry.key");
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ p->second.data(), static_cast<int>(p->second.length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "test.vereign.grpc.json.pb.MapType.StringKeyEntry.value");
+ }
+ };
+
+ if (stream->IsSerializationDeterministic() &&
+ this->_internal_string_key().size() > 1) {
+ ::std::unique_ptr<SortItem[]> items(
+ new SortItem[this->_internal_string_key().size()]);
+ typedef ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::size_type size_type;
+ size_type n = 0;
+ for (::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::const_iterator
+ it = this->_internal_string_key().begin();
+ it != this->_internal_string_key().end(); ++it, ++n) {
+ items[static_cast<ptrdiff_t>(n)] = SortItem(&*it);
+ }
+ ::std::sort(&items[0], &items[static_cast<ptrdiff_t>(n)], Less());
+ for (size_type i = 0; i < n; i++) {
+ target = MapType_StringKeyEntry_DoNotUse::Funcs::InternalSerialize(11, items[static_cast<ptrdiff_t>(i)]->first, items[static_cast<ptrdiff_t>(i)]->second, target, stream);
+ Utf8Check::Check(&(*items[static_cast<ptrdiff_t>(i)]));
+ }
+ } else {
+ for (::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::const_iterator
+ it = this->_internal_string_key().begin();
+ it != this->_internal_string_key().end(); ++it) {
+ target = MapType_StringKeyEntry_DoNotUse::Funcs::InternalSerialize(11, it->first, it->second, target, stream);
+ Utf8Check::Check(&(*it));
+ }
+ }
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields(), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:test.vereign.grpc.json.pb.MapType)
+ return target;
+}
+
+size_t MapType::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:test.vereign.grpc.json.pb.MapType)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // map<int32, string> int32_key = 1;
+ total_size += 1 *
+ ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_int32_key_size());
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >::const_iterator
+ it = this->_internal_int32_key().begin();
+ it != this->_internal_int32_key().end(); ++it) {
+ total_size += MapType_Int32KeyEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
+ }
+
+ // map<int64, string> int64_key = 2;
+ total_size += 1 *
+ ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_int64_key_size());
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >::const_iterator
+ it = this->_internal_int64_key().begin();
+ it != this->_internal_int64_key().end(); ++it) {
+ total_size += MapType_Int64KeyEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
+ }
+
+ // map<uint32, string> uint32_key = 3;
+ total_size += 1 *
+ ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_uint32_key_size());
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint32, std::string >::const_iterator
+ it = this->_internal_uint32_key().begin();
+ it != this->_internal_uint32_key().end(); ++it) {
+ total_size += MapType_Uint32KeyEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
+ }
+
+ // map<uint64, string> uint64_key = 4;
+ total_size += 1 *
+ ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_uint64_key_size());
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, std::string >::const_iterator
+ it = this->_internal_uint64_key().begin();
+ it != this->_internal_uint64_key().end(); ++it) {
+ total_size += MapType_Uint64KeyEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
+ }
+
+ // map<sint32, string> sint32_key = 5;
+ total_size += 1 *
+ ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_sint32_key_size());
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >::const_iterator
+ it = this->_internal_sint32_key().begin();
+ it != this->_internal_sint32_key().end(); ++it) {
+ total_size += MapType_Sint32KeyEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
+ }
+
+ // map<sint64, string> sint64_key = 6;
+ total_size += 1 *
+ ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_sint64_key_size());
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >::const_iterator
+ it = this->_internal_sint64_key().begin();
+ it != this->_internal_sint64_key().end(); ++it) {
+ total_size += MapType_Sint64KeyEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
+ }
+
+ // map<fixed32, string> fixed32_key = 7;
+ total_size += 1 *
+ ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_fixed32_key_size());
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint32, std::string >::const_iterator
+ it = this->_internal_fixed32_key().begin();
+ it != this->_internal_fixed32_key().end(); ++it) {
+ total_size += MapType_Fixed32KeyEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
+ }
+
+ // map<fixed64, string> fixed64_key = 8;
+ total_size += 1 *
+ ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_fixed64_key_size());
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, std::string >::const_iterator
+ it = this->_internal_fixed64_key().begin();
+ it != this->_internal_fixed64_key().end(); ++it) {
+ total_size += MapType_Fixed64KeyEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
+ }
+
+ // map<sfixed32, string> sfixed32_key = 9;
+ total_size += 1 *
+ ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_sfixed32_key_size());
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >::const_iterator
+ it = this->_internal_sfixed32_key().begin();
+ it != this->_internal_sfixed32_key().end(); ++it) {
+ total_size += MapType_Sfixed32KeyEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
+ }
+
+ // map<sfixed64, string> sfixed64_key = 10;
+ total_size += 1 *
+ ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_sfixed64_key_size());
+ for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >::const_iterator
+ it = this->_internal_sfixed64_key().begin();
+ it != this->_internal_sfixed64_key().end(); ++it) {
+ total_size += MapType_Sfixed64KeyEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
+ }
+
+ // map<string, string> string_key = 11;
+ total_size += 1 *
+ ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_string_key_size());
+ for (::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::const_iterator
+ it = this->_internal_string_key().begin();
+ it != this->_internal_string_key().end(); ++it) {
+ total_size += MapType_StringKeyEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+ _internal_metadata_, total_size, &_cached_size_);
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void MapType::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:test.vereign.grpc.json.pb.MapType)
+ GOOGLE_DCHECK_NE(&from, this);
+ const MapType* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<MapType>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:test.vereign.grpc.json.pb.MapType)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:test.vereign.grpc.json.pb.MapType)
+ MergeFrom(*source);
+ }
+}
+
+void MapType::MergeFrom(const MapType& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:test.vereign.grpc.json.pb.MapType)
+ GOOGLE_DCHECK_NE(&from, this);
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ int32_key_.MergeFrom(from.int32_key_);
+ int64_key_.MergeFrom(from.int64_key_);
+ uint32_key_.MergeFrom(from.uint32_key_);
+ uint64_key_.MergeFrom(from.uint64_key_);
+ sint32_key_.MergeFrom(from.sint32_key_);
+ sint64_key_.MergeFrom(from.sint64_key_);
+ fixed32_key_.MergeFrom(from.fixed32_key_);
+ fixed64_key_.MergeFrom(from.fixed64_key_);
+ sfixed32_key_.MergeFrom(from.sfixed32_key_);
+ sfixed64_key_.MergeFrom(from.sfixed64_key_);
+ string_key_.MergeFrom(from.string_key_);
+}
+
+void MapType::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:test.vereign.grpc.json.pb.MapType)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void MapType::CopyFrom(const MapType& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:test.vereign.grpc.json.pb.MapType)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool MapType::IsInitialized() const {
+ return true;
+}
+
+void MapType::InternalSwap(MapType* other) {
+ using std::swap;
+ _internal_metadata_.Swap(&other->_internal_metadata_);
+ int32_key_.Swap(&other->int32_key_);
+ int64_key_.Swap(&other->int64_key_);
+ uint32_key_.Swap(&other->uint32_key_);
+ uint64_key_.Swap(&other->uint64_key_);
+ sint32_key_.Swap(&other->sint32_key_);
+ sint64_key_.Swap(&other->sint64_key_);
+ fixed32_key_.Swap(&other->fixed32_key_);
+ fixed64_key_.Swap(&other->fixed64_key_);
+ sfixed32_key_.Swap(&other->sfixed32_key_);
+ sfixed64_key_.Swap(&other->sfixed64_key_);
+ string_key_.Swap(&other->string_key_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata MapType::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+MapMessageType_MsgEntry_DoNotUse::MapMessageType_MsgEntry_DoNotUse() {}
+MapMessageType_MsgEntry_DoNotUse::MapMessageType_MsgEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+ : SuperType(arena) {}
+void MapMessageType_MsgEntry_DoNotUse::MergeFrom(const MapMessageType_MsgEntry_DoNotUse& other) {
+ MergeFromInternal(other);
+}
+::PROTOBUF_NAMESPACE_ID::Metadata MapMessageType_MsgEntry_DoNotUse::GetMetadata() const {
+ return GetMetadataStatic();
+}
+void MapMessageType_MsgEntry_DoNotUse::MergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::Message& other) {
+ ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom(other);
+}
+
+
+// ===================================================================
+
+void MapMessageType::InitAsDefaultInstance() {
+}
+class MapMessageType::_Internal {
+ public:
+};
+
+MapMessageType::MapMessageType()
+ : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+ SharedCtor();
+ // @@protoc_insertion_point(constructor:test.vereign.grpc.json.pb.MapMessageType)
+}
+MapMessageType::MapMessageType(const MapMessageType& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message(),
+ _internal_metadata_(nullptr) {
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ msg_.MergeFrom(from.msg_);
+ // @@protoc_insertion_point(copy_constructor:test.vereign.grpc.json.pb.MapMessageType)
+}
+
+void MapMessageType::SharedCtor() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_MapMessageType_messages_2eproto.base);
+}
+
+MapMessageType::~MapMessageType() {
+ // @@protoc_insertion_point(destructor:test.vereign.grpc.json.pb.MapMessageType)
+ SharedDtor();
+}
+
+void MapMessageType::SharedDtor() {
+}
+
+void MapMessageType::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+const MapMessageType& MapMessageType::default_instance() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_MapMessageType_messages_2eproto.base);
+ return *internal_default_instance();
+}
+
+
+void MapMessageType::Clear() {
+// @@protoc_insertion_point(message_clear_start:test.vereign.grpc.json.pb.MapMessageType)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ msg_.Clear();
+ _internal_metadata_.Clear();
+}
+
+const char* MapMessageType::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ CHK_(ptr);
+ switch (tag >> 3) {
+ // map<string, .test.vereign.grpc.json.pb.MessageType> msg = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ ptr = ctx->ParseMessage(&msg_, ptr);
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag & 7) == 4 || tag == 0) {
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* MapMessageType::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:test.vereign.grpc.json.pb.MapMessageType)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // map<string, .test.vereign.grpc.json.pb.MessageType> msg = 1;
+ if (!this->_internal_msg().empty()) {
+ typedef ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::test::vereign::grpc::json::pb::MessageType >::const_pointer
+ ConstPtr;
+ typedef ConstPtr SortItem;
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::CompareByDerefFirst<SortItem> Less;
+ struct Utf8Check {
+ static void Check(ConstPtr p) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ p->first.data(), static_cast<int>(p->first.length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "test.vereign.grpc.json.pb.MapMessageType.MsgEntry.key");
+ }
+ };
+
+ if (stream->IsSerializationDeterministic() &&
+ this->_internal_msg().size() > 1) {
+ ::std::unique_ptr<SortItem[]> items(
+ new SortItem[this->_internal_msg().size()]);
+ typedef ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::test::vereign::grpc::json::pb::MessageType >::size_type size_type;
+ size_type n = 0;
+ for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::test::vereign::grpc::json::pb::MessageType >::const_iterator
+ it = this->_internal_msg().begin();
+ it != this->_internal_msg().end(); ++it, ++n) {
+ items[static_cast<ptrdiff_t>(n)] = SortItem(&*it);
+ }
+ ::std::sort(&items[0], &items[static_cast<ptrdiff_t>(n)], Less());
+ for (size_type i = 0; i < n; i++) {
+ target = MapMessageType_MsgEntry_DoNotUse::Funcs::InternalSerialize(1, items[static_cast<ptrdiff_t>(i)]->first, items[static_cast<ptrdiff_t>(i)]->second, target, stream);
+ Utf8Check::Check(&(*items[static_cast<ptrdiff_t>(i)]));
+ }
+ } else {
+ for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::test::vereign::grpc::json::pb::MessageType >::const_iterator
+ it = this->_internal_msg().begin();
+ it != this->_internal_msg().end(); ++it) {
+ target = MapMessageType_MsgEntry_DoNotUse::Funcs::InternalSerialize(1, it->first, it->second, target, stream);
+ Utf8Check::Check(&(*it));
+ }
+ }
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields(), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:test.vereign.grpc.json.pb.MapMessageType)
+ return target;
+}
+
+size_t MapMessageType::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:test.vereign.grpc.json.pb.MapMessageType)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // map<string, .test.vereign.grpc.json.pb.MessageType> msg = 1;
+ total_size += 1 *
+ ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_msg_size());
+ for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::test::vereign::grpc::json::pb::MessageType >::const_iterator
+ it = this->_internal_msg().begin();
+ it != this->_internal_msg().end(); ++it) {
+ total_size += MapMessageType_MsgEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+ _internal_metadata_, total_size, &_cached_size_);
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void MapMessageType::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:test.vereign.grpc.json.pb.MapMessageType)
+ GOOGLE_DCHECK_NE(&from, this);
+ const MapMessageType* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<MapMessageType>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:test.vereign.grpc.json.pb.MapMessageType)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:test.vereign.grpc.json.pb.MapMessageType)
+ MergeFrom(*source);
+ }
+}
+
+void MapMessageType::MergeFrom(const MapMessageType& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:test.vereign.grpc.json.pb.MapMessageType)
+ GOOGLE_DCHECK_NE(&from, this);
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ msg_.MergeFrom(from.msg_);
+}
+
+void MapMessageType::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:test.vereign.grpc.json.pb.MapMessageType)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void MapMessageType::CopyFrom(const MapMessageType& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:test.vereign.grpc.json.pb.MapMessageType)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool MapMessageType::IsInitialized() const {
+ return true;
+}
+
+void MapMessageType::InternalSwap(MapMessageType* other) {
+ using std::swap;
+ _internal_metadata_.Swap(&other->_internal_metadata_);
+ msg_.Swap(&other->msg_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata MapMessageType::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void BytesType::InitAsDefaultInstance() {
+}
+class BytesType::_Internal {
+ public:
+};
+
+BytesType::BytesType()
+ : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+ SharedCtor();
+ // @@protoc_insertion_point(constructor:test.vereign.grpc.json.pb.BytesType)
+}
+BytesType::BytesType(const BytesType& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message(),
+ _internal_metadata_(nullptr),
+ bytes_arr_(from.bytes_arr_) {
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ bytes_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_bytes_value().empty()) {
+ bytes_value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.bytes_value_);
+ }
+ // @@protoc_insertion_point(copy_constructor:test.vereign.grpc.json.pb.BytesType)
+}
+
+void BytesType::SharedCtor() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_BytesType_messages_2eproto.base);
+ bytes_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+BytesType::~BytesType() {
+ // @@protoc_insertion_point(destructor:test.vereign.grpc.json.pb.BytesType)
+ SharedDtor();
+}
+
+void BytesType::SharedDtor() {
+ bytes_value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void BytesType::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+const BytesType& BytesType::default_instance() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_BytesType_messages_2eproto.base);
+ return *internal_default_instance();
+}
+
+
+void BytesType::Clear() {
+// @@protoc_insertion_point(message_clear_start:test.vereign.grpc.json.pb.BytesType)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ bytes_arr_.Clear();
+ bytes_value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ _internal_metadata_.Clear();
+}
+
+const char* BytesType::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ CHK_(ptr);
+ switch (tag >> 3) {
+ // bytes bytes_value = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ auto str = _internal_mutable_bytes_value();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // repeated bytes bytes_arr = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ auto str = _internal_add_bytes_arr();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag & 7) == 4 || tag == 0) {
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* BytesType::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:test.vereign.grpc.json.pb.BytesType)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // bytes bytes_value = 1;
+ if (this->bytes_value().size() > 0) {
+ target = stream->WriteBytesMaybeAliased(
+ 1, this->_internal_bytes_value(), target);
+ }
+
+ // repeated bytes bytes_arr = 2;
+ for (int i = 0, n = this->_internal_bytes_arr_size(); i < n; i++) {
+ const auto& s = this->_internal_bytes_arr(i);
+ target = stream->WriteBytes(2, s, target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields(), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:test.vereign.grpc.json.pb.BytesType)
+ return target;
+}
+
+size_t BytesType::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:test.vereign.grpc.json.pb.BytesType)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // repeated bytes bytes_arr = 2;
+ total_size += 1 *
+ ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(bytes_arr_.size());
+ for (int i = 0, n = bytes_arr_.size(); i < n; i++) {
+ total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ bytes_arr_.Get(i));
+ }
+
+ // bytes bytes_value = 1;
+ if (this->bytes_value().size() > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_bytes_value());
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+ _internal_metadata_, total_size, &_cached_size_);
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void BytesType::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:test.vereign.grpc.json.pb.BytesType)
+ GOOGLE_DCHECK_NE(&from, this);
+ const BytesType* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<BytesType>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:test.vereign.grpc.json.pb.BytesType)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:test.vereign.grpc.json.pb.BytesType)
+ MergeFrom(*source);
+ }
+}
+
+void BytesType::MergeFrom(const BytesType& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:test.vereign.grpc.json.pb.BytesType)
+ GOOGLE_DCHECK_NE(&from, this);
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ bytes_arr_.MergeFrom(from.bytes_arr_);
+ if (from.bytes_value().size() > 0) {
+
+ bytes_value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.bytes_value_);
+ }
+}
+
+void BytesType::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:test.vereign.grpc.json.pb.BytesType)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void BytesType::CopyFrom(const BytesType& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:test.vereign.grpc.json.pb.BytesType)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool BytesType::IsInitialized() const {
+ return true;
+}
+
+void BytesType::InternalSwap(BytesType* other) {
+ using std::swap;
+ _internal_metadata_.Swap(&other->_internal_metadata_);
+ bytes_arr_.InternalSwap(&other->bytes_arr_);
+ bytes_value_.Swap(&other->bytes_value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ GetArenaNoVirtual());
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata BytesType::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void JsonNaming::InitAsDefaultInstance() {
+}
+class JsonNaming::_Internal {
+ public:
+};
+
+JsonNaming::JsonNaming()
+ : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+ SharedCtor();
+ // @@protoc_insertion_point(constructor:test.vereign.grpc.json.pb.JsonNaming)
+}
+JsonNaming::JsonNaming(const JsonNaming& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message(),
+ _internal_metadata_(nullptr) {
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ ::memcpy(&foo_value_, &from.foo_value_,
+ static_cast<size_t>(reinterpret_cast<char*>(&qux_value_) -
+ reinterpret_cast<char*>(&foo_value_)) + sizeof(qux_value_));
+ // @@protoc_insertion_point(copy_constructor:test.vereign.grpc.json.pb.JsonNaming)
+}
+
+void JsonNaming::SharedCtor() {
+ ::memset(&foo_value_, 0, static_cast<size_t>(
+ reinterpret_cast<char*>(&qux_value_) -
+ reinterpret_cast<char*>(&foo_value_)) + sizeof(qux_value_));
+}
+
+JsonNaming::~JsonNaming() {
+ // @@protoc_insertion_point(destructor:test.vereign.grpc.json.pb.JsonNaming)
+ SharedDtor();
+}
+
+void JsonNaming::SharedDtor() {
+}
+
+void JsonNaming::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+const JsonNaming& JsonNaming::default_instance() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_JsonNaming_messages_2eproto.base);
+ return *internal_default_instance();
+}
+
+
+void JsonNaming::Clear() {
+// @@protoc_insertion_point(message_clear_start:test.vereign.grpc.json.pb.JsonNaming)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ ::memset(&foo_value_, 0, static_cast<size_t>(
+ reinterpret_cast<char*>(&qux_value_) -
+ reinterpret_cast<char*>(&foo_value_)) + sizeof(qux_value_));
+ _internal_metadata_.Clear();
+}
+
+const char* JsonNaming::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ CHK_(ptr);
+ switch (tag >> 3) {
+ // int32 foo_value = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
+ foo_value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // int32 barValue = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
+ barvalue_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // int32 BazValue = 3;
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
+ bazvalue_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // int32 quX_Value = 4;
+ case 4:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
+ qux_value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag & 7) == 4 || tag == 0) {
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* JsonNaming::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:test.vereign.grpc.json.pb.JsonNaming)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // int32 foo_value = 1;
+ if (this->foo_value() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_foo_value(), target);
+ }
+
+ // int32 barValue = 2;
+ if (this->barvalue() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_barvalue(), target);
+ }
+
+ // int32 BazValue = 3;
+ if (this->bazvalue() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_bazvalue(), target);
+ }
+
+ // int32 quX_Value = 4;
+ if (this->qux_value() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_qux_value(), target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields(), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:test.vereign.grpc.json.pb.JsonNaming)
+ return target;
+}
+
+size_t JsonNaming::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:test.vereign.grpc.json.pb.JsonNaming)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // int32 foo_value = 1;
+ if (this->foo_value() != 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+ this->_internal_foo_value());
+ }
+
+ // int32 barValue = 2;
+ if (this->barvalue() != 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+ this->_internal_barvalue());
+ }
+
+ // int32 BazValue = 3;
+ if (this->bazvalue() != 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+ this->_internal_bazvalue());
+ }
+
+ // int32 quX_Value = 4;
+ if (this->qux_value() != 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+ this->_internal_qux_value());
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+ _internal_metadata_, total_size, &_cached_size_);
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void JsonNaming::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:test.vereign.grpc.json.pb.JsonNaming)
+ GOOGLE_DCHECK_NE(&from, this);
+ const JsonNaming* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<JsonNaming>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:test.vereign.grpc.json.pb.JsonNaming)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:test.vereign.grpc.json.pb.JsonNaming)
+ MergeFrom(*source);
+ }
+}
+
+void JsonNaming::MergeFrom(const JsonNaming& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:test.vereign.grpc.json.pb.JsonNaming)
+ GOOGLE_DCHECK_NE(&from, this);
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from.foo_value() != 0) {
+ _internal_set_foo_value(from._internal_foo_value());
+ }
+ if (from.barvalue() != 0) {
+ _internal_set_barvalue(from._internal_barvalue());
+ }
+ if (from.bazvalue() != 0) {
+ _internal_set_bazvalue(from._internal_bazvalue());
+ }
+ if (from.qux_value() != 0) {
+ _internal_set_qux_value(from._internal_qux_value());
+ }
+}
+
+void JsonNaming::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:test.vereign.grpc.json.pb.JsonNaming)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void JsonNaming::CopyFrom(const JsonNaming& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:test.vereign.grpc.json.pb.JsonNaming)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool JsonNaming::IsInitialized() const {
+ return true;
+}
+
+void JsonNaming::InternalSwap(JsonNaming* other) {
+ using std::swap;
+ _internal_metadata_.Swap(&other->_internal_metadata_);
+ swap(foo_value_, other->foo_value_);
+ swap(barvalue_, other->barvalue_);
+ swap(bazvalue_, other->bazvalue_);
+ swap(qux_value_, other->qux_value_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata JsonNaming::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void OneofValue::InitAsDefaultInstance() {
+ ::test::vereign::grpc::json::pb::_OneofValue_default_instance_.string_value_.UnsafeSetDefault(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ ::test::vereign::grpc::json::pb::_OneofValue_default_instance_.struct_value_ = const_cast< ::test::vereign::grpc::json::pb::SimpleStruct*>(
+ ::test::vereign::grpc::json::pb::SimpleStruct::internal_default_instance());
+}
+class OneofValue::_Internal {
+ public:
+ static const ::test::vereign::grpc::json::pb::SimpleStruct& struct_value(const OneofValue* msg);
+};
+
+const ::test::vereign::grpc::json::pb::SimpleStruct&
+OneofValue::_Internal::struct_value(const OneofValue* msg) {
+ return *msg->data_.struct_value_;
+}
+void OneofValue::set_allocated_struct_value(::test::vereign::grpc::json::pb::SimpleStruct* struct_value) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
+ clear_data();
+ if (struct_value) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
+ if (message_arena != submessage_arena) {
+ struct_value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, struct_value, submessage_arena);
+ }
+ set_has_struct_value();
+ data_.struct_value_ = struct_value;
+ }
+ // @@protoc_insertion_point(field_set_allocated:test.vereign.grpc.json.pb.OneofValue.struct_value)
+}
+OneofValue::OneofValue()
+ : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+ SharedCtor();
+ // @@protoc_insertion_point(constructor:test.vereign.grpc.json.pb.OneofValue)
+}
+OneofValue::OneofValue(const OneofValue& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message(),
+ _internal_metadata_(nullptr) {
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ clear_has_data();
+ switch (from.data_case()) {
+ case kStringValue: {
+ _internal_set_string_value(from._internal_string_value());
+ break;
+ }
+ case kStructValue: {
+ _internal_mutable_struct_value()->::test::vereign::grpc::json::pb::SimpleStruct::MergeFrom(from._internal_struct_value());
+ break;
+ }
+ case DATA_NOT_SET: {
+ break;
+ }
+ }
+ // @@protoc_insertion_point(copy_constructor:test.vereign.grpc.json.pb.OneofValue)
+}
+
+void OneofValue::SharedCtor() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_OneofValue_messages_2eproto.base);
+ clear_has_data();
+}
+
+OneofValue::~OneofValue() {
+ // @@protoc_insertion_point(destructor:test.vereign.grpc.json.pb.OneofValue)
+ SharedDtor();
+}
+
+void OneofValue::SharedDtor() {
+ if (has_data()) {
+ clear_data();
+ }
+}
+
+void OneofValue::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+const OneofValue& OneofValue::default_instance() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_OneofValue_messages_2eproto.base);
+ return *internal_default_instance();
+}
+
+
+void OneofValue::clear_data() {
+// @@protoc_insertion_point(one_of_clear_start:test.vereign.grpc.json.pb.OneofValue)
+ switch (data_case()) {
+ case kStringValue: {
+ data_.string_value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ break;
+ }
+ case kStructValue: {
+ delete data_.struct_value_;
+ break;
+ }
+ case DATA_NOT_SET: {
+ break;
+ }
+ }
+ _oneof_case_[0] = DATA_NOT_SET;
+}
+
+
+void OneofValue::Clear() {
+// @@protoc_insertion_point(message_clear_start:test.vereign.grpc.json.pb.OneofValue)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ clear_data();
+ _internal_metadata_.Clear();
+}
+
+const char* OneofValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ CHK_(ptr);
+ switch (tag >> 3) {
+ // string string_value = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ auto str = _internal_mutable_string_value();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "test.vereign.grpc.json.pb.OneofValue.string_value"));
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // .test.vereign.grpc.json.pb.SimpleStruct struct_value = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ ptr = ctx->ParseMessage(_internal_mutable_struct_value(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag & 7) == 4 || tag == 0) {
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* OneofValue::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:test.vereign.grpc.json.pb.OneofValue)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // string string_value = 1;
+ if (_internal_has_string_value()) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ this->_internal_string_value().data(), static_cast<int>(this->_internal_string_value().length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "test.vereign.grpc.json.pb.OneofValue.string_value");
+ target = stream->WriteStringMaybeAliased(
+ 1, this->_internal_string_value(), target);
+ }
+
+ // .test.vereign.grpc.json.pb.SimpleStruct struct_value = 2;
+ if (_internal_has_struct_value()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 2, _Internal::struct_value(this), target, stream);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields(), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:test.vereign.grpc.json.pb.OneofValue)
+ return target;
+}
+
+size_t OneofValue::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:test.vereign.grpc.json.pb.OneofValue)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ switch (data_case()) {
+ // string string_value = 1;
+ case kStringValue: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ this->_internal_string_value());
+ break;
+ }
+ // .test.vereign.grpc.json.pb.SimpleStruct struct_value = 2;
+ case kStructValue: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *data_.struct_value_);
+ break;
+ }
+ case DATA_NOT_SET: {
+ break;
+ }
+ }
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+ _internal_metadata_, total_size, &_cached_size_);
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void OneofValue::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:test.vereign.grpc.json.pb.OneofValue)
+ GOOGLE_DCHECK_NE(&from, this);
+ const OneofValue* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<OneofValue>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:test.vereign.grpc.json.pb.OneofValue)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:test.vereign.grpc.json.pb.OneofValue)
+ MergeFrom(*source);
+ }
+}
+
+void OneofValue::MergeFrom(const OneofValue& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:test.vereign.grpc.json.pb.OneofValue)
+ GOOGLE_DCHECK_NE(&from, this);
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ switch (from.data_case()) {
+ case kStringValue: {
+ _internal_set_string_value(from._internal_string_value());
+ break;
+ }
+ case kStructValue: {
+ _internal_mutable_struct_value()->::test::vereign::grpc::json::pb::SimpleStruct::MergeFrom(from._internal_struct_value());
+ break;
+ }
+ case DATA_NOT_SET: {
+ break;
+ }
+ }
+}
+
+void OneofValue::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:test.vereign.grpc.json.pb.OneofValue)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void OneofValue::CopyFrom(const OneofValue& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:test.vereign.grpc.json.pb.OneofValue)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool OneofValue::IsInitialized() const {
+ return true;
+}
+
+void OneofValue::InternalSwap(OneofValue* other) {
+ using std::swap;
+ _internal_metadata_.Swap(&other->_internal_metadata_);
+ swap(data_, other->data_);
+ swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata OneofValue::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void EnumType::InitAsDefaultInstance() {
+}
+class EnumType::_Internal {
+ public:
+};
+
+EnumType::EnumType()
+ : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+ SharedCtor();
+ // @@protoc_insertion_point(constructor:test.vereign.grpc.json.pb.EnumType)
+}
+EnumType::EnumType(const EnumType& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message(),
+ _internal_metadata_(nullptr) {
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ corpus_ = from.corpus_;
+ // @@protoc_insertion_point(copy_constructor:test.vereign.grpc.json.pb.EnumType)
+}
+
+void EnumType::SharedCtor() {
+ corpus_ = 0;
+}
+
+EnumType::~EnumType() {
+ // @@protoc_insertion_point(destructor:test.vereign.grpc.json.pb.EnumType)
+ SharedDtor();
+}
+
+void EnumType::SharedDtor() {
+}
+
+void EnumType::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+const EnumType& EnumType::default_instance() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_EnumType_messages_2eproto.base);
+ return *internal_default_instance();
+}
+
+
+void EnumType::Clear() {
+// @@protoc_insertion_point(message_clear_start:test.vereign.grpc.json.pb.EnumType)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ corpus_ = 0;
+ _internal_metadata_.Clear();
+}
+
+const char* EnumType::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ CHK_(ptr);
+ switch (tag >> 3) {
+ // .test.vereign.grpc.json.pb.EnumType.Corpus corpus = 4;
+ case 4:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
+ ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
+ _internal_set_corpus(static_cast<::test::vereign::grpc::json::pb::EnumType_Corpus>(val));
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag & 7) == 4 || tag == 0) {
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* EnumType::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:test.vereign.grpc.json.pb.EnumType)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // .test.vereign.grpc.json.pb.EnumType.Corpus corpus = 4;
+ if (this->corpus() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+ 4, this->_internal_corpus(), target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields(), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:test.vereign.grpc.json.pb.EnumType)
+ return target;
+}
+
+size_t EnumType::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:test.vereign.grpc.json.pb.EnumType)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // .test.vereign.grpc.json.pb.EnumType.Corpus corpus = 4;
+ if (this->corpus() != 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_corpus());
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+ _internal_metadata_, total_size, &_cached_size_);
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void EnumType::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:test.vereign.grpc.json.pb.EnumType)
+ GOOGLE_DCHECK_NE(&from, this);
+ const EnumType* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<EnumType>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:test.vereign.grpc.json.pb.EnumType)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:test.vereign.grpc.json.pb.EnumType)
+ MergeFrom(*source);
+ }
+}
+
+void EnumType::MergeFrom(const EnumType& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:test.vereign.grpc.json.pb.EnumType)
+ GOOGLE_DCHECK_NE(&from, this);
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from.corpus() != 0) {
+ _internal_set_corpus(from._internal_corpus());
+ }
+}
+
+void EnumType::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:test.vereign.grpc.json.pb.EnumType)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void EnumType::CopyFrom(const EnumType& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:test.vereign.grpc.json.pb.EnumType)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool EnumType::IsInitialized() const {
+ return true;
+}
+
+void EnumType::InternalSwap(EnumType* other) {
+ using std::swap;
+ _internal_metadata_.Swap(&other->_internal_metadata_);
+ swap(corpus_, other->corpus_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata EnumType::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void RepeatedEnumType::InitAsDefaultInstance() {
+}
+class RepeatedEnumType::_Internal {
+ public:
+};
+
+RepeatedEnumType::RepeatedEnumType()
+ : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+ SharedCtor();
+ // @@protoc_insertion_point(constructor:test.vereign.grpc.json.pb.RepeatedEnumType)
+}
+RepeatedEnumType::RepeatedEnumType(const RepeatedEnumType& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message(),
+ _internal_metadata_(nullptr),
+ corpus_(from.corpus_) {
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ // @@protoc_insertion_point(copy_constructor:test.vereign.grpc.json.pb.RepeatedEnumType)
+}
+
+void RepeatedEnumType::SharedCtor() {
+}
+
+RepeatedEnumType::~RepeatedEnumType() {
+ // @@protoc_insertion_point(destructor:test.vereign.grpc.json.pb.RepeatedEnumType)
+ SharedDtor();
+}
+
+void RepeatedEnumType::SharedDtor() {
+}
+
+void RepeatedEnumType::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+const RepeatedEnumType& RepeatedEnumType::default_instance() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_RepeatedEnumType_messages_2eproto.base);
+ return *internal_default_instance();
+}
+
+
+void RepeatedEnumType::Clear() {
+// @@protoc_insertion_point(message_clear_start:test.vereign.grpc.json.pb.RepeatedEnumType)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ corpus_.Clear();
+ _internal_metadata_.Clear();
+}
+
+const char* RepeatedEnumType::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ CHK_(ptr);
+ switch (tag >> 3) {
+ // repeated .test.vereign.grpc.json.pb.RepeatedEnumType.Corpus corpus = 4;
+ case 4:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser(_internal_mutable_corpus(), ptr, ctx);
+ CHK_(ptr);
+ } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32) {
+ ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
+ _internal_add_corpus(static_cast<::test::vereign::grpc::json::pb::RepeatedEnumType_Corpus>(val));
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag & 7) == 4 || tag == 0) {
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* RepeatedEnumType::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:test.vereign.grpc.json.pb.RepeatedEnumType)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // repeated .test.vereign.grpc.json.pb.RepeatedEnumType.Corpus corpus = 4;
+ {
+ int byte_size = _corpus_cached_byte_size_.load(std::memory_order_relaxed);
+ if (byte_size > 0) {
+ target = stream->WriteEnumPacked(
+ 4, corpus_, byte_size, target);
+ }
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields(), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:test.vereign.grpc.json.pb.RepeatedEnumType)
+ return target;
+}
+
+size_t RepeatedEnumType::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:test.vereign.grpc.json.pb.RepeatedEnumType)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // repeated .test.vereign.grpc.json.pb.RepeatedEnumType.Corpus corpus = 4;
+ {
+ size_t data_size = 0;
+ unsigned int count = static_cast<unsigned int>(this->_internal_corpus_size());for (unsigned int i = 0; i < count; i++) {
+ data_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(
+ this->_internal_corpus(static_cast<int>(i)));
+ }
+ if (data_size > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+ static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
+ _corpus_cached_byte_size_.store(cached_size,
+ std::memory_order_relaxed);
+ total_size += data_size;
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+ _internal_metadata_, total_size, &_cached_size_);
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void RepeatedEnumType::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:test.vereign.grpc.json.pb.RepeatedEnumType)
+ GOOGLE_DCHECK_NE(&from, this);
+ const RepeatedEnumType* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RepeatedEnumType>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:test.vereign.grpc.json.pb.RepeatedEnumType)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:test.vereign.grpc.json.pb.RepeatedEnumType)
+ MergeFrom(*source);
+ }
+}
+
+void RepeatedEnumType::MergeFrom(const RepeatedEnumType& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:test.vereign.grpc.json.pb.RepeatedEnumType)
+ GOOGLE_DCHECK_NE(&from, this);
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ corpus_.MergeFrom(from.corpus_);
+}
+
+void RepeatedEnumType::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:test.vereign.grpc.json.pb.RepeatedEnumType)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void RepeatedEnumType::CopyFrom(const RepeatedEnumType& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:test.vereign.grpc.json.pb.RepeatedEnumType)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool RepeatedEnumType::IsInitialized() const {
+ return true;
+}
+
+void RepeatedEnumType::InternalSwap(RepeatedEnumType* other) {
+ using std::swap;
+ _internal_metadata_.Swap(&other->_internal_metadata_);
+ corpus_.InternalSwap(&other->corpus_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata RepeatedEnumType::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void NestedType_NestedFoo_NestedBar::InitAsDefaultInstance() {
+}
+class NestedType_NestedFoo_NestedBar::_Internal {
+ public:
+};
+
+NestedType_NestedFoo_NestedBar::NestedType_NestedFoo_NestedBar()
+ : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+ SharedCtor();
+ // @@protoc_insertion_point(constructor:test.vereign.grpc.json.pb.NestedType.NestedFoo.NestedBar)
+}
+NestedType_NestedFoo_NestedBar::NestedType_NestedFoo_NestedBar(const NestedType_NestedFoo_NestedBar& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message(),
+ _internal_metadata_(nullptr) {
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_value().empty()) {
+ value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.value_);
+ }
+ // @@protoc_insertion_point(copy_constructor:test.vereign.grpc.json.pb.NestedType.NestedFoo.NestedBar)
+}
+
+void NestedType_NestedFoo_NestedBar::SharedCtor() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_NestedType_NestedFoo_NestedBar_messages_2eproto.base);
+ value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+NestedType_NestedFoo_NestedBar::~NestedType_NestedFoo_NestedBar() {
+ // @@protoc_insertion_point(destructor:test.vereign.grpc.json.pb.NestedType.NestedFoo.NestedBar)
+ SharedDtor();
+}
+
+void NestedType_NestedFoo_NestedBar::SharedDtor() {
+ value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void NestedType_NestedFoo_NestedBar::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+const NestedType_NestedFoo_NestedBar& NestedType_NestedFoo_NestedBar::default_instance() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_NestedType_NestedFoo_NestedBar_messages_2eproto.base);
+ return *internal_default_instance();
+}
+
+
+void NestedType_NestedFoo_NestedBar::Clear() {
+// @@protoc_insertion_point(message_clear_start:test.vereign.grpc.json.pb.NestedType.NestedFoo.NestedBar)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ _internal_metadata_.Clear();
+}
+
+const char* NestedType_NestedFoo_NestedBar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ CHK_(ptr);
+ switch (tag >> 3) {
+ // string Value = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ auto str = _internal_mutable_value();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "test.vereign.grpc.json.pb.NestedType.NestedFoo.NestedBar.Value"));
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag & 7) == 4 || tag == 0) {
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* NestedType_NestedFoo_NestedBar::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:test.vereign.grpc.json.pb.NestedType.NestedFoo.NestedBar)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // string Value = 1;
+ if (this->value().size() > 0) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ this->_internal_value().data(), static_cast<int>(this->_internal_value().length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "test.vereign.grpc.json.pb.NestedType.NestedFoo.NestedBar.Value");
+ target = stream->WriteStringMaybeAliased(
+ 1, this->_internal_value(), target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields(), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:test.vereign.grpc.json.pb.NestedType.NestedFoo.NestedBar)
+ return target;
+}
+
+size_t NestedType_NestedFoo_NestedBar::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:test.vereign.grpc.json.pb.NestedType.NestedFoo.NestedBar)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // string Value = 1;
+ if (this->value().size() > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ this->_internal_value());
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+ _internal_metadata_, total_size, &_cached_size_);
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void NestedType_NestedFoo_NestedBar::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:test.vereign.grpc.json.pb.NestedType.NestedFoo.NestedBar)
+ GOOGLE_DCHECK_NE(&from, this);
+ const NestedType_NestedFoo_NestedBar* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<NestedType_NestedFoo_NestedBar>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:test.vereign.grpc.json.pb.NestedType.NestedFoo.NestedBar)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:test.vereign.grpc.json.pb.NestedType.NestedFoo.NestedBar)
+ MergeFrom(*source);
+ }
+}
+
+void NestedType_NestedFoo_NestedBar::MergeFrom(const NestedType_NestedFoo_NestedBar& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:test.vereign.grpc.json.pb.NestedType.NestedFoo.NestedBar)
+ GOOGLE_DCHECK_NE(&from, this);
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from.value().size() > 0) {
+
+ value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.value_);
+ }
+}
+
+void NestedType_NestedFoo_NestedBar::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:test.vereign.grpc.json.pb.NestedType.NestedFoo.NestedBar)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void NestedType_NestedFoo_NestedBar::CopyFrom(const NestedType_NestedFoo_NestedBar& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:test.vereign.grpc.json.pb.NestedType.NestedFoo.NestedBar)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool NestedType_NestedFoo_NestedBar::IsInitialized() const {
+ return true;
+}
+
+void NestedType_NestedFoo_NestedBar::InternalSwap(NestedType_NestedFoo_NestedBar* other) {
+ using std::swap;
+ _internal_metadata_.Swap(&other->_internal_metadata_);
+ value_.Swap(&other->value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ GetArenaNoVirtual());
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata NestedType_NestedFoo_NestedBar::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void NestedType_NestedFoo::InitAsDefaultInstance() {
+ ::test::vereign::grpc::json::pb::_NestedType_NestedFoo_default_instance_._instance.get_mutable()->bar_value_ = const_cast< ::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar*>(
+ ::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar::internal_default_instance());
+}
+class NestedType_NestedFoo::_Internal {
+ public:
+ static const ::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar& bar_value(const NestedType_NestedFoo* msg);
+};
+
+const ::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar&
+NestedType_NestedFoo::_Internal::bar_value(const NestedType_NestedFoo* msg) {
+ return *msg->bar_value_;
+}
+NestedType_NestedFoo::NestedType_NestedFoo()
+ : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+ SharedCtor();
+ // @@protoc_insertion_point(constructor:test.vereign.grpc.json.pb.NestedType.NestedFoo)
+}
+NestedType_NestedFoo::NestedType_NestedFoo(const NestedType_NestedFoo& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message(),
+ _internal_metadata_(nullptr) {
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_value().empty()) {
+ value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.value_);
+ }
+ if (from._internal_has_bar_value()) {
+ bar_value_ = new ::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar(*from.bar_value_);
+ } else {
+ bar_value_ = nullptr;
+ }
+ // @@protoc_insertion_point(copy_constructor:test.vereign.grpc.json.pb.NestedType.NestedFoo)
+}
+
+void NestedType_NestedFoo::SharedCtor() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_NestedType_NestedFoo_messages_2eproto.base);
+ value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ bar_value_ = nullptr;
+}
+
+NestedType_NestedFoo::~NestedType_NestedFoo() {
+ // @@protoc_insertion_point(destructor:test.vereign.grpc.json.pb.NestedType.NestedFoo)
+ SharedDtor();
+}
+
+void NestedType_NestedFoo::SharedDtor() {
+ value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (this != internal_default_instance()) delete bar_value_;
+}
+
+void NestedType_NestedFoo::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+const NestedType_NestedFoo& NestedType_NestedFoo::default_instance() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_NestedType_NestedFoo_messages_2eproto.base);
+ return *internal_default_instance();
+}
+
+
+void NestedType_NestedFoo::Clear() {
+// @@protoc_insertion_point(message_clear_start:test.vereign.grpc.json.pb.NestedType.NestedFoo)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (GetArenaNoVirtual() == nullptr && bar_value_ != nullptr) {
+ delete bar_value_;
+ }
+ bar_value_ = nullptr;
+ _internal_metadata_.Clear();
+}
+
+const char* NestedType_NestedFoo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ CHK_(ptr);
+ switch (tag >> 3) {
+ // string value = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ auto str = _internal_mutable_value();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "test.vereign.grpc.json.pb.NestedType.NestedFoo.value"));
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // .test.vereign.grpc.json.pb.NestedType.NestedFoo.NestedBar bar_value = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ ptr = ctx->ParseMessage(_internal_mutable_bar_value(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag & 7) == 4 || tag == 0) {
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* NestedType_NestedFoo::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:test.vereign.grpc.json.pb.NestedType.NestedFoo)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // string value = 1;
+ if (this->value().size() > 0) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ this->_internal_value().data(), static_cast<int>(this->_internal_value().length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "test.vereign.grpc.json.pb.NestedType.NestedFoo.value");
+ target = stream->WriteStringMaybeAliased(
+ 1, this->_internal_value(), target);
+ }
+
+ // .test.vereign.grpc.json.pb.NestedType.NestedFoo.NestedBar bar_value = 2;
+ if (this->has_bar_value()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 2, _Internal::bar_value(this), target, stream);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields(), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:test.vereign.grpc.json.pb.NestedType.NestedFoo)
+ return target;
+}
+
+size_t NestedType_NestedFoo::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:test.vereign.grpc.json.pb.NestedType.NestedFoo)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // string value = 1;
+ if (this->value().size() > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ this->_internal_value());
+ }
+
+ // .test.vereign.grpc.json.pb.NestedType.NestedFoo.NestedBar bar_value = 2;
+ if (this->has_bar_value()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *bar_value_);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+ _internal_metadata_, total_size, &_cached_size_);
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void NestedType_NestedFoo::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:test.vereign.grpc.json.pb.NestedType.NestedFoo)
+ GOOGLE_DCHECK_NE(&from, this);
+ const NestedType_NestedFoo* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<NestedType_NestedFoo>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:test.vereign.grpc.json.pb.NestedType.NestedFoo)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:test.vereign.grpc.json.pb.NestedType.NestedFoo)
+ MergeFrom(*source);
+ }
+}
+
+void NestedType_NestedFoo::MergeFrom(const NestedType_NestedFoo& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:test.vereign.grpc.json.pb.NestedType.NestedFoo)
+ GOOGLE_DCHECK_NE(&from, this);
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from.value().size() > 0) {
+
+ value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.value_);
+ }
+ if (from.has_bar_value()) {
+ _internal_mutable_bar_value()->::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar::MergeFrom(from._internal_bar_value());
+ }
+}
+
+void NestedType_NestedFoo::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:test.vereign.grpc.json.pb.NestedType.NestedFoo)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void NestedType_NestedFoo::CopyFrom(const NestedType_NestedFoo& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:test.vereign.grpc.json.pb.NestedType.NestedFoo)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool NestedType_NestedFoo::IsInitialized() const {
+ return true;
+}
+
+void NestedType_NestedFoo::InternalSwap(NestedType_NestedFoo* other) {
+ using std::swap;
+ _internal_metadata_.Swap(&other->_internal_metadata_);
+ value_.Swap(&other->value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ GetArenaNoVirtual());
+ swap(bar_value_, other->bar_value_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata NestedType_NestedFoo::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void NestedType::InitAsDefaultInstance() {
+ ::test::vereign::grpc::json::pb::_NestedType_default_instance_._instance.get_mutable()->foo_value_ = const_cast< ::test::vereign::grpc::json::pb::NestedType_NestedFoo*>(
+ ::test::vereign::grpc::json::pb::NestedType_NestedFoo::internal_default_instance());
+}
+class NestedType::_Internal {
+ public:
+ static const ::test::vereign::grpc::json::pb::NestedType_NestedFoo& foo_value(const NestedType* msg);
+};
+
+const ::test::vereign::grpc::json::pb::NestedType_NestedFoo&
+NestedType::_Internal::foo_value(const NestedType* msg) {
+ return *msg->foo_value_;
+}
+NestedType::NestedType()
+ : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+ SharedCtor();
+ // @@protoc_insertion_point(constructor:test.vereign.grpc.json.pb.NestedType)
+}
+NestedType::NestedType(const NestedType& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message(),
+ _internal_metadata_(nullptr) {
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_value().empty()) {
+ value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.value_);
+ }
+ if (from._internal_has_foo_value()) {
+ foo_value_ = new ::test::vereign::grpc::json::pb::NestedType_NestedFoo(*from.foo_value_);
+ } else {
+ foo_value_ = nullptr;
+ }
+ // @@protoc_insertion_point(copy_constructor:test.vereign.grpc.json.pb.NestedType)
+}
+
+void NestedType::SharedCtor() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_NestedType_messages_2eproto.base);
+ value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ foo_value_ = nullptr;
+}
+
+NestedType::~NestedType() {
+ // @@protoc_insertion_point(destructor:test.vereign.grpc.json.pb.NestedType)
+ SharedDtor();
+}
+
+void NestedType::SharedDtor() {
+ value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (this != internal_default_instance()) delete foo_value_;
+}
+
+void NestedType::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+const NestedType& NestedType::default_instance() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_NestedType_messages_2eproto.base);
+ return *internal_default_instance();
+}
+
+
+void NestedType::Clear() {
+// @@protoc_insertion_point(message_clear_start:test.vereign.grpc.json.pb.NestedType)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (GetArenaNoVirtual() == nullptr && foo_value_ != nullptr) {
+ delete foo_value_;
+ }
+ foo_value_ = nullptr;
+ _internal_metadata_.Clear();
+}
+
+const char* NestedType::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ CHK_(ptr);
+ switch (tag >> 3) {
+ // string value = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ auto str = _internal_mutable_value();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "test.vereign.grpc.json.pb.NestedType.value"));
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // .test.vereign.grpc.json.pb.NestedType.NestedFoo foo_value = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ ptr = ctx->ParseMessage(_internal_mutable_foo_value(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag & 7) == 4 || tag == 0) {
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* NestedType::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:test.vereign.grpc.json.pb.NestedType)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // string value = 1;
+ if (this->value().size() > 0) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ this->_internal_value().data(), static_cast<int>(this->_internal_value().length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "test.vereign.grpc.json.pb.NestedType.value");
+ target = stream->WriteStringMaybeAliased(
+ 1, this->_internal_value(), target);
+ }
+
+ // .test.vereign.grpc.json.pb.NestedType.NestedFoo foo_value = 2;
+ if (this->has_foo_value()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 2, _Internal::foo_value(this), target, stream);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields(), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:test.vereign.grpc.json.pb.NestedType)
+ return target;
+}
+
+size_t NestedType::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:test.vereign.grpc.json.pb.NestedType)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // string value = 1;
+ if (this->value().size() > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ this->_internal_value());
+ }
+
+ // .test.vereign.grpc.json.pb.NestedType.NestedFoo foo_value = 2;
+ if (this->has_foo_value()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *foo_value_);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+ _internal_metadata_, total_size, &_cached_size_);
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void NestedType::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:test.vereign.grpc.json.pb.NestedType)
+ GOOGLE_DCHECK_NE(&from, this);
+ const NestedType* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<NestedType>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:test.vereign.grpc.json.pb.NestedType)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:test.vereign.grpc.json.pb.NestedType)
+ MergeFrom(*source);
+ }
+}
+
+void NestedType::MergeFrom(const NestedType& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:test.vereign.grpc.json.pb.NestedType)
+ GOOGLE_DCHECK_NE(&from, this);
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from.value().size() > 0) {
+
+ value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.value_);
+ }
+ if (from.has_foo_value()) {
+ _internal_mutable_foo_value()->::test::vereign::grpc::json::pb::NestedType_NestedFoo::MergeFrom(from._internal_foo_value());
+ }
+}
+
+void NestedType::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:test.vereign.grpc.json.pb.NestedType)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void NestedType::CopyFrom(const NestedType& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:test.vereign.grpc.json.pb.NestedType)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool NestedType::IsInitialized() const {
+ return true;
+}
+
+void NestedType::InternalSwap(NestedType* other) {
+ using std::swap;
+ _internal_metadata_.Swap(&other->_internal_metadata_);
+ value_.Swap(&other->value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ GetArenaNoVirtual());
+ swap(foo_value_, other->foo_value_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata NestedType::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+} // namespace pb
+} // namespace json
+} // namespace grpc
+} // namespace vereign
+} // namespace test
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_NOINLINE ::test::vereign::grpc::json::pb::SimpleStruct* Arena::CreateMaybeMessage< ::test::vereign::grpc::json::pb::SimpleStruct >(Arena* arena) {
+ return Arena::CreateInternal< ::test::vereign::grpc::json::pb::SimpleStruct >(arena);
+}
+template<> PROTOBUF_NOINLINE ::test::vereign::grpc::json::pb::RepeatedTypes* Arena::CreateMaybeMessage< ::test::vereign::grpc::json::pb::RepeatedTypes >(Arena* arena) {
+ return Arena::CreateInternal< ::test::vereign::grpc::json::pb::RepeatedTypes >(arena);
+}
+template<> PROTOBUF_NOINLINE ::test::vereign::grpc::json::pb::Bar* Arena::CreateMaybeMessage< ::test::vereign::grpc::json::pb::Bar >(Arena* arena) {
+ return Arena::CreateInternal< ::test::vereign::grpc::json::pb::Bar >(arena);
+}
+template<> PROTOBUF_NOINLINE ::test::vereign::grpc::json::pb::Foo* Arena::CreateMaybeMessage< ::test::vereign::grpc::json::pb::Foo >(Arena* arena) {
+ return Arena::CreateInternal< ::test::vereign::grpc::json::pb::Foo >(arena);
+}
+template<> PROTOBUF_NOINLINE ::test::vereign::grpc::json::pb::MessageType* Arena::CreateMaybeMessage< ::test::vereign::grpc::json::pb::MessageType >(Arena* arena) {
+ return Arena::CreateInternal< ::test::vereign::grpc::json::pb::MessageType >(arena);
+}
+template<> PROTOBUF_NOINLINE ::test::vereign::grpc::json::pb::MapType_Int32KeyEntry_DoNotUse* Arena::CreateMaybeMessage< ::test::vereign::grpc::json::pb::MapType_Int32KeyEntry_DoNotUse >(Arena* arena) {
+ return Arena::CreateInternal< ::test::vereign::grpc::json::pb::MapType_Int32KeyEntry_DoNotUse >(arena);
+}
+template<> PROTOBUF_NOINLINE ::test::vereign::grpc::json::pb::MapType_Int64KeyEntry_DoNotUse* Arena::CreateMaybeMessage< ::test::vereign::grpc::json::pb::MapType_Int64KeyEntry_DoNotUse >(Arena* arena) {
+ return Arena::CreateInternal< ::test::vereign::grpc::json::pb::MapType_Int64KeyEntry_DoNotUse >(arena);
+}
+template<> PROTOBUF_NOINLINE ::test::vereign::grpc::json::pb::MapType_Uint32KeyEntry_DoNotUse* Arena::CreateMaybeMessage< ::test::vereign::grpc::json::pb::MapType_Uint32KeyEntry_DoNotUse >(Arena* arena) {
+ return Arena::CreateInternal< ::test::vereign::grpc::json::pb::MapType_Uint32KeyEntry_DoNotUse >(arena);
+}
+template<> PROTOBUF_NOINLINE ::test::vereign::grpc::json::pb::MapType_Uint64KeyEntry_DoNotUse* Arena::CreateMaybeMessage< ::test::vereign::grpc::json::pb::MapType_Uint64KeyEntry_DoNotUse >(Arena* arena) {
+ return Arena::CreateInternal< ::test::vereign::grpc::json::pb::MapType_Uint64KeyEntry_DoNotUse >(arena);
+}
+template<> PROTOBUF_NOINLINE ::test::vereign::grpc::json::pb::MapType_Sint32KeyEntry_DoNotUse* Arena::CreateMaybeMessage< ::test::vereign::grpc::json::pb::MapType_Sint32KeyEntry_DoNotUse >(Arena* arena) {
+ return Arena::CreateInternal< ::test::vereign::grpc::json::pb::MapType_Sint32KeyEntry_DoNotUse >(arena);
+}
+template<> PROTOBUF_NOINLINE ::test::vereign::grpc::json::pb::MapType_Sint64KeyEntry_DoNotUse* Arena::CreateMaybeMessage< ::test::vereign::grpc::json::pb::MapType_Sint64KeyEntry_DoNotUse >(Arena* arena) {
+ return Arena::CreateInternal< ::test::vereign::grpc::json::pb::MapType_Sint64KeyEntry_DoNotUse >(arena);
+}
+template<> PROTOBUF_NOINLINE ::test::vereign::grpc::json::pb::MapType_Fixed32KeyEntry_DoNotUse* Arena::CreateMaybeMessage< ::test::vereign::grpc::json::pb::MapType_Fixed32KeyEntry_DoNotUse >(Arena* arena) {
+ return Arena::CreateInternal< ::test::vereign::grpc::json::pb::MapType_Fixed32KeyEntry_DoNotUse >(arena);
+}
+template<> PROTOBUF_NOINLINE ::test::vereign::grpc::json::pb::MapType_Fixed64KeyEntry_DoNotUse* Arena::CreateMaybeMessage< ::test::vereign::grpc::json::pb::MapType_Fixed64KeyEntry_DoNotUse >(Arena* arena) {
+ return Arena::CreateInternal< ::test::vereign::grpc::json::pb::MapType_Fixed64KeyEntry_DoNotUse >(arena);
+}
+template<> PROTOBUF_NOINLINE ::test::vereign::grpc::json::pb::MapType_Sfixed32KeyEntry_DoNotUse* Arena::CreateMaybeMessage< ::test::vereign::grpc::json::pb::MapType_Sfixed32KeyEntry_DoNotUse >(Arena* arena) {
+ return Arena::CreateInternal< ::test::vereign::grpc::json::pb::MapType_Sfixed32KeyEntry_DoNotUse >(arena);
+}
+template<> PROTOBUF_NOINLINE ::test::vereign::grpc::json::pb::MapType_Sfixed64KeyEntry_DoNotUse* Arena::CreateMaybeMessage< ::test::vereign::grpc::json::pb::MapType_Sfixed64KeyEntry_DoNotUse >(Arena* arena) {
+ return Arena::CreateInternal< ::test::vereign::grpc::json::pb::MapType_Sfixed64KeyEntry_DoNotUse >(arena);
+}
+template<> PROTOBUF_NOINLINE ::test::vereign::grpc::json::pb::MapType_StringKeyEntry_DoNotUse* Arena::CreateMaybeMessage< ::test::vereign::grpc::json::pb::MapType_StringKeyEntry_DoNotUse >(Arena* arena) {
+ return Arena::CreateInternal< ::test::vereign::grpc::json::pb::MapType_StringKeyEntry_DoNotUse >(arena);
+}
+template<> PROTOBUF_NOINLINE ::test::vereign::grpc::json::pb::MapType* Arena::CreateMaybeMessage< ::test::vereign::grpc::json::pb::MapType >(Arena* arena) {
+ return Arena::CreateInternal< ::test::vereign::grpc::json::pb::MapType >(arena);
+}
+template<> PROTOBUF_NOINLINE ::test::vereign::grpc::json::pb::MapMessageType_MsgEntry_DoNotUse* Arena::CreateMaybeMessage< ::test::vereign::grpc::json::pb::MapMessageType_MsgEntry_DoNotUse >(Arena* arena) {
+ return Arena::CreateInternal< ::test::vereign::grpc::json::pb::MapMessageType_MsgEntry_DoNotUse >(arena);
+}
+template<> PROTOBUF_NOINLINE ::test::vereign::grpc::json::pb::MapMessageType* Arena::CreateMaybeMessage< ::test::vereign::grpc::json::pb::MapMessageType >(Arena* arena) {
+ return Arena::CreateInternal< ::test::vereign::grpc::json::pb::MapMessageType >(arena);
+}
+template<> PROTOBUF_NOINLINE ::test::vereign::grpc::json::pb::BytesType* Arena::CreateMaybeMessage< ::test::vereign::grpc::json::pb::BytesType >(Arena* arena) {
+ return Arena::CreateInternal< ::test::vereign::grpc::json::pb::BytesType >(arena);
+}
+template<> PROTOBUF_NOINLINE ::test::vereign::grpc::json::pb::JsonNaming* Arena::CreateMaybeMessage< ::test::vereign::grpc::json::pb::JsonNaming >(Arena* arena) {
+ return Arena::CreateInternal< ::test::vereign::grpc::json::pb::JsonNaming >(arena);
+}
+template<> PROTOBUF_NOINLINE ::test::vereign::grpc::json::pb::OneofValue* Arena::CreateMaybeMessage< ::test::vereign::grpc::json::pb::OneofValue >(Arena* arena) {
+ return Arena::CreateInternal< ::test::vereign::grpc::json::pb::OneofValue >(arena);
+}
+template<> PROTOBUF_NOINLINE ::test::vereign::grpc::json::pb::EnumType* Arena::CreateMaybeMessage< ::test::vereign::grpc::json::pb::EnumType >(Arena* arena) {
+ return Arena::CreateInternal< ::test::vereign::grpc::json::pb::EnumType >(arena);
+}
+template<> PROTOBUF_NOINLINE ::test::vereign::grpc::json::pb::RepeatedEnumType* Arena::CreateMaybeMessage< ::test::vereign::grpc::json::pb::RepeatedEnumType >(Arena* arena) {
+ return Arena::CreateInternal< ::test::vereign::grpc::json::pb::RepeatedEnumType >(arena);
+}
+template<> PROTOBUF_NOINLINE ::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar* Arena::CreateMaybeMessage< ::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar >(Arena* arena) {
+ return Arena::CreateInternal< ::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar >(arena);
+}
+template<> PROTOBUF_NOINLINE ::test::vereign::grpc::json::pb::NestedType_NestedFoo* Arena::CreateMaybeMessage< ::test::vereign::grpc::json::pb::NestedType_NestedFoo >(Arena* arena) {
+ return Arena::CreateInternal< ::test::vereign::grpc::json::pb::NestedType_NestedFoo >(arena);
+}
+template<> PROTOBUF_NOINLINE ::test::vereign::grpc::json::pb::NestedType* Arena::CreateMaybeMessage< ::test::vereign::grpc::json::pb::NestedType >(Arena* arena) {
+ return Arena::CreateInternal< ::test::vereign::grpc::json::pb::NestedType >(arena);
+}
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>
diff --git a/cpp/tests/vereign/grpc/json/pb/messages.pb.h b/cpp/tests/vereign/grpc/json/pb/messages.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..46d432512d8bc464e17aa8a998fc2397c199f637
--- /dev/null
+++ b/cpp/tests/vereign/grpc/json/pb/messages.pb.h
@@ -0,0 +1,6166 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: messages.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_messages_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_messages_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3011000
+#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
+#if 3011002 < 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
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/inlined_string_field.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h> // IWYU pragma: export
+#include <google/protobuf/extension_set.h> // IWYU pragma: export
+#include <google/protobuf/map.h> // IWYU pragma: export
+#include <google/protobuf/map_entry.h>
+#include <google/protobuf/map_field_inl.h>
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_messages_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+} // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_messages_2eproto {
+ static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+ PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+ static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
+ PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+ static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[27]
+ PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+ static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+ static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+ static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_messages_2eproto;
+namespace test {
+namespace vereign {
+namespace grpc {
+namespace json {
+namespace pb {
+class Bar;
+class BarDefaultTypeInternal;
+extern BarDefaultTypeInternal _Bar_default_instance_;
+class BytesType;
+class BytesTypeDefaultTypeInternal;
+extern BytesTypeDefaultTypeInternal _BytesType_default_instance_;
+class EnumType;
+class EnumTypeDefaultTypeInternal;
+extern EnumTypeDefaultTypeInternal _EnumType_default_instance_;
+class Foo;
+class FooDefaultTypeInternal;
+extern FooDefaultTypeInternal _Foo_default_instance_;
+class JsonNaming;
+class JsonNamingDefaultTypeInternal;
+extern JsonNamingDefaultTypeInternal _JsonNaming_default_instance_;
+class MapMessageType;
+class MapMessageTypeDefaultTypeInternal;
+extern MapMessageTypeDefaultTypeInternal _MapMessageType_default_instance_;
+class MapMessageType_MsgEntry_DoNotUse;
+class MapMessageType_MsgEntry_DoNotUseDefaultTypeInternal;
+extern MapMessageType_MsgEntry_DoNotUseDefaultTypeInternal _MapMessageType_MsgEntry_DoNotUse_default_instance_;
+class MapType;
+class MapTypeDefaultTypeInternal;
+extern MapTypeDefaultTypeInternal _MapType_default_instance_;
+class MapType_Fixed32KeyEntry_DoNotUse;
+class MapType_Fixed32KeyEntry_DoNotUseDefaultTypeInternal;
+extern MapType_Fixed32KeyEntry_DoNotUseDefaultTypeInternal _MapType_Fixed32KeyEntry_DoNotUse_default_instance_;
+class MapType_Fixed64KeyEntry_DoNotUse;
+class MapType_Fixed64KeyEntry_DoNotUseDefaultTypeInternal;
+extern MapType_Fixed64KeyEntry_DoNotUseDefaultTypeInternal _MapType_Fixed64KeyEntry_DoNotUse_default_instance_;
+class MapType_Int32KeyEntry_DoNotUse;
+class MapType_Int32KeyEntry_DoNotUseDefaultTypeInternal;
+extern MapType_Int32KeyEntry_DoNotUseDefaultTypeInternal _MapType_Int32KeyEntry_DoNotUse_default_instance_;
+class MapType_Int64KeyEntry_DoNotUse;
+class MapType_Int64KeyEntry_DoNotUseDefaultTypeInternal;
+extern MapType_Int64KeyEntry_DoNotUseDefaultTypeInternal _MapType_Int64KeyEntry_DoNotUse_default_instance_;
+class MapType_Sfixed32KeyEntry_DoNotUse;
+class MapType_Sfixed32KeyEntry_DoNotUseDefaultTypeInternal;
+extern MapType_Sfixed32KeyEntry_DoNotUseDefaultTypeInternal _MapType_Sfixed32KeyEntry_DoNotUse_default_instance_;
+class MapType_Sfixed64KeyEntry_DoNotUse;
+class MapType_Sfixed64KeyEntry_DoNotUseDefaultTypeInternal;
+extern MapType_Sfixed64KeyEntry_DoNotUseDefaultTypeInternal _MapType_Sfixed64KeyEntry_DoNotUse_default_instance_;
+class MapType_Sint32KeyEntry_DoNotUse;
+class MapType_Sint32KeyEntry_DoNotUseDefaultTypeInternal;
+extern MapType_Sint32KeyEntry_DoNotUseDefaultTypeInternal _MapType_Sint32KeyEntry_DoNotUse_default_instance_;
+class MapType_Sint64KeyEntry_DoNotUse;
+class MapType_Sint64KeyEntry_DoNotUseDefaultTypeInternal;
+extern MapType_Sint64KeyEntry_DoNotUseDefaultTypeInternal _MapType_Sint64KeyEntry_DoNotUse_default_instance_;
+class MapType_StringKeyEntry_DoNotUse;
+class MapType_StringKeyEntry_DoNotUseDefaultTypeInternal;
+extern MapType_StringKeyEntry_DoNotUseDefaultTypeInternal _MapType_StringKeyEntry_DoNotUse_default_instance_;
+class MapType_Uint32KeyEntry_DoNotUse;
+class MapType_Uint32KeyEntry_DoNotUseDefaultTypeInternal;
+extern MapType_Uint32KeyEntry_DoNotUseDefaultTypeInternal _MapType_Uint32KeyEntry_DoNotUse_default_instance_;
+class MapType_Uint64KeyEntry_DoNotUse;
+class MapType_Uint64KeyEntry_DoNotUseDefaultTypeInternal;
+extern MapType_Uint64KeyEntry_DoNotUseDefaultTypeInternal _MapType_Uint64KeyEntry_DoNotUse_default_instance_;
+class MessageType;
+class MessageTypeDefaultTypeInternal;
+extern MessageTypeDefaultTypeInternal _MessageType_default_instance_;
+class NestedType;
+class NestedTypeDefaultTypeInternal;
+extern NestedTypeDefaultTypeInternal _NestedType_default_instance_;
+class NestedType_NestedFoo;
+class NestedType_NestedFooDefaultTypeInternal;
+extern NestedType_NestedFooDefaultTypeInternal _NestedType_NestedFoo_default_instance_;
+class NestedType_NestedFoo_NestedBar;
+class NestedType_NestedFoo_NestedBarDefaultTypeInternal;
+extern NestedType_NestedFoo_NestedBarDefaultTypeInternal _NestedType_NestedFoo_NestedBar_default_instance_;
+class OneofValue;
+class OneofValueDefaultTypeInternal;
+extern OneofValueDefaultTypeInternal _OneofValue_default_instance_;
+class RepeatedEnumType;
+class RepeatedEnumTypeDefaultTypeInternal;
+extern RepeatedEnumTypeDefaultTypeInternal _RepeatedEnumType_default_instance_;
+class RepeatedTypes;
+class RepeatedTypesDefaultTypeInternal;
+extern RepeatedTypesDefaultTypeInternal _RepeatedTypes_default_instance_;
+class SimpleStruct;
+class SimpleStructDefaultTypeInternal;
+extern SimpleStructDefaultTypeInternal _SimpleStruct_default_instance_;
+} // namespace pb
+} // namespace json
+} // namespace grpc
+} // namespace vereign
+} // namespace test
+PROTOBUF_NAMESPACE_OPEN
+template<> ::test::vereign::grpc::json::pb::Bar* Arena::CreateMaybeMessage<::test::vereign::grpc::json::pb::Bar>(Arena*);
+template<> ::test::vereign::grpc::json::pb::BytesType* Arena::CreateMaybeMessage<::test::vereign::grpc::json::pb::BytesType>(Arena*);
+template<> ::test::vereign::grpc::json::pb::EnumType* Arena::CreateMaybeMessage<::test::vereign::grpc::json::pb::EnumType>(Arena*);
+template<> ::test::vereign::grpc::json::pb::Foo* Arena::CreateMaybeMessage<::test::vereign::grpc::json::pb::Foo>(Arena*);
+template<> ::test::vereign::grpc::json::pb::JsonNaming* Arena::CreateMaybeMessage<::test::vereign::grpc::json::pb::JsonNaming>(Arena*);
+template<> ::test::vereign::grpc::json::pb::MapMessageType* Arena::CreateMaybeMessage<::test::vereign::grpc::json::pb::MapMessageType>(Arena*);
+template<> ::test::vereign::grpc::json::pb::MapMessageType_MsgEntry_DoNotUse* Arena::CreateMaybeMessage<::test::vereign::grpc::json::pb::MapMessageType_MsgEntry_DoNotUse>(Arena*);
+template<> ::test::vereign::grpc::json::pb::MapType* Arena::CreateMaybeMessage<::test::vereign::grpc::json::pb::MapType>(Arena*);
+template<> ::test::vereign::grpc::json::pb::MapType_Fixed32KeyEntry_DoNotUse* Arena::CreateMaybeMessage<::test::vereign::grpc::json::pb::MapType_Fixed32KeyEntry_DoNotUse>(Arena*);
+template<> ::test::vereign::grpc::json::pb::MapType_Fixed64KeyEntry_DoNotUse* Arena::CreateMaybeMessage<::test::vereign::grpc::json::pb::MapType_Fixed64KeyEntry_DoNotUse>(Arena*);
+template<> ::test::vereign::grpc::json::pb::MapType_Int32KeyEntry_DoNotUse* Arena::CreateMaybeMessage<::test::vereign::grpc::json::pb::MapType_Int32KeyEntry_DoNotUse>(Arena*);
+template<> ::test::vereign::grpc::json::pb::MapType_Int64KeyEntry_DoNotUse* Arena::CreateMaybeMessage<::test::vereign::grpc::json::pb::MapType_Int64KeyEntry_DoNotUse>(Arena*);
+template<> ::test::vereign::grpc::json::pb::MapType_Sfixed32KeyEntry_DoNotUse* Arena::CreateMaybeMessage<::test::vereign::grpc::json::pb::MapType_Sfixed32KeyEntry_DoNotUse>(Arena*);
+template<> ::test::vereign::grpc::json::pb::MapType_Sfixed64KeyEntry_DoNotUse* Arena::CreateMaybeMessage<::test::vereign::grpc::json::pb::MapType_Sfixed64KeyEntry_DoNotUse>(Arena*);
+template<> ::test::vereign::grpc::json::pb::MapType_Sint32KeyEntry_DoNotUse* Arena::CreateMaybeMessage<::test::vereign::grpc::json::pb::MapType_Sint32KeyEntry_DoNotUse>(Arena*);
+template<> ::test::vereign::grpc::json::pb::MapType_Sint64KeyEntry_DoNotUse* Arena::CreateMaybeMessage<::test::vereign::grpc::json::pb::MapType_Sint64KeyEntry_DoNotUse>(Arena*);
+template<> ::test::vereign::grpc::json::pb::MapType_StringKeyEntry_DoNotUse* Arena::CreateMaybeMessage<::test::vereign::grpc::json::pb::MapType_StringKeyEntry_DoNotUse>(Arena*);
+template<> ::test::vereign::grpc::json::pb::MapType_Uint32KeyEntry_DoNotUse* Arena::CreateMaybeMessage<::test::vereign::grpc::json::pb::MapType_Uint32KeyEntry_DoNotUse>(Arena*);
+template<> ::test::vereign::grpc::json::pb::MapType_Uint64KeyEntry_DoNotUse* Arena::CreateMaybeMessage<::test::vereign::grpc::json::pb::MapType_Uint64KeyEntry_DoNotUse>(Arena*);
+template<> ::test::vereign::grpc::json::pb::MessageType* Arena::CreateMaybeMessage<::test::vereign::grpc::json::pb::MessageType>(Arena*);
+template<> ::test::vereign::grpc::json::pb::NestedType* Arena::CreateMaybeMessage<::test::vereign::grpc::json::pb::NestedType>(Arena*);
+template<> ::test::vereign::grpc::json::pb::NestedType_NestedFoo* Arena::CreateMaybeMessage<::test::vereign::grpc::json::pb::NestedType_NestedFoo>(Arena*);
+template<> ::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar* Arena::CreateMaybeMessage<::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar>(Arena*);
+template<> ::test::vereign::grpc::json::pb::OneofValue* Arena::CreateMaybeMessage<::test::vereign::grpc::json::pb::OneofValue>(Arena*);
+template<> ::test::vereign::grpc::json::pb::RepeatedEnumType* Arena::CreateMaybeMessage<::test::vereign::grpc::json::pb::RepeatedEnumType>(Arena*);
+template<> ::test::vereign::grpc::json::pb::RepeatedTypes* Arena::CreateMaybeMessage<::test::vereign::grpc::json::pb::RepeatedTypes>(Arena*);
+template<> ::test::vereign::grpc::json::pb::SimpleStruct* Arena::CreateMaybeMessage<::test::vereign::grpc::json::pb::SimpleStruct>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace test {
+namespace vereign {
+namespace grpc {
+namespace json {
+namespace pb {
+
+enum EnumType_Corpus : int {
+ EnumType_Corpus_UNIVERSAL = 0,
+ EnumType_Corpus_WEB = 1,
+ EnumType_Corpus_IMAGES = 2,
+ EnumType_Corpus_LOCAL = 3,
+ EnumType_Corpus_NEWS = 4,
+ EnumType_Corpus_PRODUCTS = 5,
+ EnumType_Corpus_VIDEO = 6,
+ EnumType_Corpus_EnumType_Corpus_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
+ EnumType_Corpus_EnumType_Corpus_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
+};
+bool EnumType_Corpus_IsValid(int value);
+constexpr EnumType_Corpus EnumType_Corpus_Corpus_MIN = EnumType_Corpus_UNIVERSAL;
+constexpr EnumType_Corpus EnumType_Corpus_Corpus_MAX = EnumType_Corpus_VIDEO;
+constexpr int EnumType_Corpus_Corpus_ARRAYSIZE = EnumType_Corpus_Corpus_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* EnumType_Corpus_descriptor();
+template<typename T>
+inline const std::string& EnumType_Corpus_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, EnumType_Corpus>::value ||
+ ::std::is_integral<T>::value,
+ "Incorrect type passed to function EnumType_Corpus_Name.");
+ return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+ EnumType_Corpus_descriptor(), enum_t_value);
+}
+inline bool EnumType_Corpus_Parse(
+ const std::string& name, EnumType_Corpus* value) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<EnumType_Corpus>(
+ EnumType_Corpus_descriptor(), name, value);
+}
+enum RepeatedEnumType_Corpus : int {
+ RepeatedEnumType_Corpus_UNIVERSAL = 0,
+ RepeatedEnumType_Corpus_WEB = 1,
+ RepeatedEnumType_Corpus_IMAGES = 2,
+ RepeatedEnumType_Corpus_LOCAL = 3,
+ RepeatedEnumType_Corpus_NEWS = 4,
+ RepeatedEnumType_Corpus_PRODUCTS = 5,
+ RepeatedEnumType_Corpus_VIDEO = 6,
+ RepeatedEnumType_Corpus_RepeatedEnumType_Corpus_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
+ RepeatedEnumType_Corpus_RepeatedEnumType_Corpus_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
+};
+bool RepeatedEnumType_Corpus_IsValid(int value);
+constexpr RepeatedEnumType_Corpus RepeatedEnumType_Corpus_Corpus_MIN = RepeatedEnumType_Corpus_UNIVERSAL;
+constexpr RepeatedEnumType_Corpus RepeatedEnumType_Corpus_Corpus_MAX = RepeatedEnumType_Corpus_VIDEO;
+constexpr int RepeatedEnumType_Corpus_Corpus_ARRAYSIZE = RepeatedEnumType_Corpus_Corpus_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* RepeatedEnumType_Corpus_descriptor();
+template<typename T>
+inline const std::string& RepeatedEnumType_Corpus_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, RepeatedEnumType_Corpus>::value ||
+ ::std::is_integral<T>::value,
+ "Incorrect type passed to function RepeatedEnumType_Corpus_Name.");
+ return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+ RepeatedEnumType_Corpus_descriptor(), enum_t_value);
+}
+inline bool RepeatedEnumType_Corpus_Parse(
+ const std::string& name, RepeatedEnumType_Corpus* value) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<RepeatedEnumType_Corpus>(
+ RepeatedEnumType_Corpus_descriptor(), name, value);
+}
+// ===================================================================
+
+class SimpleStruct :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:test.vereign.grpc.json.pb.SimpleStruct) */ {
+ public:
+ SimpleStruct();
+ virtual ~SimpleStruct();
+
+ SimpleStruct(const SimpleStruct& from);
+ SimpleStruct(SimpleStruct&& from) noexcept
+ : SimpleStruct() {
+ *this = ::std::move(from);
+ }
+
+ inline SimpleStruct& operator=(const SimpleStruct& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline SimpleStruct& operator=(SimpleStruct&& from) noexcept {
+ if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+ if (this != &from) InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return GetMetadataStatic().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return GetMetadataStatic().reflection;
+ }
+ static const SimpleStruct& default_instance();
+
+ static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
+ static inline const SimpleStruct* internal_default_instance() {
+ return reinterpret_cast<const SimpleStruct*>(
+ &_SimpleStruct_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 0;
+
+ friend void swap(SimpleStruct& a, SimpleStruct& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(SimpleStruct* other) {
+ if (other == this) return;
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline SimpleStruct* New() const final {
+ return CreateMaybeMessage<SimpleStruct>(nullptr);
+ }
+
+ SimpleStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<SimpleStruct>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const SimpleStruct& from);
+ void MergeFrom(const SimpleStruct& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ inline void SharedCtor();
+ inline void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(SimpleStruct* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "test.vereign.grpc.json.pb.SimpleStruct";
+ }
+ private:
+ inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+ return nullptr;
+ }
+ inline void* MaybeArenaPtr() const {
+ return nullptr;
+ }
+ public:
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_messages_2eproto);
+ return ::descriptor_table_messages_2eproto.file_level_metadata[kIndexInFileMessages];
+ }
+
+ public:
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kStringValueFieldNumber = 14,
+ kInt64ValueFieldNumber = 2,
+ kInt32ValueFieldNumber = 1,
+ kUint32ValueFieldNumber = 3,
+ kUint64ValueFieldNumber = 4,
+ kSint64ValueFieldNumber = 6,
+ kSint32ValueFieldNumber = 5,
+ kFixed32ValueFieldNumber = 7,
+ kFixed64ValueFieldNumber = 8,
+ kSfixed64ValueFieldNumber = 10,
+ kSfixed32ValueFieldNumber = 9,
+ kFloatValueFieldNumber = 11,
+ kDoubleValueFieldNumber = 12,
+ kBoolValueFieldNumber = 13,
+ };
+ // string string_value = 14;
+ void clear_string_value();
+ const std::string& string_value() const;
+ void set_string_value(const std::string& value);
+ void set_string_value(std::string&& value);
+ void set_string_value(const char* value);
+ void set_string_value(const char* value, size_t size);
+ std::string* mutable_string_value();
+ std::string* release_string_value();
+ void set_allocated_string_value(std::string* string_value);
+ private:
+ const std::string& _internal_string_value() const;
+ void _internal_set_string_value(const std::string& value);
+ std::string* _internal_mutable_string_value();
+ public:
+
+ // int64 int64_value = 2;
+ void clear_int64_value();
+ ::PROTOBUF_NAMESPACE_ID::int64 int64_value() const;
+ void set_int64_value(::PROTOBUF_NAMESPACE_ID::int64 value);
+ private:
+ ::PROTOBUF_NAMESPACE_ID::int64 _internal_int64_value() const;
+ void _internal_set_int64_value(::PROTOBUF_NAMESPACE_ID::int64 value);
+ public:
+
+ // int32 int32_value = 1;
+ void clear_int32_value();
+ ::PROTOBUF_NAMESPACE_ID::int32 int32_value() const;
+ void set_int32_value(::PROTOBUF_NAMESPACE_ID::int32 value);
+ private:
+ ::PROTOBUF_NAMESPACE_ID::int32 _internal_int32_value() const;
+ void _internal_set_int32_value(::PROTOBUF_NAMESPACE_ID::int32 value);
+ public:
+
+ // uint32 uint32_value = 3;
+ void clear_uint32_value();
+ ::PROTOBUF_NAMESPACE_ID::uint32 uint32_value() const;
+ void set_uint32_value(::PROTOBUF_NAMESPACE_ID::uint32 value);
+ private:
+ ::PROTOBUF_NAMESPACE_ID::uint32 _internal_uint32_value() const;
+ void _internal_set_uint32_value(::PROTOBUF_NAMESPACE_ID::uint32 value);
+ public:
+
+ // uint64 uint64_value = 4;
+ void clear_uint64_value();
+ ::PROTOBUF_NAMESPACE_ID::uint64 uint64_value() const;
+ void set_uint64_value(::PROTOBUF_NAMESPACE_ID::uint64 value);
+ private:
+ ::PROTOBUF_NAMESPACE_ID::uint64 _internal_uint64_value() const;
+ void _internal_set_uint64_value(::PROTOBUF_NAMESPACE_ID::uint64 value);
+ public:
+
+ // sint64 sint64_value = 6;
+ void clear_sint64_value();
+ ::PROTOBUF_NAMESPACE_ID::int64 sint64_value() const;
+ void set_sint64_value(::PROTOBUF_NAMESPACE_ID::int64 value);
+ private:
+ ::PROTOBUF_NAMESPACE_ID::int64 _internal_sint64_value() const;
+ void _internal_set_sint64_value(::PROTOBUF_NAMESPACE_ID::int64 value);
+ public:
+
+ // sint32 sint32_value = 5;
+ void clear_sint32_value();
+ ::PROTOBUF_NAMESPACE_ID::int32 sint32_value() const;
+ void set_sint32_value(::PROTOBUF_NAMESPACE_ID::int32 value);
+ private:
+ ::PROTOBUF_NAMESPACE_ID::int32 _internal_sint32_value() const;
+ void _internal_set_sint32_value(::PROTOBUF_NAMESPACE_ID::int32 value);
+ public:
+
+ // fixed32 fixed32_value = 7;
+ void clear_fixed32_value();
+ ::PROTOBUF_NAMESPACE_ID::uint32 fixed32_value() const;
+ void set_fixed32_value(::PROTOBUF_NAMESPACE_ID::uint32 value);
+ private:
+ ::PROTOBUF_NAMESPACE_ID::uint32 _internal_fixed32_value() const;
+ void _internal_set_fixed32_value(::PROTOBUF_NAMESPACE_ID::uint32 value);
+ public:
+
+ // fixed64 fixed64_value = 8;
+ void clear_fixed64_value();
+ ::PROTOBUF_NAMESPACE_ID::uint64 fixed64_value() const;
+ void set_fixed64_value(::PROTOBUF_NAMESPACE_ID::uint64 value);
+ private:
+ ::PROTOBUF_NAMESPACE_ID::uint64 _internal_fixed64_value() const;
+ void _internal_set_fixed64_value(::PROTOBUF_NAMESPACE_ID::uint64 value);
+ public:
+
+ // sfixed64 sfixed64_value = 10;
+ void clear_sfixed64_value();
+ ::PROTOBUF_NAMESPACE_ID::int64 sfixed64_value() const;
+ void set_sfixed64_value(::PROTOBUF_NAMESPACE_ID::int64 value);
+ private:
+ ::PROTOBUF_NAMESPACE_ID::int64 _internal_sfixed64_value() const;
+ void _internal_set_sfixed64_value(::PROTOBUF_NAMESPACE_ID::int64 value);
+ public:
+
+ // sfixed32 sfixed32_value = 9;
+ void clear_sfixed32_value();
+ ::PROTOBUF_NAMESPACE_ID::int32 sfixed32_value() const;
+ void set_sfixed32_value(::PROTOBUF_NAMESPACE_ID::int32 value);
+ private:
+ ::PROTOBUF_NAMESPACE_ID::int32 _internal_sfixed32_value() const;
+ void _internal_set_sfixed32_value(::PROTOBUF_NAMESPACE_ID::int32 value);
+ public:
+
+ // float float_value = 11;
+ void clear_float_value();
+ float float_value() const;
+ void set_float_value(float value);
+ private:
+ float _internal_float_value() const;
+ void _internal_set_float_value(float value);
+ public:
+
+ // double double_value = 12;
+ void clear_double_value();
+ double double_value() const;
+ void set_double_value(double value);
+ private:
+ double _internal_double_value() const;
+ void _internal_set_double_value(double value);
+ public:
+
+ // bool bool_value = 13;
+ void clear_bool_value();
+ bool bool_value() const;
+ void set_bool_value(bool value);
+ private:
+ bool _internal_bool_value() const;
+ void _internal_set_bool_value(bool value);
+ public:
+
+ // @@protoc_insertion_point(class_scope:test.vereign.grpc.json.pb.SimpleStruct)
+ private:
+ class _Internal;
+
+ ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_value_;
+ ::PROTOBUF_NAMESPACE_ID::int64 int64_value_;
+ ::PROTOBUF_NAMESPACE_ID::int32 int32_value_;
+ ::PROTOBUF_NAMESPACE_ID::uint32 uint32_value_;
+ ::PROTOBUF_NAMESPACE_ID::uint64 uint64_value_;
+ ::PROTOBUF_NAMESPACE_ID::int64 sint64_value_;
+ ::PROTOBUF_NAMESPACE_ID::int32 sint32_value_;
+ ::PROTOBUF_NAMESPACE_ID::uint32 fixed32_value_;
+ ::PROTOBUF_NAMESPACE_ID::uint64 fixed64_value_;
+ ::PROTOBUF_NAMESPACE_ID::int64 sfixed64_value_;
+ ::PROTOBUF_NAMESPACE_ID::int32 sfixed32_value_;
+ float float_value_;
+ double double_value_;
+ bool bool_value_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class RepeatedTypes :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:test.vereign.grpc.json.pb.RepeatedTypes) */ {
+ public:
+ RepeatedTypes();
+ virtual ~RepeatedTypes();
+
+ RepeatedTypes(const RepeatedTypes& from);
+ RepeatedTypes(RepeatedTypes&& from) noexcept
+ : RepeatedTypes() {
+ *this = ::std::move(from);
+ }
+
+ inline RepeatedTypes& operator=(const RepeatedTypes& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline RepeatedTypes& operator=(RepeatedTypes&& from) noexcept {
+ if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+ if (this != &from) InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return GetMetadataStatic().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return GetMetadataStatic().reflection;
+ }
+ static const RepeatedTypes& default_instance();
+
+ static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
+ static inline const RepeatedTypes* internal_default_instance() {
+ return reinterpret_cast<const RepeatedTypes*>(
+ &_RepeatedTypes_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 1;
+
+ friend void swap(RepeatedTypes& a, RepeatedTypes& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(RepeatedTypes* other) {
+ if (other == this) return;
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline RepeatedTypes* New() const final {
+ return CreateMaybeMessage<RepeatedTypes>(nullptr);
+ }
+
+ RepeatedTypes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<RepeatedTypes>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const RepeatedTypes& from);
+ void MergeFrom(const RepeatedTypes& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ inline void SharedCtor();
+ inline void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(RepeatedTypes* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "test.vereign.grpc.json.pb.RepeatedTypes";
+ }
+ private:
+ inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+ return nullptr;
+ }
+ inline void* MaybeArenaPtr() const {
+ return nullptr;
+ }
+ public:
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_messages_2eproto);
+ return ::descriptor_table_messages_2eproto.file_level_metadata[kIndexInFileMessages];
+ }
+
+ public:
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kInt32ArrFieldNumber = 1,
+ kInt64ArrFieldNumber = 2,
+ kUint32ArrFieldNumber = 3,
+ kUint64ArrFieldNumber = 4,
+ kSint32ArrFieldNumber = 5,
+ kSint64ArrFieldNumber = 6,
+ kFixed32ArrFieldNumber = 7,
+ kFixed64ArrFieldNumber = 8,
+ kSfixed32ArrFieldNumber = 9,
+ kSfixed64ArrFieldNumber = 10,
+ kFloatArrFieldNumber = 11,
+ kDoubleArrFieldNumber = 12,
+ kBoolArrFieldNumber = 13,
+ kStringArrFieldNumber = 14,
+ };
+ // repeated int32 int32_arr = 1;
+ int int32_arr_size() const;
+ private:
+ int _internal_int32_arr_size() const;
+ public:
+ void clear_int32_arr();
+ private:
+ ::PROTOBUF_NAMESPACE_ID::int32 _internal_int32_arr(int index) const;
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
+ _internal_int32_arr() const;
+ void _internal_add_int32_arr(::PROTOBUF_NAMESPACE_ID::int32 value);
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
+ _internal_mutable_int32_arr();
+ public:
+ ::PROTOBUF_NAMESPACE_ID::int32 int32_arr(int index) const;
+ void set_int32_arr(int index, ::PROTOBUF_NAMESPACE_ID::int32 value);
+ void add_int32_arr(::PROTOBUF_NAMESPACE_ID::int32 value);
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
+ int32_arr() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
+ mutable_int32_arr();
+
+ // repeated int64 int64_arr = 2;
+ int int64_arr_size() const;
+ private:
+ int _internal_int64_arr_size() const;
+ public:
+ void clear_int64_arr();
+ private:
+ ::PROTOBUF_NAMESPACE_ID::int64 _internal_int64_arr(int index) const;
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
+ _internal_int64_arr() const;
+ void _internal_add_int64_arr(::PROTOBUF_NAMESPACE_ID::int64 value);
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
+ _internal_mutable_int64_arr();
+ public:
+ ::PROTOBUF_NAMESPACE_ID::int64 int64_arr(int index) const;
+ void set_int64_arr(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
+ void add_int64_arr(::PROTOBUF_NAMESPACE_ID::int64 value);
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
+ int64_arr() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
+ mutable_int64_arr();
+
+ // repeated uint32 uint32_arr = 3;
+ int uint32_arr_size() const;
+ private:
+ int _internal_uint32_arr_size() const;
+ public:
+ void clear_uint32_arr();
+ private:
+ ::PROTOBUF_NAMESPACE_ID::uint32 _internal_uint32_arr(int index) const;
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >&
+ _internal_uint32_arr() const;
+ void _internal_add_uint32_arr(::PROTOBUF_NAMESPACE_ID::uint32 value);
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >*
+ _internal_mutable_uint32_arr();
+ public:
+ ::PROTOBUF_NAMESPACE_ID::uint32 uint32_arr(int index) const;
+ void set_uint32_arr(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value);
+ void add_uint32_arr(::PROTOBUF_NAMESPACE_ID::uint32 value);
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >&
+ uint32_arr() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >*
+ mutable_uint32_arr();
+
+ // repeated uint64 uint64_arr = 4;
+ int uint64_arr_size() const;
+ private:
+ int _internal_uint64_arr_size() const;
+ public:
+ void clear_uint64_arr();
+ private:
+ ::PROTOBUF_NAMESPACE_ID::uint64 _internal_uint64_arr(int index) const;
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >&
+ _internal_uint64_arr() const;
+ void _internal_add_uint64_arr(::PROTOBUF_NAMESPACE_ID::uint64 value);
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >*
+ _internal_mutable_uint64_arr();
+ public:
+ ::PROTOBUF_NAMESPACE_ID::uint64 uint64_arr(int index) const;
+ void set_uint64_arr(int index, ::PROTOBUF_NAMESPACE_ID::uint64 value);
+ void add_uint64_arr(::PROTOBUF_NAMESPACE_ID::uint64 value);
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >&
+ uint64_arr() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >*
+ mutable_uint64_arr();
+
+ // repeated sint32 sint32_arr = 5;
+ int sint32_arr_size() const;
+ private:
+ int _internal_sint32_arr_size() const;
+ public:
+ void clear_sint32_arr();
+ private:
+ ::PROTOBUF_NAMESPACE_ID::int32 _internal_sint32_arr(int index) const;
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
+ _internal_sint32_arr() const;
+ void _internal_add_sint32_arr(::PROTOBUF_NAMESPACE_ID::int32 value);
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
+ _internal_mutable_sint32_arr();
+ public:
+ ::PROTOBUF_NAMESPACE_ID::int32 sint32_arr(int index) const;
+ void set_sint32_arr(int index, ::PROTOBUF_NAMESPACE_ID::int32 value);
+ void add_sint32_arr(::PROTOBUF_NAMESPACE_ID::int32 value);
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
+ sint32_arr() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
+ mutable_sint32_arr();
+
+ // repeated sint64 sint64_arr = 6;
+ int sint64_arr_size() const;
+ private:
+ int _internal_sint64_arr_size() const;
+ public:
+ void clear_sint64_arr();
+ private:
+ ::PROTOBUF_NAMESPACE_ID::int64 _internal_sint64_arr(int index) const;
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
+ _internal_sint64_arr() const;
+ void _internal_add_sint64_arr(::PROTOBUF_NAMESPACE_ID::int64 value);
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
+ _internal_mutable_sint64_arr();
+ public:
+ ::PROTOBUF_NAMESPACE_ID::int64 sint64_arr(int index) const;
+ void set_sint64_arr(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
+ void add_sint64_arr(::PROTOBUF_NAMESPACE_ID::int64 value);
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
+ sint64_arr() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
+ mutable_sint64_arr();
+
+ // repeated fixed32 fixed32_arr = 7;
+ int fixed32_arr_size() const;
+ private:
+ int _internal_fixed32_arr_size() const;
+ public:
+ void clear_fixed32_arr();
+ private:
+ ::PROTOBUF_NAMESPACE_ID::uint32 _internal_fixed32_arr(int index) const;
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >&
+ _internal_fixed32_arr() const;
+ void _internal_add_fixed32_arr(::PROTOBUF_NAMESPACE_ID::uint32 value);
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >*
+ _internal_mutable_fixed32_arr();
+ public:
+ ::PROTOBUF_NAMESPACE_ID::uint32 fixed32_arr(int index) const;
+ void set_fixed32_arr(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value);
+ void add_fixed32_arr(::PROTOBUF_NAMESPACE_ID::uint32 value);
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >&
+ fixed32_arr() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >*
+ mutable_fixed32_arr();
+
+ // repeated fixed64 fixed64_arr = 8;
+ int fixed64_arr_size() const;
+ private:
+ int _internal_fixed64_arr_size() const;
+ public:
+ void clear_fixed64_arr();
+ private:
+ ::PROTOBUF_NAMESPACE_ID::uint64 _internal_fixed64_arr(int index) const;
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >&
+ _internal_fixed64_arr() const;
+ void _internal_add_fixed64_arr(::PROTOBUF_NAMESPACE_ID::uint64 value);
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >*
+ _internal_mutable_fixed64_arr();
+ public:
+ ::PROTOBUF_NAMESPACE_ID::uint64 fixed64_arr(int index) const;
+ void set_fixed64_arr(int index, ::PROTOBUF_NAMESPACE_ID::uint64 value);
+ void add_fixed64_arr(::PROTOBUF_NAMESPACE_ID::uint64 value);
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >&
+ fixed64_arr() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >*
+ mutable_fixed64_arr();
+
+ // repeated sfixed32 sfixed32_arr = 9;
+ int sfixed32_arr_size() const;
+ private:
+ int _internal_sfixed32_arr_size() const;
+ public:
+ void clear_sfixed32_arr();
+ private:
+ ::PROTOBUF_NAMESPACE_ID::int32 _internal_sfixed32_arr(int index) const;
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
+ _internal_sfixed32_arr() const;
+ void _internal_add_sfixed32_arr(::PROTOBUF_NAMESPACE_ID::int32 value);
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
+ _internal_mutable_sfixed32_arr();
+ public:
+ ::PROTOBUF_NAMESPACE_ID::int32 sfixed32_arr(int index) const;
+ void set_sfixed32_arr(int index, ::PROTOBUF_NAMESPACE_ID::int32 value);
+ void add_sfixed32_arr(::PROTOBUF_NAMESPACE_ID::int32 value);
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
+ sfixed32_arr() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
+ mutable_sfixed32_arr();
+
+ // repeated sfixed64 sfixed64_arr = 10;
+ int sfixed64_arr_size() const;
+ private:
+ int _internal_sfixed64_arr_size() const;
+ public:
+ void clear_sfixed64_arr();
+ private:
+ ::PROTOBUF_NAMESPACE_ID::int64 _internal_sfixed64_arr(int index) const;
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
+ _internal_sfixed64_arr() const;
+ void _internal_add_sfixed64_arr(::PROTOBUF_NAMESPACE_ID::int64 value);
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
+ _internal_mutable_sfixed64_arr();
+ public:
+ ::PROTOBUF_NAMESPACE_ID::int64 sfixed64_arr(int index) const;
+ void set_sfixed64_arr(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
+ void add_sfixed64_arr(::PROTOBUF_NAMESPACE_ID::int64 value);
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
+ sfixed64_arr() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
+ mutable_sfixed64_arr();
+
+ // repeated float float_arr = 11;
+ int float_arr_size() const;
+ private:
+ int _internal_float_arr_size() const;
+ public:
+ void clear_float_arr();
+ private:
+ float _internal_float_arr(int index) const;
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
+ _internal_float_arr() const;
+ void _internal_add_float_arr(float value);
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
+ _internal_mutable_float_arr();
+ public:
+ float float_arr(int index) const;
+ void set_float_arr(int index, float value);
+ void add_float_arr(float value);
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
+ float_arr() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
+ mutable_float_arr();
+
+ // repeated double double_arr = 12;
+ int double_arr_size() const;
+ private:
+ int _internal_double_arr_size() const;
+ public:
+ void clear_double_arr();
+ private:
+ double _internal_double_arr(int index) const;
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
+ _internal_double_arr() const;
+ void _internal_add_double_arr(double value);
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
+ _internal_mutable_double_arr();
+ public:
+ double double_arr(int index) const;
+ void set_double_arr(int index, double value);
+ void add_double_arr(double value);
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
+ double_arr() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
+ mutable_double_arr();
+
+ // repeated bool bool_arr = 13;
+ int bool_arr_size() const;
+ private:
+ int _internal_bool_arr_size() const;
+ public:
+ void clear_bool_arr();
+ private:
+ bool _internal_bool_arr(int index) const;
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
+ _internal_bool_arr() const;
+ void _internal_add_bool_arr(bool value);
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
+ _internal_mutable_bool_arr();
+ public:
+ bool bool_arr(int index) const;
+ void set_bool_arr(int index, bool value);
+ void add_bool_arr(bool value);
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
+ bool_arr() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
+ mutable_bool_arr();
+
+ // repeated string string_arr = 14;
+ int string_arr_size() const;
+ private:
+ int _internal_string_arr_size() const;
+ public:
+ void clear_string_arr();
+ const std::string& string_arr(int index) const;
+ std::string* mutable_string_arr(int index);
+ void set_string_arr(int index, const std::string& value);
+ void set_string_arr(int index, std::string&& value);
+ void set_string_arr(int index, const char* value);
+ void set_string_arr(int index, const char* value, size_t size);
+ std::string* add_string_arr();
+ void add_string_arr(const std::string& value);
+ void add_string_arr(std::string&& value);
+ void add_string_arr(const char* value);
+ void add_string_arr(const char* value, size_t size);
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& string_arr() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_string_arr();
+ private:
+ const std::string& _internal_string_arr(int index) const;
+ std::string* _internal_add_string_arr();
+ public:
+
+ // @@protoc_insertion_point(class_scope:test.vereign.grpc.json.pb.RepeatedTypes)
+ private:
+ class _Internal;
+
+ ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > int32_arr_;
+ mutable std::atomic<int> _int32_arr_cached_byte_size_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > int64_arr_;
+ mutable std::atomic<int> _int64_arr_cached_byte_size_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 > uint32_arr_;
+ mutable std::atomic<int> _uint32_arr_cached_byte_size_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 > uint64_arr_;
+ mutable std::atomic<int> _uint64_arr_cached_byte_size_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > sint32_arr_;
+ mutable std::atomic<int> _sint32_arr_cached_byte_size_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > sint64_arr_;
+ mutable std::atomic<int> _sint64_arr_cached_byte_size_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 > fixed32_arr_;
+ mutable std::atomic<int> _fixed32_arr_cached_byte_size_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 > fixed64_arr_;
+ mutable std::atomic<int> _fixed64_arr_cached_byte_size_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > sfixed32_arr_;
+ mutable std::atomic<int> _sfixed32_arr_cached_byte_size_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > sfixed64_arr_;
+ mutable std::atomic<int> _sfixed64_arr_cached_byte_size_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > float_arr_;
+ mutable std::atomic<int> _float_arr_cached_byte_size_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > double_arr_;
+ mutable std::atomic<int> _double_arr_cached_byte_size_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool > bool_arr_;
+ mutable std::atomic<int> _bool_arr_cached_byte_size_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> string_arr_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Bar :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:test.vereign.grpc.json.pb.Bar) */ {
+ public:
+ Bar();
+ virtual ~Bar();
+
+ Bar(const Bar& from);
+ Bar(Bar&& from) noexcept
+ : Bar() {
+ *this = ::std::move(from);
+ }
+
+ inline Bar& operator=(const Bar& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline Bar& operator=(Bar&& from) noexcept {
+ if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+ if (this != &from) InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return GetMetadataStatic().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return GetMetadataStatic().reflection;
+ }
+ static const Bar& default_instance();
+
+ static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
+ static inline const Bar* internal_default_instance() {
+ return reinterpret_cast<const Bar*>(
+ &_Bar_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 2;
+
+ friend void swap(Bar& a, Bar& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(Bar* other) {
+ if (other == this) return;
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline Bar* New() const final {
+ return CreateMaybeMessage<Bar>(nullptr);
+ }
+
+ Bar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<Bar>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const Bar& from);
+ void MergeFrom(const Bar& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ inline void SharedCtor();
+ inline void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(Bar* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "test.vereign.grpc.json.pb.Bar";
+ }
+ private:
+ inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+ return nullptr;
+ }
+ inline void* MaybeArenaPtr() const {
+ return nullptr;
+ }
+ public:
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_messages_2eproto);
+ return ::descriptor_table_messages_2eproto.file_level_metadata[kIndexInFileMessages];
+ }
+
+ public:
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kValueFieldNumber = 2,
+ };
+ // string value = 2;
+ void clear_value();
+ const std::string& value() const;
+ void set_value(const std::string& value);
+ void set_value(std::string&& value);
+ void set_value(const char* value);
+ void set_value(const char* value, size_t size);
+ std::string* mutable_value();
+ std::string* release_value();
+ void set_allocated_value(std::string* value);
+ private:
+ const std::string& _internal_value() const;
+ void _internal_set_value(const std::string& value);
+ std::string* _internal_mutable_value();
+ public:
+
+ // @@protoc_insertion_point(class_scope:test.vereign.grpc.json.pb.Bar)
+ private:
+ class _Internal;
+
+ ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Foo :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:test.vereign.grpc.json.pb.Foo) */ {
+ public:
+ Foo();
+ virtual ~Foo();
+
+ Foo(const Foo& from);
+ Foo(Foo&& from) noexcept
+ : Foo() {
+ *this = ::std::move(from);
+ }
+
+ inline Foo& operator=(const Foo& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline Foo& operator=(Foo&& from) noexcept {
+ if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+ if (this != &from) InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return GetMetadataStatic().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return GetMetadataStatic().reflection;
+ }
+ static const Foo& default_instance();
+
+ static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
+ static inline const Foo* internal_default_instance() {
+ return reinterpret_cast<const Foo*>(
+ &_Foo_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 3;
+
+ friend void swap(Foo& a, Foo& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(Foo* other) {
+ if (other == this) return;
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline Foo* New() const final {
+ return CreateMaybeMessage<Foo>(nullptr);
+ }
+
+ Foo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<Foo>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const Foo& from);
+ void MergeFrom(const Foo& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ inline void SharedCtor();
+ inline void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(Foo* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "test.vereign.grpc.json.pb.Foo";
+ }
+ private:
+ inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+ return nullptr;
+ }
+ inline void* MaybeArenaPtr() const {
+ return nullptr;
+ }
+ public:
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_messages_2eproto);
+ return ::descriptor_table_messages_2eproto.file_level_metadata[kIndexInFileMessages];
+ }
+
+ public:
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kValueFieldNumber = 1,
+ kBarFieldNumber = 2,
+ };
+ // string value = 1;
+ void clear_value();
+ const std::string& value() const;
+ void set_value(const std::string& value);
+ void set_value(std::string&& value);
+ void set_value(const char* value);
+ void set_value(const char* value, size_t size);
+ std::string* mutable_value();
+ std::string* release_value();
+ void set_allocated_value(std::string* value);
+ private:
+ const std::string& _internal_value() const;
+ void _internal_set_value(const std::string& value);
+ std::string* _internal_mutable_value();
+ public:
+
+ // .test.vereign.grpc.json.pb.Bar bar = 2;
+ bool has_bar() const;
+ private:
+ bool _internal_has_bar() const;
+ public:
+ void clear_bar();
+ const ::test::vereign::grpc::json::pb::Bar& bar() const;
+ ::test::vereign::grpc::json::pb::Bar* release_bar();
+ ::test::vereign::grpc::json::pb::Bar* mutable_bar();
+ void set_allocated_bar(::test::vereign::grpc::json::pb::Bar* bar);
+ private:
+ const ::test::vereign::grpc::json::pb::Bar& _internal_bar() const;
+ ::test::vereign::grpc::json::pb::Bar* _internal_mutable_bar();
+ public:
+
+ // @@protoc_insertion_point(class_scope:test.vereign.grpc.json.pb.Foo)
+ private:
+ class _Internal;
+
+ ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
+ ::test::vereign::grpc::json::pb::Bar* bar_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MessageType :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:test.vereign.grpc.json.pb.MessageType) */ {
+ public:
+ MessageType();
+ virtual ~MessageType();
+
+ MessageType(const MessageType& from);
+ MessageType(MessageType&& from) noexcept
+ : MessageType() {
+ *this = ::std::move(from);
+ }
+
+ inline MessageType& operator=(const MessageType& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline MessageType& operator=(MessageType&& from) noexcept {
+ if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+ if (this != &from) InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return GetMetadataStatic().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return GetMetadataStatic().reflection;
+ }
+ static const MessageType& default_instance();
+
+ static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
+ static inline const MessageType* internal_default_instance() {
+ return reinterpret_cast<const MessageType*>(
+ &_MessageType_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 4;
+
+ friend void swap(MessageType& a, MessageType& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(MessageType* other) {
+ if (other == this) return;
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline MessageType* New() const final {
+ return CreateMaybeMessage<MessageType>(nullptr);
+ }
+
+ MessageType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<MessageType>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const MessageType& from);
+ void MergeFrom(const MessageType& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ inline void SharedCtor();
+ inline void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(MessageType* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "test.vereign.grpc.json.pb.MessageType";
+ }
+ private:
+ inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+ return nullptr;
+ }
+ inline void* MaybeArenaPtr() const {
+ return nullptr;
+ }
+ public:
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_messages_2eproto);
+ return ::descriptor_table_messages_2eproto.file_level_metadata[kIndexInFileMessages];
+ }
+
+ public:
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kFooArrFieldNumber = 2,
+ kFooFieldNumber = 1,
+ };
+ // repeated .test.vereign.grpc.json.pb.Foo foo_arr = 2;
+ int foo_arr_size() const;
+ private:
+ int _internal_foo_arr_size() const;
+ public:
+ void clear_foo_arr();
+ ::test::vereign::grpc::json::pb::Foo* mutable_foo_arr(int index);
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::test::vereign::grpc::json::pb::Foo >*
+ mutable_foo_arr();
+ private:
+ const ::test::vereign::grpc::json::pb::Foo& _internal_foo_arr(int index) const;
+ ::test::vereign::grpc::json::pb::Foo* _internal_add_foo_arr();
+ public:
+ const ::test::vereign::grpc::json::pb::Foo& foo_arr(int index) const;
+ ::test::vereign::grpc::json::pb::Foo* add_foo_arr();
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::test::vereign::grpc::json::pb::Foo >&
+ foo_arr() const;
+
+ // .test.vereign.grpc.json.pb.Foo foo = 1;
+ bool has_foo() const;
+ private:
+ bool _internal_has_foo() const;
+ public:
+ void clear_foo();
+ const ::test::vereign::grpc::json::pb::Foo& foo() const;
+ ::test::vereign::grpc::json::pb::Foo* release_foo();
+ ::test::vereign::grpc::json::pb::Foo* mutable_foo();
+ void set_allocated_foo(::test::vereign::grpc::json::pb::Foo* foo);
+ private:
+ const ::test::vereign::grpc::json::pb::Foo& _internal_foo() const;
+ ::test::vereign::grpc::json::pb::Foo* _internal_mutable_foo();
+ public:
+
+ // @@protoc_insertion_point(class_scope:test.vereign.grpc.json.pb.MessageType)
+ private:
+ class _Internal;
+
+ ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::test::vereign::grpc::json::pb::Foo > foo_arr_;
+ ::test::vereign::grpc::json::pb::Foo* foo_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MapType_Int32KeyEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapType_Int32KeyEntry_DoNotUse,
+ ::PROTOBUF_NAMESPACE_ID::int32, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > {
+public:
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapType_Int32KeyEntry_DoNotUse,
+ ::PROTOBUF_NAMESPACE_ID::int32, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > SuperType;
+ MapType_Int32KeyEntry_DoNotUse();
+ MapType_Int32KeyEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ void MergeFrom(const MapType_Int32KeyEntry_DoNotUse& other);
+ static const MapType_Int32KeyEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const MapType_Int32KeyEntry_DoNotUse*>(&_MapType_Int32KeyEntry_DoNotUse_default_instance_); }
+ static bool ValidateKey(void*) { return true; }
+ static bool ValidateValue(std::string* s) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "test.vereign.grpc.json.pb.MapType.Int32KeyEntry.value");
+ }
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& other) final;
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_messages_2eproto);
+ return ::descriptor_table_messages_2eproto.file_level_metadata[5];
+ }
+
+ public:
+};
+
+// -------------------------------------------------------------------
+
+class MapType_Int64KeyEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapType_Int64KeyEntry_DoNotUse,
+ ::PROTOBUF_NAMESPACE_ID::int64, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > {
+public:
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapType_Int64KeyEntry_DoNotUse,
+ ::PROTOBUF_NAMESPACE_ID::int64, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > SuperType;
+ MapType_Int64KeyEntry_DoNotUse();
+ MapType_Int64KeyEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ void MergeFrom(const MapType_Int64KeyEntry_DoNotUse& other);
+ static const MapType_Int64KeyEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const MapType_Int64KeyEntry_DoNotUse*>(&_MapType_Int64KeyEntry_DoNotUse_default_instance_); }
+ static bool ValidateKey(void*) { return true; }
+ static bool ValidateValue(std::string* s) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "test.vereign.grpc.json.pb.MapType.Int64KeyEntry.value");
+ }
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& other) final;
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_messages_2eproto);
+ return ::descriptor_table_messages_2eproto.file_level_metadata[6];
+ }
+
+ public:
+};
+
+// -------------------------------------------------------------------
+
+class MapType_Uint32KeyEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapType_Uint32KeyEntry_DoNotUse,
+ ::PROTOBUF_NAMESPACE_ID::uint32, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > {
+public:
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapType_Uint32KeyEntry_DoNotUse,
+ ::PROTOBUF_NAMESPACE_ID::uint32, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > SuperType;
+ MapType_Uint32KeyEntry_DoNotUse();
+ MapType_Uint32KeyEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ void MergeFrom(const MapType_Uint32KeyEntry_DoNotUse& other);
+ static const MapType_Uint32KeyEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const MapType_Uint32KeyEntry_DoNotUse*>(&_MapType_Uint32KeyEntry_DoNotUse_default_instance_); }
+ static bool ValidateKey(void*) { return true; }
+ static bool ValidateValue(std::string* s) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "test.vereign.grpc.json.pb.MapType.Uint32KeyEntry.value");
+ }
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& other) final;
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_messages_2eproto);
+ return ::descriptor_table_messages_2eproto.file_level_metadata[7];
+ }
+
+ public:
+};
+
+// -------------------------------------------------------------------
+
+class MapType_Uint64KeyEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapType_Uint64KeyEntry_DoNotUse,
+ ::PROTOBUF_NAMESPACE_ID::uint64, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > {
+public:
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapType_Uint64KeyEntry_DoNotUse,
+ ::PROTOBUF_NAMESPACE_ID::uint64, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > SuperType;
+ MapType_Uint64KeyEntry_DoNotUse();
+ MapType_Uint64KeyEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ void MergeFrom(const MapType_Uint64KeyEntry_DoNotUse& other);
+ static const MapType_Uint64KeyEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const MapType_Uint64KeyEntry_DoNotUse*>(&_MapType_Uint64KeyEntry_DoNotUse_default_instance_); }
+ static bool ValidateKey(void*) { return true; }
+ static bool ValidateValue(std::string* s) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "test.vereign.grpc.json.pb.MapType.Uint64KeyEntry.value");
+ }
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& other) final;
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_messages_2eproto);
+ return ::descriptor_table_messages_2eproto.file_level_metadata[8];
+ }
+
+ public:
+};
+
+// -------------------------------------------------------------------
+
+class MapType_Sint32KeyEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapType_Sint32KeyEntry_DoNotUse,
+ ::PROTOBUF_NAMESPACE_ID::int32, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_SINT32,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > {
+public:
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapType_Sint32KeyEntry_DoNotUse,
+ ::PROTOBUF_NAMESPACE_ID::int32, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_SINT32,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > SuperType;
+ MapType_Sint32KeyEntry_DoNotUse();
+ MapType_Sint32KeyEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ void MergeFrom(const MapType_Sint32KeyEntry_DoNotUse& other);
+ static const MapType_Sint32KeyEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const MapType_Sint32KeyEntry_DoNotUse*>(&_MapType_Sint32KeyEntry_DoNotUse_default_instance_); }
+ static bool ValidateKey(void*) { return true; }
+ static bool ValidateValue(std::string* s) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "test.vereign.grpc.json.pb.MapType.Sint32KeyEntry.value");
+ }
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& other) final;
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_messages_2eproto);
+ return ::descriptor_table_messages_2eproto.file_level_metadata[9];
+ }
+
+ public:
+};
+
+// -------------------------------------------------------------------
+
+class MapType_Sint64KeyEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapType_Sint64KeyEntry_DoNotUse,
+ ::PROTOBUF_NAMESPACE_ID::int64, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_SINT64,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > {
+public:
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapType_Sint64KeyEntry_DoNotUse,
+ ::PROTOBUF_NAMESPACE_ID::int64, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_SINT64,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > SuperType;
+ MapType_Sint64KeyEntry_DoNotUse();
+ MapType_Sint64KeyEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ void MergeFrom(const MapType_Sint64KeyEntry_DoNotUse& other);
+ static const MapType_Sint64KeyEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const MapType_Sint64KeyEntry_DoNotUse*>(&_MapType_Sint64KeyEntry_DoNotUse_default_instance_); }
+ static bool ValidateKey(void*) { return true; }
+ static bool ValidateValue(std::string* s) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "test.vereign.grpc.json.pb.MapType.Sint64KeyEntry.value");
+ }
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& other) final;
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_messages_2eproto);
+ return ::descriptor_table_messages_2eproto.file_level_metadata[10];
+ }
+
+ public:
+};
+
+// -------------------------------------------------------------------
+
+class MapType_Fixed32KeyEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapType_Fixed32KeyEntry_DoNotUse,
+ ::PROTOBUF_NAMESPACE_ID::uint32, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FIXED32,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > {
+public:
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapType_Fixed32KeyEntry_DoNotUse,
+ ::PROTOBUF_NAMESPACE_ID::uint32, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FIXED32,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > SuperType;
+ MapType_Fixed32KeyEntry_DoNotUse();
+ MapType_Fixed32KeyEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ void MergeFrom(const MapType_Fixed32KeyEntry_DoNotUse& other);
+ static const MapType_Fixed32KeyEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const MapType_Fixed32KeyEntry_DoNotUse*>(&_MapType_Fixed32KeyEntry_DoNotUse_default_instance_); }
+ static bool ValidateKey(void*) { return true; }
+ static bool ValidateValue(std::string* s) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "test.vereign.grpc.json.pb.MapType.Fixed32KeyEntry.value");
+ }
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& other) final;
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_messages_2eproto);
+ return ::descriptor_table_messages_2eproto.file_level_metadata[11];
+ }
+
+ public:
+};
+
+// -------------------------------------------------------------------
+
+class MapType_Fixed64KeyEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapType_Fixed64KeyEntry_DoNotUse,
+ ::PROTOBUF_NAMESPACE_ID::uint64, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FIXED64,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > {
+public:
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapType_Fixed64KeyEntry_DoNotUse,
+ ::PROTOBUF_NAMESPACE_ID::uint64, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FIXED64,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > SuperType;
+ MapType_Fixed64KeyEntry_DoNotUse();
+ MapType_Fixed64KeyEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ void MergeFrom(const MapType_Fixed64KeyEntry_DoNotUse& other);
+ static const MapType_Fixed64KeyEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const MapType_Fixed64KeyEntry_DoNotUse*>(&_MapType_Fixed64KeyEntry_DoNotUse_default_instance_); }
+ static bool ValidateKey(void*) { return true; }
+ static bool ValidateValue(std::string* s) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "test.vereign.grpc.json.pb.MapType.Fixed64KeyEntry.value");
+ }
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& other) final;
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_messages_2eproto);
+ return ::descriptor_table_messages_2eproto.file_level_metadata[12];
+ }
+
+ public:
+};
+
+// -------------------------------------------------------------------
+
+class MapType_Sfixed32KeyEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapType_Sfixed32KeyEntry_DoNotUse,
+ ::PROTOBUF_NAMESPACE_ID::int32, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_SFIXED32,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > {
+public:
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapType_Sfixed32KeyEntry_DoNotUse,
+ ::PROTOBUF_NAMESPACE_ID::int32, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_SFIXED32,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > SuperType;
+ MapType_Sfixed32KeyEntry_DoNotUse();
+ MapType_Sfixed32KeyEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ void MergeFrom(const MapType_Sfixed32KeyEntry_DoNotUse& other);
+ static const MapType_Sfixed32KeyEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const MapType_Sfixed32KeyEntry_DoNotUse*>(&_MapType_Sfixed32KeyEntry_DoNotUse_default_instance_); }
+ static bool ValidateKey(void*) { return true; }
+ static bool ValidateValue(std::string* s) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "test.vereign.grpc.json.pb.MapType.Sfixed32KeyEntry.value");
+ }
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& other) final;
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_messages_2eproto);
+ return ::descriptor_table_messages_2eproto.file_level_metadata[13];
+ }
+
+ public:
+};
+
+// -------------------------------------------------------------------
+
+class MapType_Sfixed64KeyEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapType_Sfixed64KeyEntry_DoNotUse,
+ ::PROTOBUF_NAMESPACE_ID::int64, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_SFIXED64,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > {
+public:
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapType_Sfixed64KeyEntry_DoNotUse,
+ ::PROTOBUF_NAMESPACE_ID::int64, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_SFIXED64,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > SuperType;
+ MapType_Sfixed64KeyEntry_DoNotUse();
+ MapType_Sfixed64KeyEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ void MergeFrom(const MapType_Sfixed64KeyEntry_DoNotUse& other);
+ static const MapType_Sfixed64KeyEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const MapType_Sfixed64KeyEntry_DoNotUse*>(&_MapType_Sfixed64KeyEntry_DoNotUse_default_instance_); }
+ static bool ValidateKey(void*) { return true; }
+ static bool ValidateValue(std::string* s) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "test.vereign.grpc.json.pb.MapType.Sfixed64KeyEntry.value");
+ }
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& other) final;
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_messages_2eproto);
+ return ::descriptor_table_messages_2eproto.file_level_metadata[14];
+ }
+
+ public:
+};
+
+// -------------------------------------------------------------------
+
+class MapType_StringKeyEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapType_StringKeyEntry_DoNotUse,
+ std::string, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > {
+public:
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapType_StringKeyEntry_DoNotUse,
+ std::string, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > SuperType;
+ MapType_StringKeyEntry_DoNotUse();
+ MapType_StringKeyEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ void MergeFrom(const MapType_StringKeyEntry_DoNotUse& other);
+ static const MapType_StringKeyEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const MapType_StringKeyEntry_DoNotUse*>(&_MapType_StringKeyEntry_DoNotUse_default_instance_); }
+ static bool ValidateKey(std::string* s) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "test.vereign.grpc.json.pb.MapType.StringKeyEntry.key");
+ }
+ static bool ValidateValue(std::string* s) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "test.vereign.grpc.json.pb.MapType.StringKeyEntry.value");
+ }
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& other) final;
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_messages_2eproto);
+ return ::descriptor_table_messages_2eproto.file_level_metadata[15];
+ }
+
+ public:
+};
+
+// -------------------------------------------------------------------
+
+class MapType :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:test.vereign.grpc.json.pb.MapType) */ {
+ public:
+ MapType();
+ virtual ~MapType();
+
+ MapType(const MapType& from);
+ MapType(MapType&& from) noexcept
+ : MapType() {
+ *this = ::std::move(from);
+ }
+
+ inline MapType& operator=(const MapType& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline MapType& operator=(MapType&& from) noexcept {
+ if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+ if (this != &from) InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return GetMetadataStatic().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return GetMetadataStatic().reflection;
+ }
+ static const MapType& default_instance();
+
+ static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
+ static inline const MapType* internal_default_instance() {
+ return reinterpret_cast<const MapType*>(
+ &_MapType_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 16;
+
+ friend void swap(MapType& a, MapType& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(MapType* other) {
+ if (other == this) return;
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline MapType* New() const final {
+ return CreateMaybeMessage<MapType>(nullptr);
+ }
+
+ MapType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<MapType>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const MapType& from);
+ void MergeFrom(const MapType& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ inline void SharedCtor();
+ inline void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(MapType* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "test.vereign.grpc.json.pb.MapType";
+ }
+ private:
+ inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+ return nullptr;
+ }
+ inline void* MaybeArenaPtr() const {
+ return nullptr;
+ }
+ public:
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_messages_2eproto);
+ return ::descriptor_table_messages_2eproto.file_level_metadata[kIndexInFileMessages];
+ }
+
+ public:
+
+ // nested types ----------------------------------------------------
+
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kInt32KeyFieldNumber = 1,
+ kInt64KeyFieldNumber = 2,
+ kUint32KeyFieldNumber = 3,
+ kUint64KeyFieldNumber = 4,
+ kSint32KeyFieldNumber = 5,
+ kSint64KeyFieldNumber = 6,
+ kFixed32KeyFieldNumber = 7,
+ kFixed64KeyFieldNumber = 8,
+ kSfixed32KeyFieldNumber = 9,
+ kSfixed64KeyFieldNumber = 10,
+ kStringKeyFieldNumber = 11,
+ };
+ // map<int32, string> int32_key = 1;
+ int int32_key_size() const;
+ private:
+ int _internal_int32_key_size() const;
+ public:
+ void clear_int32_key();
+ private:
+ const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >&
+ _internal_int32_key() const;
+ ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >*
+ _internal_mutable_int32_key();
+ public:
+ const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >&
+ int32_key() const;
+ ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >*
+ mutable_int32_key();
+
+ // map<int64, string> int64_key = 2;
+ int int64_key_size() const;
+ private:
+ int _internal_int64_key_size() const;
+ public:
+ void clear_int64_key();
+ private:
+ const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >&
+ _internal_int64_key() const;
+ ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >*
+ _internal_mutable_int64_key();
+ public:
+ const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >&
+ int64_key() const;
+ ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >*
+ mutable_int64_key();
+
+ // map<uint32, string> uint32_key = 3;
+ int uint32_key_size() const;
+ private:
+ int _internal_uint32_key_size() const;
+ public:
+ void clear_uint32_key();
+ private:
+ const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint32, std::string >&
+ _internal_uint32_key() const;
+ ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint32, std::string >*
+ _internal_mutable_uint32_key();
+ public:
+ const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint32, std::string >&
+ uint32_key() const;
+ ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint32, std::string >*
+ mutable_uint32_key();
+
+ // map<uint64, string> uint64_key = 4;
+ int uint64_key_size() const;
+ private:
+ int _internal_uint64_key_size() const;
+ public:
+ void clear_uint64_key();
+ private:
+ const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, std::string >&
+ _internal_uint64_key() const;
+ ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, std::string >*
+ _internal_mutable_uint64_key();
+ public:
+ const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, std::string >&
+ uint64_key() const;
+ ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, std::string >*
+ mutable_uint64_key();
+
+ // map<sint32, string> sint32_key = 5;
+ int sint32_key_size() const;
+ private:
+ int _internal_sint32_key_size() const;
+ public:
+ void clear_sint32_key();
+ private:
+ const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >&
+ _internal_sint32_key() const;
+ ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >*
+ _internal_mutable_sint32_key();
+ public:
+ const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >&
+ sint32_key() const;
+ ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >*
+ mutable_sint32_key();
+
+ // map<sint64, string> sint64_key = 6;
+ int sint64_key_size() const;
+ private:
+ int _internal_sint64_key_size() const;
+ public:
+ void clear_sint64_key();
+ private:
+ const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >&
+ _internal_sint64_key() const;
+ ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >*
+ _internal_mutable_sint64_key();
+ public:
+ const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >&
+ sint64_key() const;
+ ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >*
+ mutable_sint64_key();
+
+ // map<fixed32, string> fixed32_key = 7;
+ int fixed32_key_size() const;
+ private:
+ int _internal_fixed32_key_size() const;
+ public:
+ void clear_fixed32_key();
+ private:
+ const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint32, std::string >&
+ _internal_fixed32_key() const;
+ ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint32, std::string >*
+ _internal_mutable_fixed32_key();
+ public:
+ const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint32, std::string >&
+ fixed32_key() const;
+ ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint32, std::string >*
+ mutable_fixed32_key();
+
+ // map<fixed64, string> fixed64_key = 8;
+ int fixed64_key_size() const;
+ private:
+ int _internal_fixed64_key_size() const;
+ public:
+ void clear_fixed64_key();
+ private:
+ const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, std::string >&
+ _internal_fixed64_key() const;
+ ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, std::string >*
+ _internal_mutable_fixed64_key();
+ public:
+ const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, std::string >&
+ fixed64_key() const;
+ ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, std::string >*
+ mutable_fixed64_key();
+
+ // map<sfixed32, string> sfixed32_key = 9;
+ int sfixed32_key_size() const;
+ private:
+ int _internal_sfixed32_key_size() const;
+ public:
+ void clear_sfixed32_key();
+ private:
+ const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >&
+ _internal_sfixed32_key() const;
+ ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >*
+ _internal_mutable_sfixed32_key();
+ public:
+ const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >&
+ sfixed32_key() const;
+ ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >*
+ mutable_sfixed32_key();
+
+ // map<sfixed64, string> sfixed64_key = 10;
+ int sfixed64_key_size() const;
+ private:
+ int _internal_sfixed64_key_size() const;
+ public:
+ void clear_sfixed64_key();
+ private:
+ const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >&
+ _internal_sfixed64_key() const;
+ ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >*
+ _internal_mutable_sfixed64_key();
+ public:
+ const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >&
+ sfixed64_key() const;
+ ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >*
+ mutable_sfixed64_key();
+
+ // map<string, string> string_key = 11;
+ int string_key_size() const;
+ private:
+ int _internal_string_key_size() const;
+ public:
+ void clear_string_key();
+ private:
+ const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
+ _internal_string_key() const;
+ ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
+ _internal_mutable_string_key();
+ public:
+ const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
+ string_key() const;
+ ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
+ mutable_string_key();
+
+ // @@protoc_insertion_point(class_scope:test.vereign.grpc.json.pb.MapType)
+ private:
+ class _Internal;
+
+ ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+ ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+ MapType_Int32KeyEntry_DoNotUse,
+ ::PROTOBUF_NAMESPACE_ID::int32, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > int32_key_;
+ ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+ MapType_Int64KeyEntry_DoNotUse,
+ ::PROTOBUF_NAMESPACE_ID::int64, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > int64_key_;
+ ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+ MapType_Uint32KeyEntry_DoNotUse,
+ ::PROTOBUF_NAMESPACE_ID::uint32, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > uint32_key_;
+ ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+ MapType_Uint64KeyEntry_DoNotUse,
+ ::PROTOBUF_NAMESPACE_ID::uint64, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > uint64_key_;
+ ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+ MapType_Sint32KeyEntry_DoNotUse,
+ ::PROTOBUF_NAMESPACE_ID::int32, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_SINT32,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > sint32_key_;
+ ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+ MapType_Sint64KeyEntry_DoNotUse,
+ ::PROTOBUF_NAMESPACE_ID::int64, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_SINT64,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > sint64_key_;
+ ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+ MapType_Fixed32KeyEntry_DoNotUse,
+ ::PROTOBUF_NAMESPACE_ID::uint32, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FIXED32,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > fixed32_key_;
+ ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+ MapType_Fixed64KeyEntry_DoNotUse,
+ ::PROTOBUF_NAMESPACE_ID::uint64, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FIXED64,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > fixed64_key_;
+ ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+ MapType_Sfixed32KeyEntry_DoNotUse,
+ ::PROTOBUF_NAMESPACE_ID::int32, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_SFIXED32,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > sfixed32_key_;
+ ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+ MapType_Sfixed64KeyEntry_DoNotUse,
+ ::PROTOBUF_NAMESPACE_ID::int64, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_SFIXED64,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > sfixed64_key_;
+ ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+ MapType_StringKeyEntry_DoNotUse,
+ std::string, std::string,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ 0 > string_key_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MapMessageType_MsgEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapMessageType_MsgEntry_DoNotUse,
+ std::string, ::test::vereign::grpc::json::pb::MessageType,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE,
+ 0 > {
+public:
+ typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MapMessageType_MsgEntry_DoNotUse,
+ std::string, ::test::vereign::grpc::json::pb::MessageType,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE,
+ 0 > SuperType;
+ MapMessageType_MsgEntry_DoNotUse();
+ MapMessageType_MsgEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ void MergeFrom(const MapMessageType_MsgEntry_DoNotUse& other);
+ static const MapMessageType_MsgEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const MapMessageType_MsgEntry_DoNotUse*>(&_MapMessageType_MsgEntry_DoNotUse_default_instance_); }
+ static bool ValidateKey(std::string* s) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "test.vereign.grpc.json.pb.MapMessageType.MsgEntry.key");
+ }
+ static bool ValidateValue(void*) { return true; }
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& other) final;
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_messages_2eproto);
+ return ::descriptor_table_messages_2eproto.file_level_metadata[17];
+ }
+
+ public:
+};
+
+// -------------------------------------------------------------------
+
+class MapMessageType :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:test.vereign.grpc.json.pb.MapMessageType) */ {
+ public:
+ MapMessageType();
+ virtual ~MapMessageType();
+
+ MapMessageType(const MapMessageType& from);
+ MapMessageType(MapMessageType&& from) noexcept
+ : MapMessageType() {
+ *this = ::std::move(from);
+ }
+
+ inline MapMessageType& operator=(const MapMessageType& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline MapMessageType& operator=(MapMessageType&& from) noexcept {
+ if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+ if (this != &from) InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return GetMetadataStatic().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return GetMetadataStatic().reflection;
+ }
+ static const MapMessageType& default_instance();
+
+ static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
+ static inline const MapMessageType* internal_default_instance() {
+ return reinterpret_cast<const MapMessageType*>(
+ &_MapMessageType_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 18;
+
+ friend void swap(MapMessageType& a, MapMessageType& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(MapMessageType* other) {
+ if (other == this) return;
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline MapMessageType* New() const final {
+ return CreateMaybeMessage<MapMessageType>(nullptr);
+ }
+
+ MapMessageType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<MapMessageType>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const MapMessageType& from);
+ void MergeFrom(const MapMessageType& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ inline void SharedCtor();
+ inline void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(MapMessageType* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "test.vereign.grpc.json.pb.MapMessageType";
+ }
+ private:
+ inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+ return nullptr;
+ }
+ inline void* MaybeArenaPtr() const {
+ return nullptr;
+ }
+ public:
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_messages_2eproto);
+ return ::descriptor_table_messages_2eproto.file_level_metadata[kIndexInFileMessages];
+ }
+
+ public:
+
+ // nested types ----------------------------------------------------
+
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kMsgFieldNumber = 1,
+ };
+ // map<string, .test.vereign.grpc.json.pb.MessageType> msg = 1;
+ int msg_size() const;
+ private:
+ int _internal_msg_size() const;
+ public:
+ void clear_msg();
+ private:
+ const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::test::vereign::grpc::json::pb::MessageType >&
+ _internal_msg() const;
+ ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::test::vereign::grpc::json::pb::MessageType >*
+ _internal_mutable_msg();
+ public:
+ const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::test::vereign::grpc::json::pb::MessageType >&
+ msg() const;
+ ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::test::vereign::grpc::json::pb::MessageType >*
+ mutable_msg();
+
+ // @@protoc_insertion_point(class_scope:test.vereign.grpc.json.pb.MapMessageType)
+ private:
+ class _Internal;
+
+ ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+ ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+ MapMessageType_MsgEntry_DoNotUse,
+ std::string, ::test::vereign::grpc::json::pb::MessageType,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE,
+ 0 > msg_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class BytesType :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:test.vereign.grpc.json.pb.BytesType) */ {
+ public:
+ BytesType();
+ virtual ~BytesType();
+
+ BytesType(const BytesType& from);
+ BytesType(BytesType&& from) noexcept
+ : BytesType() {
+ *this = ::std::move(from);
+ }
+
+ inline BytesType& operator=(const BytesType& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline BytesType& operator=(BytesType&& from) noexcept {
+ if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+ if (this != &from) InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return GetMetadataStatic().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return GetMetadataStatic().reflection;
+ }
+ static const BytesType& default_instance();
+
+ static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
+ static inline const BytesType* internal_default_instance() {
+ return reinterpret_cast<const BytesType*>(
+ &_BytesType_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 19;
+
+ friend void swap(BytesType& a, BytesType& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(BytesType* other) {
+ if (other == this) return;
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline BytesType* New() const final {
+ return CreateMaybeMessage<BytesType>(nullptr);
+ }
+
+ BytesType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<BytesType>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const BytesType& from);
+ void MergeFrom(const BytesType& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ inline void SharedCtor();
+ inline void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(BytesType* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "test.vereign.grpc.json.pb.BytesType";
+ }
+ private:
+ inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+ return nullptr;
+ }
+ inline void* MaybeArenaPtr() const {
+ return nullptr;
+ }
+ public:
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_messages_2eproto);
+ return ::descriptor_table_messages_2eproto.file_level_metadata[kIndexInFileMessages];
+ }
+
+ public:
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kBytesArrFieldNumber = 2,
+ kBytesValueFieldNumber = 1,
+ };
+ // repeated bytes bytes_arr = 2;
+ int bytes_arr_size() const;
+ private:
+ int _internal_bytes_arr_size() const;
+ public:
+ void clear_bytes_arr();
+ const std::string& bytes_arr(int index) const;
+ std::string* mutable_bytes_arr(int index);
+ void set_bytes_arr(int index, const std::string& value);
+ void set_bytes_arr(int index, std::string&& value);
+ void set_bytes_arr(int index, const char* value);
+ void set_bytes_arr(int index, const void* value, size_t size);
+ std::string* add_bytes_arr();
+ void add_bytes_arr(const std::string& value);
+ void add_bytes_arr(std::string&& value);
+ void add_bytes_arr(const char* value);
+ void add_bytes_arr(const void* value, size_t size);
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& bytes_arr() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_bytes_arr();
+ private:
+ const std::string& _internal_bytes_arr(int index) const;
+ std::string* _internal_add_bytes_arr();
+ public:
+
+ // bytes bytes_value = 1;
+ void clear_bytes_value();
+ const std::string& bytes_value() const;
+ void set_bytes_value(const std::string& value);
+ void set_bytes_value(std::string&& value);
+ void set_bytes_value(const char* value);
+ void set_bytes_value(const void* value, size_t size);
+ std::string* mutable_bytes_value();
+ std::string* release_bytes_value();
+ void set_allocated_bytes_value(std::string* bytes_value);
+ private:
+ const std::string& _internal_bytes_value() const;
+ void _internal_set_bytes_value(const std::string& value);
+ std::string* _internal_mutable_bytes_value();
+ public:
+
+ // @@protoc_insertion_point(class_scope:test.vereign.grpc.json.pb.BytesType)
+ private:
+ class _Internal;
+
+ ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> bytes_arr_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bytes_value_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class JsonNaming :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:test.vereign.grpc.json.pb.JsonNaming) */ {
+ public:
+ JsonNaming();
+ virtual ~JsonNaming();
+
+ JsonNaming(const JsonNaming& from);
+ JsonNaming(JsonNaming&& from) noexcept
+ : JsonNaming() {
+ *this = ::std::move(from);
+ }
+
+ inline JsonNaming& operator=(const JsonNaming& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline JsonNaming& operator=(JsonNaming&& from) noexcept {
+ if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+ if (this != &from) InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return GetMetadataStatic().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return GetMetadataStatic().reflection;
+ }
+ static const JsonNaming& default_instance();
+
+ static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
+ static inline const JsonNaming* internal_default_instance() {
+ return reinterpret_cast<const JsonNaming*>(
+ &_JsonNaming_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 20;
+
+ friend void swap(JsonNaming& a, JsonNaming& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(JsonNaming* other) {
+ if (other == this) return;
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline JsonNaming* New() const final {
+ return CreateMaybeMessage<JsonNaming>(nullptr);
+ }
+
+ JsonNaming* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<JsonNaming>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const JsonNaming& from);
+ void MergeFrom(const JsonNaming& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ inline void SharedCtor();
+ inline void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(JsonNaming* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "test.vereign.grpc.json.pb.JsonNaming";
+ }
+ private:
+ inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+ return nullptr;
+ }
+ inline void* MaybeArenaPtr() const {
+ return nullptr;
+ }
+ public:
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_messages_2eproto);
+ return ::descriptor_table_messages_2eproto.file_level_metadata[kIndexInFileMessages];
+ }
+
+ public:
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kFooValueFieldNumber = 1,
+ kBarValueFieldNumber = 2,
+ kBazValueFieldNumber = 3,
+ kQuXValueFieldNumber = 4,
+ };
+ // int32 foo_value = 1;
+ void clear_foo_value();
+ ::PROTOBUF_NAMESPACE_ID::int32 foo_value() const;
+ void set_foo_value(::PROTOBUF_NAMESPACE_ID::int32 value);
+ private:
+ ::PROTOBUF_NAMESPACE_ID::int32 _internal_foo_value() const;
+ void _internal_set_foo_value(::PROTOBUF_NAMESPACE_ID::int32 value);
+ public:
+
+ // int32 barValue = 2;
+ void clear_barvalue();
+ ::PROTOBUF_NAMESPACE_ID::int32 barvalue() const;
+ void set_barvalue(::PROTOBUF_NAMESPACE_ID::int32 value);
+ private:
+ ::PROTOBUF_NAMESPACE_ID::int32 _internal_barvalue() const;
+ void _internal_set_barvalue(::PROTOBUF_NAMESPACE_ID::int32 value);
+ public:
+
+ // int32 BazValue = 3;
+ void clear_bazvalue();
+ ::PROTOBUF_NAMESPACE_ID::int32 bazvalue() const;
+ void set_bazvalue(::PROTOBUF_NAMESPACE_ID::int32 value);
+ private:
+ ::PROTOBUF_NAMESPACE_ID::int32 _internal_bazvalue() const;
+ void _internal_set_bazvalue(::PROTOBUF_NAMESPACE_ID::int32 value);
+ public:
+
+ // int32 quX_Value = 4;
+ void clear_qux_value();
+ ::PROTOBUF_NAMESPACE_ID::int32 qux_value() const;
+ void set_qux_value(::PROTOBUF_NAMESPACE_ID::int32 value);
+ private:
+ ::PROTOBUF_NAMESPACE_ID::int32 _internal_qux_value() const;
+ void _internal_set_qux_value(::PROTOBUF_NAMESPACE_ID::int32 value);
+ public:
+
+ // @@protoc_insertion_point(class_scope:test.vereign.grpc.json.pb.JsonNaming)
+ private:
+ class _Internal;
+
+ ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+ ::PROTOBUF_NAMESPACE_ID::int32 foo_value_;
+ ::PROTOBUF_NAMESPACE_ID::int32 barvalue_;
+ ::PROTOBUF_NAMESPACE_ID::int32 bazvalue_;
+ ::PROTOBUF_NAMESPACE_ID::int32 qux_value_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class OneofValue :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:test.vereign.grpc.json.pb.OneofValue) */ {
+ public:
+ OneofValue();
+ virtual ~OneofValue();
+
+ OneofValue(const OneofValue& from);
+ OneofValue(OneofValue&& from) noexcept
+ : OneofValue() {
+ *this = ::std::move(from);
+ }
+
+ inline OneofValue& operator=(const OneofValue& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline OneofValue& operator=(OneofValue&& from) noexcept {
+ if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+ if (this != &from) InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return GetMetadataStatic().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return GetMetadataStatic().reflection;
+ }
+ static const OneofValue& default_instance();
+
+ enum DataCase {
+ kStringValue = 1,
+ kStructValue = 2,
+ DATA_NOT_SET = 0,
+ };
+
+ static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
+ static inline const OneofValue* internal_default_instance() {
+ return reinterpret_cast<const OneofValue*>(
+ &_OneofValue_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 21;
+
+ friend void swap(OneofValue& a, OneofValue& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(OneofValue* other) {
+ if (other == this) return;
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline OneofValue* New() const final {
+ return CreateMaybeMessage<OneofValue>(nullptr);
+ }
+
+ OneofValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<OneofValue>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const OneofValue& from);
+ void MergeFrom(const OneofValue& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ inline void SharedCtor();
+ inline void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(OneofValue* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "test.vereign.grpc.json.pb.OneofValue";
+ }
+ private:
+ inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+ return nullptr;
+ }
+ inline void* MaybeArenaPtr() const {
+ return nullptr;
+ }
+ public:
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_messages_2eproto);
+ return ::descriptor_table_messages_2eproto.file_level_metadata[kIndexInFileMessages];
+ }
+
+ public:
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kStringValueFieldNumber = 1,
+ kStructValueFieldNumber = 2,
+ };
+ // string string_value = 1;
+ private:
+ bool _internal_has_string_value() const;
+ public:
+ void clear_string_value();
+ const std::string& string_value() const;
+ void set_string_value(const std::string& value);
+ void set_string_value(std::string&& value);
+ void set_string_value(const char* value);
+ void set_string_value(const char* value, size_t size);
+ std::string* mutable_string_value();
+ std::string* release_string_value();
+ void set_allocated_string_value(std::string* string_value);
+ private:
+ const std::string& _internal_string_value() const;
+ void _internal_set_string_value(const std::string& value);
+ std::string* _internal_mutable_string_value();
+ public:
+
+ // .test.vereign.grpc.json.pb.SimpleStruct struct_value = 2;
+ bool has_struct_value() const;
+ private:
+ bool _internal_has_struct_value() const;
+ public:
+ void clear_struct_value();
+ const ::test::vereign::grpc::json::pb::SimpleStruct& struct_value() const;
+ ::test::vereign::grpc::json::pb::SimpleStruct* release_struct_value();
+ ::test::vereign::grpc::json::pb::SimpleStruct* mutable_struct_value();
+ void set_allocated_struct_value(::test::vereign::grpc::json::pb::SimpleStruct* struct_value);
+ private:
+ const ::test::vereign::grpc::json::pb::SimpleStruct& _internal_struct_value() const;
+ ::test::vereign::grpc::json::pb::SimpleStruct* _internal_mutable_struct_value();
+ public:
+
+ void clear_data();
+ DataCase data_case() const;
+ // @@protoc_insertion_point(class_scope:test.vereign.grpc.json.pb.OneofValue)
+ private:
+ class _Internal;
+ void set_has_string_value();
+ void set_has_struct_value();
+
+ inline bool has_data() const;
+ inline void clear_has_data();
+
+ ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+ union DataUnion {
+ DataUnion() {}
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_value_;
+ ::test::vereign::grpc::json::pb::SimpleStruct* struct_value_;
+ } data_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
+
+ friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class EnumType :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:test.vereign.grpc.json.pb.EnumType) */ {
+ public:
+ EnumType();
+ virtual ~EnumType();
+
+ EnumType(const EnumType& from);
+ EnumType(EnumType&& from) noexcept
+ : EnumType() {
+ *this = ::std::move(from);
+ }
+
+ inline EnumType& operator=(const EnumType& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline EnumType& operator=(EnumType&& from) noexcept {
+ if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+ if (this != &from) InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return GetMetadataStatic().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return GetMetadataStatic().reflection;
+ }
+ static const EnumType& default_instance();
+
+ static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
+ static inline const EnumType* internal_default_instance() {
+ return reinterpret_cast<const EnumType*>(
+ &_EnumType_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 22;
+
+ friend void swap(EnumType& a, EnumType& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(EnumType* other) {
+ if (other == this) return;
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline EnumType* New() const final {
+ return CreateMaybeMessage<EnumType>(nullptr);
+ }
+
+ EnumType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<EnumType>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const EnumType& from);
+ void MergeFrom(const EnumType& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ inline void SharedCtor();
+ inline void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(EnumType* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "test.vereign.grpc.json.pb.EnumType";
+ }
+ private:
+ inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+ return nullptr;
+ }
+ inline void* MaybeArenaPtr() const {
+ return nullptr;
+ }
+ public:
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_messages_2eproto);
+ return ::descriptor_table_messages_2eproto.file_level_metadata[kIndexInFileMessages];
+ }
+
+ public:
+
+ // nested types ----------------------------------------------------
+
+ typedef EnumType_Corpus Corpus;
+ static constexpr Corpus UNIVERSAL =
+ EnumType_Corpus_UNIVERSAL;
+ static constexpr Corpus WEB =
+ EnumType_Corpus_WEB;
+ static constexpr Corpus IMAGES =
+ EnumType_Corpus_IMAGES;
+ static constexpr Corpus LOCAL =
+ EnumType_Corpus_LOCAL;
+ static constexpr Corpus NEWS =
+ EnumType_Corpus_NEWS;
+ static constexpr Corpus PRODUCTS =
+ EnumType_Corpus_PRODUCTS;
+ static constexpr Corpus VIDEO =
+ EnumType_Corpus_VIDEO;
+ static inline bool Corpus_IsValid(int value) {
+ return EnumType_Corpus_IsValid(value);
+ }
+ static constexpr Corpus Corpus_MIN =
+ EnumType_Corpus_Corpus_MIN;
+ static constexpr Corpus Corpus_MAX =
+ EnumType_Corpus_Corpus_MAX;
+ static constexpr int Corpus_ARRAYSIZE =
+ EnumType_Corpus_Corpus_ARRAYSIZE;
+ static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+ Corpus_descriptor() {
+ return EnumType_Corpus_descriptor();
+ }
+ template<typename T>
+ static inline const std::string& Corpus_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, Corpus>::value ||
+ ::std::is_integral<T>::value,
+ "Incorrect type passed to function Corpus_Name.");
+ return EnumType_Corpus_Name(enum_t_value);
+ }
+ static inline bool Corpus_Parse(const std::string& name,
+ Corpus* value) {
+ return EnumType_Corpus_Parse(name, value);
+ }
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kCorpusFieldNumber = 4,
+ };
+ // .test.vereign.grpc.json.pb.EnumType.Corpus corpus = 4;
+ void clear_corpus();
+ ::test::vereign::grpc::json::pb::EnumType_Corpus corpus() const;
+ void set_corpus(::test::vereign::grpc::json::pb::EnumType_Corpus value);
+ private:
+ ::test::vereign::grpc::json::pb::EnumType_Corpus _internal_corpus() const;
+ void _internal_set_corpus(::test::vereign::grpc::json::pb::EnumType_Corpus value);
+ public:
+
+ // @@protoc_insertion_point(class_scope:test.vereign.grpc.json.pb.EnumType)
+ private:
+ class _Internal;
+
+ ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+ int corpus_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class RepeatedEnumType :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:test.vereign.grpc.json.pb.RepeatedEnumType) */ {
+ public:
+ RepeatedEnumType();
+ virtual ~RepeatedEnumType();
+
+ RepeatedEnumType(const RepeatedEnumType& from);
+ RepeatedEnumType(RepeatedEnumType&& from) noexcept
+ : RepeatedEnumType() {
+ *this = ::std::move(from);
+ }
+
+ inline RepeatedEnumType& operator=(const RepeatedEnumType& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline RepeatedEnumType& operator=(RepeatedEnumType&& from) noexcept {
+ if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+ if (this != &from) InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return GetMetadataStatic().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return GetMetadataStatic().reflection;
+ }
+ static const RepeatedEnumType& default_instance();
+
+ static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
+ static inline const RepeatedEnumType* internal_default_instance() {
+ return reinterpret_cast<const RepeatedEnumType*>(
+ &_RepeatedEnumType_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 23;
+
+ friend void swap(RepeatedEnumType& a, RepeatedEnumType& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(RepeatedEnumType* other) {
+ if (other == this) return;
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline RepeatedEnumType* New() const final {
+ return CreateMaybeMessage<RepeatedEnumType>(nullptr);
+ }
+
+ RepeatedEnumType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<RepeatedEnumType>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const RepeatedEnumType& from);
+ void MergeFrom(const RepeatedEnumType& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ inline void SharedCtor();
+ inline void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(RepeatedEnumType* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "test.vereign.grpc.json.pb.RepeatedEnumType";
+ }
+ private:
+ inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+ return nullptr;
+ }
+ inline void* MaybeArenaPtr() const {
+ return nullptr;
+ }
+ public:
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_messages_2eproto);
+ return ::descriptor_table_messages_2eproto.file_level_metadata[kIndexInFileMessages];
+ }
+
+ public:
+
+ // nested types ----------------------------------------------------
+
+ typedef RepeatedEnumType_Corpus Corpus;
+ static constexpr Corpus UNIVERSAL =
+ RepeatedEnumType_Corpus_UNIVERSAL;
+ static constexpr Corpus WEB =
+ RepeatedEnumType_Corpus_WEB;
+ static constexpr Corpus IMAGES =
+ RepeatedEnumType_Corpus_IMAGES;
+ static constexpr Corpus LOCAL =
+ RepeatedEnumType_Corpus_LOCAL;
+ static constexpr Corpus NEWS =
+ RepeatedEnumType_Corpus_NEWS;
+ static constexpr Corpus PRODUCTS =
+ RepeatedEnumType_Corpus_PRODUCTS;
+ static constexpr Corpus VIDEO =
+ RepeatedEnumType_Corpus_VIDEO;
+ static inline bool Corpus_IsValid(int value) {
+ return RepeatedEnumType_Corpus_IsValid(value);
+ }
+ static constexpr Corpus Corpus_MIN =
+ RepeatedEnumType_Corpus_Corpus_MIN;
+ static constexpr Corpus Corpus_MAX =
+ RepeatedEnumType_Corpus_Corpus_MAX;
+ static constexpr int Corpus_ARRAYSIZE =
+ RepeatedEnumType_Corpus_Corpus_ARRAYSIZE;
+ static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+ Corpus_descriptor() {
+ return RepeatedEnumType_Corpus_descriptor();
+ }
+ template<typename T>
+ static inline const std::string& Corpus_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, Corpus>::value ||
+ ::std::is_integral<T>::value,
+ "Incorrect type passed to function Corpus_Name.");
+ return RepeatedEnumType_Corpus_Name(enum_t_value);
+ }
+ static inline bool Corpus_Parse(const std::string& name,
+ Corpus* value) {
+ return RepeatedEnumType_Corpus_Parse(name, value);
+ }
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kCorpusFieldNumber = 4,
+ };
+ // repeated .test.vereign.grpc.json.pb.RepeatedEnumType.Corpus corpus = 4;
+ int corpus_size() const;
+ private:
+ int _internal_corpus_size() const;
+ public:
+ void clear_corpus();
+ private:
+ ::test::vereign::grpc::json::pb::RepeatedEnumType_Corpus _internal_corpus(int index) const;
+ void _internal_add_corpus(::test::vereign::grpc::json::pb::RepeatedEnumType_Corpus value);
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_corpus();
+ public:
+ ::test::vereign::grpc::json::pb::RepeatedEnumType_Corpus corpus(int index) const;
+ void set_corpus(int index, ::test::vereign::grpc::json::pb::RepeatedEnumType_Corpus value);
+ void add_corpus(::test::vereign::grpc::json::pb::RepeatedEnumType_Corpus value);
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& corpus() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_corpus();
+
+ // @@protoc_insertion_point(class_scope:test.vereign.grpc.json.pb.RepeatedEnumType)
+ private:
+ class _Internal;
+
+ ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> corpus_;
+ mutable std::atomic<int> _corpus_cached_byte_size_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class NestedType_NestedFoo_NestedBar :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:test.vereign.grpc.json.pb.NestedType.NestedFoo.NestedBar) */ {
+ public:
+ NestedType_NestedFoo_NestedBar();
+ virtual ~NestedType_NestedFoo_NestedBar();
+
+ NestedType_NestedFoo_NestedBar(const NestedType_NestedFoo_NestedBar& from);
+ NestedType_NestedFoo_NestedBar(NestedType_NestedFoo_NestedBar&& from) noexcept
+ : NestedType_NestedFoo_NestedBar() {
+ *this = ::std::move(from);
+ }
+
+ inline NestedType_NestedFoo_NestedBar& operator=(const NestedType_NestedFoo_NestedBar& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline NestedType_NestedFoo_NestedBar& operator=(NestedType_NestedFoo_NestedBar&& from) noexcept {
+ if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+ if (this != &from) InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return GetMetadataStatic().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return GetMetadataStatic().reflection;
+ }
+ static const NestedType_NestedFoo_NestedBar& default_instance();
+
+ static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
+ static inline const NestedType_NestedFoo_NestedBar* internal_default_instance() {
+ return reinterpret_cast<const NestedType_NestedFoo_NestedBar*>(
+ &_NestedType_NestedFoo_NestedBar_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 24;
+
+ friend void swap(NestedType_NestedFoo_NestedBar& a, NestedType_NestedFoo_NestedBar& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(NestedType_NestedFoo_NestedBar* other) {
+ if (other == this) return;
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline NestedType_NestedFoo_NestedBar* New() const final {
+ return CreateMaybeMessage<NestedType_NestedFoo_NestedBar>(nullptr);
+ }
+
+ NestedType_NestedFoo_NestedBar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<NestedType_NestedFoo_NestedBar>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const NestedType_NestedFoo_NestedBar& from);
+ void MergeFrom(const NestedType_NestedFoo_NestedBar& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ inline void SharedCtor();
+ inline void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(NestedType_NestedFoo_NestedBar* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "test.vereign.grpc.json.pb.NestedType.NestedFoo.NestedBar";
+ }
+ private:
+ inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+ return nullptr;
+ }
+ inline void* MaybeArenaPtr() const {
+ return nullptr;
+ }
+ public:
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_messages_2eproto);
+ return ::descriptor_table_messages_2eproto.file_level_metadata[kIndexInFileMessages];
+ }
+
+ public:
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kValueFieldNumber = 1,
+ };
+ // string Value = 1;
+ void clear_value();
+ const std::string& value() const;
+ void set_value(const std::string& value);
+ void set_value(std::string&& value);
+ void set_value(const char* value);
+ void set_value(const char* value, size_t size);
+ std::string* mutable_value();
+ std::string* release_value();
+ void set_allocated_value(std::string* value);
+ private:
+ const std::string& _internal_value() const;
+ void _internal_set_value(const std::string& value);
+ std::string* _internal_mutable_value();
+ public:
+
+ // @@protoc_insertion_point(class_scope:test.vereign.grpc.json.pb.NestedType.NestedFoo.NestedBar)
+ private:
+ class _Internal;
+
+ ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class NestedType_NestedFoo :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:test.vereign.grpc.json.pb.NestedType.NestedFoo) */ {
+ public:
+ NestedType_NestedFoo();
+ virtual ~NestedType_NestedFoo();
+
+ NestedType_NestedFoo(const NestedType_NestedFoo& from);
+ NestedType_NestedFoo(NestedType_NestedFoo&& from) noexcept
+ : NestedType_NestedFoo() {
+ *this = ::std::move(from);
+ }
+
+ inline NestedType_NestedFoo& operator=(const NestedType_NestedFoo& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline NestedType_NestedFoo& operator=(NestedType_NestedFoo&& from) noexcept {
+ if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+ if (this != &from) InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return GetMetadataStatic().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return GetMetadataStatic().reflection;
+ }
+ static const NestedType_NestedFoo& default_instance();
+
+ static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
+ static inline const NestedType_NestedFoo* internal_default_instance() {
+ return reinterpret_cast<const NestedType_NestedFoo*>(
+ &_NestedType_NestedFoo_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 25;
+
+ friend void swap(NestedType_NestedFoo& a, NestedType_NestedFoo& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(NestedType_NestedFoo* other) {
+ if (other == this) return;
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline NestedType_NestedFoo* New() const final {
+ return CreateMaybeMessage<NestedType_NestedFoo>(nullptr);
+ }
+
+ NestedType_NestedFoo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<NestedType_NestedFoo>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const NestedType_NestedFoo& from);
+ void MergeFrom(const NestedType_NestedFoo& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ inline void SharedCtor();
+ inline void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(NestedType_NestedFoo* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "test.vereign.grpc.json.pb.NestedType.NestedFoo";
+ }
+ private:
+ inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+ return nullptr;
+ }
+ inline void* MaybeArenaPtr() const {
+ return nullptr;
+ }
+ public:
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_messages_2eproto);
+ return ::descriptor_table_messages_2eproto.file_level_metadata[kIndexInFileMessages];
+ }
+
+ public:
+
+ // nested types ----------------------------------------------------
+
+ typedef NestedType_NestedFoo_NestedBar NestedBar;
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kValueFieldNumber = 1,
+ kBarValueFieldNumber = 2,
+ };
+ // string value = 1;
+ void clear_value();
+ const std::string& value() const;
+ void set_value(const std::string& value);
+ void set_value(std::string&& value);
+ void set_value(const char* value);
+ void set_value(const char* value, size_t size);
+ std::string* mutable_value();
+ std::string* release_value();
+ void set_allocated_value(std::string* value);
+ private:
+ const std::string& _internal_value() const;
+ void _internal_set_value(const std::string& value);
+ std::string* _internal_mutable_value();
+ public:
+
+ // .test.vereign.grpc.json.pb.NestedType.NestedFoo.NestedBar bar_value = 2;
+ bool has_bar_value() const;
+ private:
+ bool _internal_has_bar_value() const;
+ public:
+ void clear_bar_value();
+ const ::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar& bar_value() const;
+ ::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar* release_bar_value();
+ ::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar* mutable_bar_value();
+ void set_allocated_bar_value(::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar* bar_value);
+ private:
+ const ::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar& _internal_bar_value() const;
+ ::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar* _internal_mutable_bar_value();
+ public:
+
+ // @@protoc_insertion_point(class_scope:test.vereign.grpc.json.pb.NestedType.NestedFoo)
+ private:
+ class _Internal;
+
+ ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
+ ::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar* bar_value_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class NestedType :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:test.vereign.grpc.json.pb.NestedType) */ {
+ public:
+ NestedType();
+ virtual ~NestedType();
+
+ NestedType(const NestedType& from);
+ NestedType(NestedType&& from) noexcept
+ : NestedType() {
+ *this = ::std::move(from);
+ }
+
+ inline NestedType& operator=(const NestedType& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline NestedType& operator=(NestedType&& from) noexcept {
+ if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+ if (this != &from) InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return GetMetadataStatic().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return GetMetadataStatic().reflection;
+ }
+ static const NestedType& default_instance();
+
+ static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
+ static inline const NestedType* internal_default_instance() {
+ return reinterpret_cast<const NestedType*>(
+ &_NestedType_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 26;
+
+ friend void swap(NestedType& a, NestedType& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(NestedType* other) {
+ if (other == this) return;
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline NestedType* New() const final {
+ return CreateMaybeMessage<NestedType>(nullptr);
+ }
+
+ NestedType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<NestedType>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const NestedType& from);
+ void MergeFrom(const NestedType& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ inline void SharedCtor();
+ inline void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(NestedType* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "test.vereign.grpc.json.pb.NestedType";
+ }
+ private:
+ inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+ return nullptr;
+ }
+ inline void* MaybeArenaPtr() const {
+ return nullptr;
+ }
+ public:
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_messages_2eproto);
+ return ::descriptor_table_messages_2eproto.file_level_metadata[kIndexInFileMessages];
+ }
+
+ public:
+
+ // nested types ----------------------------------------------------
+
+ typedef NestedType_NestedFoo NestedFoo;
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kValueFieldNumber = 1,
+ kFooValueFieldNumber = 2,
+ };
+ // string value = 1;
+ void clear_value();
+ const std::string& value() const;
+ void set_value(const std::string& value);
+ void set_value(std::string&& value);
+ void set_value(const char* value);
+ void set_value(const char* value, size_t size);
+ std::string* mutable_value();
+ std::string* release_value();
+ void set_allocated_value(std::string* value);
+ private:
+ const std::string& _internal_value() const;
+ void _internal_set_value(const std::string& value);
+ std::string* _internal_mutable_value();
+ public:
+
+ // .test.vereign.grpc.json.pb.NestedType.NestedFoo foo_value = 2;
+ bool has_foo_value() const;
+ private:
+ bool _internal_has_foo_value() const;
+ public:
+ void clear_foo_value();
+ const ::test::vereign::grpc::json::pb::NestedType_NestedFoo& foo_value() const;
+ ::test::vereign::grpc::json::pb::NestedType_NestedFoo* release_foo_value();
+ ::test::vereign::grpc::json::pb::NestedType_NestedFoo* mutable_foo_value();
+ void set_allocated_foo_value(::test::vereign::grpc::json::pb::NestedType_NestedFoo* foo_value);
+ private:
+ const ::test::vereign::grpc::json::pb::NestedType_NestedFoo& _internal_foo_value() const;
+ ::test::vereign::grpc::json::pb::NestedType_NestedFoo* _internal_mutable_foo_value();
+ public:
+
+ // @@protoc_insertion_point(class_scope:test.vereign.grpc.json.pb.NestedType)
+ private:
+ class _Internal;
+
+ ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
+ ::test::vereign::grpc::json::pb::NestedType_NestedFoo* foo_value_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_messages_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+ #pragma GCC diagnostic push
+ #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif // __GNUC__
+// SimpleStruct
+
+// int32 int32_value = 1;
+inline void SimpleStruct::clear_int32_value() {
+ int32_value_ = 0;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 SimpleStruct::_internal_int32_value() const {
+ return int32_value_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 SimpleStruct::int32_value() const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.SimpleStruct.int32_value)
+ return _internal_int32_value();
+}
+inline void SimpleStruct::_internal_set_int32_value(::PROTOBUF_NAMESPACE_ID::int32 value) {
+
+ int32_value_ = value;
+}
+inline void SimpleStruct::set_int32_value(::PROTOBUF_NAMESPACE_ID::int32 value) {
+ _internal_set_int32_value(value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.SimpleStruct.int32_value)
+}
+
+// int64 int64_value = 2;
+inline void SimpleStruct::clear_int64_value() {
+ int64_value_ = PROTOBUF_LONGLONG(0);
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 SimpleStruct::_internal_int64_value() const {
+ return int64_value_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 SimpleStruct::int64_value() const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.SimpleStruct.int64_value)
+ return _internal_int64_value();
+}
+inline void SimpleStruct::_internal_set_int64_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
+
+ int64_value_ = value;
+}
+inline void SimpleStruct::set_int64_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
+ _internal_set_int64_value(value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.SimpleStruct.int64_value)
+}
+
+// uint32 uint32_value = 3;
+inline void SimpleStruct::clear_uint32_value() {
+ uint32_value_ = 0u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleStruct::_internal_uint32_value() const {
+ return uint32_value_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleStruct::uint32_value() const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.SimpleStruct.uint32_value)
+ return _internal_uint32_value();
+}
+inline void SimpleStruct::_internal_set_uint32_value(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+
+ uint32_value_ = value;
+}
+inline void SimpleStruct::set_uint32_value(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+ _internal_set_uint32_value(value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.SimpleStruct.uint32_value)
+}
+
+// uint64 uint64_value = 4;
+inline void SimpleStruct::clear_uint64_value() {
+ uint64_value_ = PROTOBUF_ULONGLONG(0);
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 SimpleStruct::_internal_uint64_value() const {
+ return uint64_value_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 SimpleStruct::uint64_value() const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.SimpleStruct.uint64_value)
+ return _internal_uint64_value();
+}
+inline void SimpleStruct::_internal_set_uint64_value(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+
+ uint64_value_ = value;
+}
+inline void SimpleStruct::set_uint64_value(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+ _internal_set_uint64_value(value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.SimpleStruct.uint64_value)
+}
+
+// sint32 sint32_value = 5;
+inline void SimpleStruct::clear_sint32_value() {
+ sint32_value_ = 0;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 SimpleStruct::_internal_sint32_value() const {
+ return sint32_value_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 SimpleStruct::sint32_value() const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.SimpleStruct.sint32_value)
+ return _internal_sint32_value();
+}
+inline void SimpleStruct::_internal_set_sint32_value(::PROTOBUF_NAMESPACE_ID::int32 value) {
+
+ sint32_value_ = value;
+}
+inline void SimpleStruct::set_sint32_value(::PROTOBUF_NAMESPACE_ID::int32 value) {
+ _internal_set_sint32_value(value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.SimpleStruct.sint32_value)
+}
+
+// sint64 sint64_value = 6;
+inline void SimpleStruct::clear_sint64_value() {
+ sint64_value_ = PROTOBUF_LONGLONG(0);
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 SimpleStruct::_internal_sint64_value() const {
+ return sint64_value_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 SimpleStruct::sint64_value() const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.SimpleStruct.sint64_value)
+ return _internal_sint64_value();
+}
+inline void SimpleStruct::_internal_set_sint64_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
+
+ sint64_value_ = value;
+}
+inline void SimpleStruct::set_sint64_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
+ _internal_set_sint64_value(value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.SimpleStruct.sint64_value)
+}
+
+// fixed32 fixed32_value = 7;
+inline void SimpleStruct::clear_fixed32_value() {
+ fixed32_value_ = 0u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleStruct::_internal_fixed32_value() const {
+ return fixed32_value_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleStruct::fixed32_value() const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.SimpleStruct.fixed32_value)
+ return _internal_fixed32_value();
+}
+inline void SimpleStruct::_internal_set_fixed32_value(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+
+ fixed32_value_ = value;
+}
+inline void SimpleStruct::set_fixed32_value(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+ _internal_set_fixed32_value(value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.SimpleStruct.fixed32_value)
+}
+
+// fixed64 fixed64_value = 8;
+inline void SimpleStruct::clear_fixed64_value() {
+ fixed64_value_ = PROTOBUF_ULONGLONG(0);
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 SimpleStruct::_internal_fixed64_value() const {
+ return fixed64_value_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 SimpleStruct::fixed64_value() const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.SimpleStruct.fixed64_value)
+ return _internal_fixed64_value();
+}
+inline void SimpleStruct::_internal_set_fixed64_value(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+
+ fixed64_value_ = value;
+}
+inline void SimpleStruct::set_fixed64_value(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+ _internal_set_fixed64_value(value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.SimpleStruct.fixed64_value)
+}
+
+// sfixed32 sfixed32_value = 9;
+inline void SimpleStruct::clear_sfixed32_value() {
+ sfixed32_value_ = 0;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 SimpleStruct::_internal_sfixed32_value() const {
+ return sfixed32_value_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 SimpleStruct::sfixed32_value() const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.SimpleStruct.sfixed32_value)
+ return _internal_sfixed32_value();
+}
+inline void SimpleStruct::_internal_set_sfixed32_value(::PROTOBUF_NAMESPACE_ID::int32 value) {
+
+ sfixed32_value_ = value;
+}
+inline void SimpleStruct::set_sfixed32_value(::PROTOBUF_NAMESPACE_ID::int32 value) {
+ _internal_set_sfixed32_value(value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.SimpleStruct.sfixed32_value)
+}
+
+// sfixed64 sfixed64_value = 10;
+inline void SimpleStruct::clear_sfixed64_value() {
+ sfixed64_value_ = PROTOBUF_LONGLONG(0);
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 SimpleStruct::_internal_sfixed64_value() const {
+ return sfixed64_value_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 SimpleStruct::sfixed64_value() const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.SimpleStruct.sfixed64_value)
+ return _internal_sfixed64_value();
+}
+inline void SimpleStruct::_internal_set_sfixed64_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
+
+ sfixed64_value_ = value;
+}
+inline void SimpleStruct::set_sfixed64_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
+ _internal_set_sfixed64_value(value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.SimpleStruct.sfixed64_value)
+}
+
+// float float_value = 11;
+inline void SimpleStruct::clear_float_value() {
+ float_value_ = 0;
+}
+inline float SimpleStruct::_internal_float_value() const {
+ return float_value_;
+}
+inline float SimpleStruct::float_value() const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.SimpleStruct.float_value)
+ return _internal_float_value();
+}
+inline void SimpleStruct::_internal_set_float_value(float value) {
+
+ float_value_ = value;
+}
+inline void SimpleStruct::set_float_value(float value) {
+ _internal_set_float_value(value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.SimpleStruct.float_value)
+}
+
+// double double_value = 12;
+inline void SimpleStruct::clear_double_value() {
+ double_value_ = 0;
+}
+inline double SimpleStruct::_internal_double_value() const {
+ return double_value_;
+}
+inline double SimpleStruct::double_value() const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.SimpleStruct.double_value)
+ return _internal_double_value();
+}
+inline void SimpleStruct::_internal_set_double_value(double value) {
+
+ double_value_ = value;
+}
+inline void SimpleStruct::set_double_value(double value) {
+ _internal_set_double_value(value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.SimpleStruct.double_value)
+}
+
+// bool bool_value = 13;
+inline void SimpleStruct::clear_bool_value() {
+ bool_value_ = false;
+}
+inline bool SimpleStruct::_internal_bool_value() const {
+ return bool_value_;
+}
+inline bool SimpleStruct::bool_value() const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.SimpleStruct.bool_value)
+ return _internal_bool_value();
+}
+inline void SimpleStruct::_internal_set_bool_value(bool value) {
+
+ bool_value_ = value;
+}
+inline void SimpleStruct::set_bool_value(bool value) {
+ _internal_set_bool_value(value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.SimpleStruct.bool_value)
+}
+
+// string string_value = 14;
+inline void SimpleStruct::clear_string_value() {
+ string_value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline const std::string& SimpleStruct::string_value() const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.SimpleStruct.string_value)
+ return _internal_string_value();
+}
+inline void SimpleStruct::set_string_value(const std::string& value) {
+ _internal_set_string_value(value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.SimpleStruct.string_value)
+}
+inline std::string* SimpleStruct::mutable_string_value() {
+ // @@protoc_insertion_point(field_mutable:test.vereign.grpc.json.pb.SimpleStruct.string_value)
+ return _internal_mutable_string_value();
+}
+inline const std::string& SimpleStruct::_internal_string_value() const {
+ return string_value_.GetNoArena();
+}
+inline void SimpleStruct::_internal_set_string_value(const std::string& value) {
+
+ string_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+}
+inline void SimpleStruct::set_string_value(std::string&& value) {
+
+ string_value_.SetNoArena(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+ // @@protoc_insertion_point(field_set_rvalue:test.vereign.grpc.json.pb.SimpleStruct.string_value)
+}
+inline void SimpleStruct::set_string_value(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+
+ string_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+ // @@protoc_insertion_point(field_set_char:test.vereign.grpc.json.pb.SimpleStruct.string_value)
+}
+inline void SimpleStruct::set_string_value(const char* value, size_t size) {
+
+ string_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ ::std::string(reinterpret_cast<const char*>(value), size));
+ // @@protoc_insertion_point(field_set_pointer:test.vereign.grpc.json.pb.SimpleStruct.string_value)
+}
+inline std::string* SimpleStruct::_internal_mutable_string_value() {
+
+ return string_value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline std::string* SimpleStruct::release_string_value() {
+ // @@protoc_insertion_point(field_release:test.vereign.grpc.json.pb.SimpleStruct.string_value)
+
+ return string_value_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline void SimpleStruct::set_allocated_string_value(std::string* string_value) {
+ if (string_value != nullptr) {
+
+ } else {
+
+ }
+ string_value_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), string_value);
+ // @@protoc_insertion_point(field_set_allocated:test.vereign.grpc.json.pb.SimpleStruct.string_value)
+}
+
+// -------------------------------------------------------------------
+
+// RepeatedTypes
+
+// repeated int32 int32_arr = 1;
+inline int RepeatedTypes::_internal_int32_arr_size() const {
+ return int32_arr_.size();
+}
+inline int RepeatedTypes::int32_arr_size() const {
+ return _internal_int32_arr_size();
+}
+inline void RepeatedTypes::clear_int32_arr() {
+ int32_arr_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 RepeatedTypes::_internal_int32_arr(int index) const {
+ return int32_arr_.Get(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 RepeatedTypes::int32_arr(int index) const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.RepeatedTypes.int32_arr)
+ return _internal_int32_arr(index);
+}
+inline void RepeatedTypes::set_int32_arr(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) {
+ int32_arr_.Set(index, value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.RepeatedTypes.int32_arr)
+}
+inline void RepeatedTypes::_internal_add_int32_arr(::PROTOBUF_NAMESPACE_ID::int32 value) {
+ int32_arr_.Add(value);
+}
+inline void RepeatedTypes::add_int32_arr(::PROTOBUF_NAMESPACE_ID::int32 value) {
+ _internal_add_int32_arr(value);
+ // @@protoc_insertion_point(field_add:test.vereign.grpc.json.pb.RepeatedTypes.int32_arr)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
+RepeatedTypes::_internal_int32_arr() const {
+ return int32_arr_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
+RepeatedTypes::int32_arr() const {
+ // @@protoc_insertion_point(field_list:test.vereign.grpc.json.pb.RepeatedTypes.int32_arr)
+ return _internal_int32_arr();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
+RepeatedTypes::_internal_mutable_int32_arr() {
+ return &int32_arr_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
+RepeatedTypes::mutable_int32_arr() {
+ // @@protoc_insertion_point(field_mutable_list:test.vereign.grpc.json.pb.RepeatedTypes.int32_arr)
+ return _internal_mutable_int32_arr();
+}
+
+// repeated int64 int64_arr = 2;
+inline int RepeatedTypes::_internal_int64_arr_size() const {
+ return int64_arr_.size();
+}
+inline int RepeatedTypes::int64_arr_size() const {
+ return _internal_int64_arr_size();
+}
+inline void RepeatedTypes::clear_int64_arr() {
+ int64_arr_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 RepeatedTypes::_internal_int64_arr(int index) const {
+ return int64_arr_.Get(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 RepeatedTypes::int64_arr(int index) const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.RepeatedTypes.int64_arr)
+ return _internal_int64_arr(index);
+}
+inline void RepeatedTypes::set_int64_arr(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
+ int64_arr_.Set(index, value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.RepeatedTypes.int64_arr)
+}
+inline void RepeatedTypes::_internal_add_int64_arr(::PROTOBUF_NAMESPACE_ID::int64 value) {
+ int64_arr_.Add(value);
+}
+inline void RepeatedTypes::add_int64_arr(::PROTOBUF_NAMESPACE_ID::int64 value) {
+ _internal_add_int64_arr(value);
+ // @@protoc_insertion_point(field_add:test.vereign.grpc.json.pb.RepeatedTypes.int64_arr)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
+RepeatedTypes::_internal_int64_arr() const {
+ return int64_arr_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
+RepeatedTypes::int64_arr() const {
+ // @@protoc_insertion_point(field_list:test.vereign.grpc.json.pb.RepeatedTypes.int64_arr)
+ return _internal_int64_arr();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
+RepeatedTypes::_internal_mutable_int64_arr() {
+ return &int64_arr_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
+RepeatedTypes::mutable_int64_arr() {
+ // @@protoc_insertion_point(field_mutable_list:test.vereign.grpc.json.pb.RepeatedTypes.int64_arr)
+ return _internal_mutable_int64_arr();
+}
+
+// repeated uint32 uint32_arr = 3;
+inline int RepeatedTypes::_internal_uint32_arr_size() const {
+ return uint32_arr_.size();
+}
+inline int RepeatedTypes::uint32_arr_size() const {
+ return _internal_uint32_arr_size();
+}
+inline void RepeatedTypes::clear_uint32_arr() {
+ uint32_arr_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 RepeatedTypes::_internal_uint32_arr(int index) const {
+ return uint32_arr_.Get(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 RepeatedTypes::uint32_arr(int index) const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.RepeatedTypes.uint32_arr)
+ return _internal_uint32_arr(index);
+}
+inline void RepeatedTypes::set_uint32_arr(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value) {
+ uint32_arr_.Set(index, value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.RepeatedTypes.uint32_arr)
+}
+inline void RepeatedTypes::_internal_add_uint32_arr(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+ uint32_arr_.Add(value);
+}
+inline void RepeatedTypes::add_uint32_arr(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+ _internal_add_uint32_arr(value);
+ // @@protoc_insertion_point(field_add:test.vereign.grpc.json.pb.RepeatedTypes.uint32_arr)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >&
+RepeatedTypes::_internal_uint32_arr() const {
+ return uint32_arr_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >&
+RepeatedTypes::uint32_arr() const {
+ // @@protoc_insertion_point(field_list:test.vereign.grpc.json.pb.RepeatedTypes.uint32_arr)
+ return _internal_uint32_arr();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >*
+RepeatedTypes::_internal_mutable_uint32_arr() {
+ return &uint32_arr_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >*
+RepeatedTypes::mutable_uint32_arr() {
+ // @@protoc_insertion_point(field_mutable_list:test.vereign.grpc.json.pb.RepeatedTypes.uint32_arr)
+ return _internal_mutable_uint32_arr();
+}
+
+// repeated uint64 uint64_arr = 4;
+inline int RepeatedTypes::_internal_uint64_arr_size() const {
+ return uint64_arr_.size();
+}
+inline int RepeatedTypes::uint64_arr_size() const {
+ return _internal_uint64_arr_size();
+}
+inline void RepeatedTypes::clear_uint64_arr() {
+ uint64_arr_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 RepeatedTypes::_internal_uint64_arr(int index) const {
+ return uint64_arr_.Get(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 RepeatedTypes::uint64_arr(int index) const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.RepeatedTypes.uint64_arr)
+ return _internal_uint64_arr(index);
+}
+inline void RepeatedTypes::set_uint64_arr(int index, ::PROTOBUF_NAMESPACE_ID::uint64 value) {
+ uint64_arr_.Set(index, value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.RepeatedTypes.uint64_arr)
+}
+inline void RepeatedTypes::_internal_add_uint64_arr(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+ uint64_arr_.Add(value);
+}
+inline void RepeatedTypes::add_uint64_arr(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+ _internal_add_uint64_arr(value);
+ // @@protoc_insertion_point(field_add:test.vereign.grpc.json.pb.RepeatedTypes.uint64_arr)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >&
+RepeatedTypes::_internal_uint64_arr() const {
+ return uint64_arr_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >&
+RepeatedTypes::uint64_arr() const {
+ // @@protoc_insertion_point(field_list:test.vereign.grpc.json.pb.RepeatedTypes.uint64_arr)
+ return _internal_uint64_arr();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >*
+RepeatedTypes::_internal_mutable_uint64_arr() {
+ return &uint64_arr_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >*
+RepeatedTypes::mutable_uint64_arr() {
+ // @@protoc_insertion_point(field_mutable_list:test.vereign.grpc.json.pb.RepeatedTypes.uint64_arr)
+ return _internal_mutable_uint64_arr();
+}
+
+// repeated sint32 sint32_arr = 5;
+inline int RepeatedTypes::_internal_sint32_arr_size() const {
+ return sint32_arr_.size();
+}
+inline int RepeatedTypes::sint32_arr_size() const {
+ return _internal_sint32_arr_size();
+}
+inline void RepeatedTypes::clear_sint32_arr() {
+ sint32_arr_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 RepeatedTypes::_internal_sint32_arr(int index) const {
+ return sint32_arr_.Get(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 RepeatedTypes::sint32_arr(int index) const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.RepeatedTypes.sint32_arr)
+ return _internal_sint32_arr(index);
+}
+inline void RepeatedTypes::set_sint32_arr(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) {
+ sint32_arr_.Set(index, value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.RepeatedTypes.sint32_arr)
+}
+inline void RepeatedTypes::_internal_add_sint32_arr(::PROTOBUF_NAMESPACE_ID::int32 value) {
+ sint32_arr_.Add(value);
+}
+inline void RepeatedTypes::add_sint32_arr(::PROTOBUF_NAMESPACE_ID::int32 value) {
+ _internal_add_sint32_arr(value);
+ // @@protoc_insertion_point(field_add:test.vereign.grpc.json.pb.RepeatedTypes.sint32_arr)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
+RepeatedTypes::_internal_sint32_arr() const {
+ return sint32_arr_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
+RepeatedTypes::sint32_arr() const {
+ // @@protoc_insertion_point(field_list:test.vereign.grpc.json.pb.RepeatedTypes.sint32_arr)
+ return _internal_sint32_arr();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
+RepeatedTypes::_internal_mutable_sint32_arr() {
+ return &sint32_arr_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
+RepeatedTypes::mutable_sint32_arr() {
+ // @@protoc_insertion_point(field_mutable_list:test.vereign.grpc.json.pb.RepeatedTypes.sint32_arr)
+ return _internal_mutable_sint32_arr();
+}
+
+// repeated sint64 sint64_arr = 6;
+inline int RepeatedTypes::_internal_sint64_arr_size() const {
+ return sint64_arr_.size();
+}
+inline int RepeatedTypes::sint64_arr_size() const {
+ return _internal_sint64_arr_size();
+}
+inline void RepeatedTypes::clear_sint64_arr() {
+ sint64_arr_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 RepeatedTypes::_internal_sint64_arr(int index) const {
+ return sint64_arr_.Get(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 RepeatedTypes::sint64_arr(int index) const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.RepeatedTypes.sint64_arr)
+ return _internal_sint64_arr(index);
+}
+inline void RepeatedTypes::set_sint64_arr(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
+ sint64_arr_.Set(index, value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.RepeatedTypes.sint64_arr)
+}
+inline void RepeatedTypes::_internal_add_sint64_arr(::PROTOBUF_NAMESPACE_ID::int64 value) {
+ sint64_arr_.Add(value);
+}
+inline void RepeatedTypes::add_sint64_arr(::PROTOBUF_NAMESPACE_ID::int64 value) {
+ _internal_add_sint64_arr(value);
+ // @@protoc_insertion_point(field_add:test.vereign.grpc.json.pb.RepeatedTypes.sint64_arr)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
+RepeatedTypes::_internal_sint64_arr() const {
+ return sint64_arr_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
+RepeatedTypes::sint64_arr() const {
+ // @@protoc_insertion_point(field_list:test.vereign.grpc.json.pb.RepeatedTypes.sint64_arr)
+ return _internal_sint64_arr();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
+RepeatedTypes::_internal_mutable_sint64_arr() {
+ return &sint64_arr_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
+RepeatedTypes::mutable_sint64_arr() {
+ // @@protoc_insertion_point(field_mutable_list:test.vereign.grpc.json.pb.RepeatedTypes.sint64_arr)
+ return _internal_mutable_sint64_arr();
+}
+
+// repeated fixed32 fixed32_arr = 7;
+inline int RepeatedTypes::_internal_fixed32_arr_size() const {
+ return fixed32_arr_.size();
+}
+inline int RepeatedTypes::fixed32_arr_size() const {
+ return _internal_fixed32_arr_size();
+}
+inline void RepeatedTypes::clear_fixed32_arr() {
+ fixed32_arr_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 RepeatedTypes::_internal_fixed32_arr(int index) const {
+ return fixed32_arr_.Get(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 RepeatedTypes::fixed32_arr(int index) const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.RepeatedTypes.fixed32_arr)
+ return _internal_fixed32_arr(index);
+}
+inline void RepeatedTypes::set_fixed32_arr(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value) {
+ fixed32_arr_.Set(index, value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.RepeatedTypes.fixed32_arr)
+}
+inline void RepeatedTypes::_internal_add_fixed32_arr(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+ fixed32_arr_.Add(value);
+}
+inline void RepeatedTypes::add_fixed32_arr(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+ _internal_add_fixed32_arr(value);
+ // @@protoc_insertion_point(field_add:test.vereign.grpc.json.pb.RepeatedTypes.fixed32_arr)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >&
+RepeatedTypes::_internal_fixed32_arr() const {
+ return fixed32_arr_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >&
+RepeatedTypes::fixed32_arr() const {
+ // @@protoc_insertion_point(field_list:test.vereign.grpc.json.pb.RepeatedTypes.fixed32_arr)
+ return _internal_fixed32_arr();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >*
+RepeatedTypes::_internal_mutable_fixed32_arr() {
+ return &fixed32_arr_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >*
+RepeatedTypes::mutable_fixed32_arr() {
+ // @@protoc_insertion_point(field_mutable_list:test.vereign.grpc.json.pb.RepeatedTypes.fixed32_arr)
+ return _internal_mutable_fixed32_arr();
+}
+
+// repeated fixed64 fixed64_arr = 8;
+inline int RepeatedTypes::_internal_fixed64_arr_size() const {
+ return fixed64_arr_.size();
+}
+inline int RepeatedTypes::fixed64_arr_size() const {
+ return _internal_fixed64_arr_size();
+}
+inline void RepeatedTypes::clear_fixed64_arr() {
+ fixed64_arr_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 RepeatedTypes::_internal_fixed64_arr(int index) const {
+ return fixed64_arr_.Get(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 RepeatedTypes::fixed64_arr(int index) const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.RepeatedTypes.fixed64_arr)
+ return _internal_fixed64_arr(index);
+}
+inline void RepeatedTypes::set_fixed64_arr(int index, ::PROTOBUF_NAMESPACE_ID::uint64 value) {
+ fixed64_arr_.Set(index, value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.RepeatedTypes.fixed64_arr)
+}
+inline void RepeatedTypes::_internal_add_fixed64_arr(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+ fixed64_arr_.Add(value);
+}
+inline void RepeatedTypes::add_fixed64_arr(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+ _internal_add_fixed64_arr(value);
+ // @@protoc_insertion_point(field_add:test.vereign.grpc.json.pb.RepeatedTypes.fixed64_arr)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >&
+RepeatedTypes::_internal_fixed64_arr() const {
+ return fixed64_arr_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >&
+RepeatedTypes::fixed64_arr() const {
+ // @@protoc_insertion_point(field_list:test.vereign.grpc.json.pb.RepeatedTypes.fixed64_arr)
+ return _internal_fixed64_arr();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >*
+RepeatedTypes::_internal_mutable_fixed64_arr() {
+ return &fixed64_arr_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >*
+RepeatedTypes::mutable_fixed64_arr() {
+ // @@protoc_insertion_point(field_mutable_list:test.vereign.grpc.json.pb.RepeatedTypes.fixed64_arr)
+ return _internal_mutable_fixed64_arr();
+}
+
+// repeated sfixed32 sfixed32_arr = 9;
+inline int RepeatedTypes::_internal_sfixed32_arr_size() const {
+ return sfixed32_arr_.size();
+}
+inline int RepeatedTypes::sfixed32_arr_size() const {
+ return _internal_sfixed32_arr_size();
+}
+inline void RepeatedTypes::clear_sfixed32_arr() {
+ sfixed32_arr_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 RepeatedTypes::_internal_sfixed32_arr(int index) const {
+ return sfixed32_arr_.Get(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 RepeatedTypes::sfixed32_arr(int index) const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.RepeatedTypes.sfixed32_arr)
+ return _internal_sfixed32_arr(index);
+}
+inline void RepeatedTypes::set_sfixed32_arr(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) {
+ sfixed32_arr_.Set(index, value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.RepeatedTypes.sfixed32_arr)
+}
+inline void RepeatedTypes::_internal_add_sfixed32_arr(::PROTOBUF_NAMESPACE_ID::int32 value) {
+ sfixed32_arr_.Add(value);
+}
+inline void RepeatedTypes::add_sfixed32_arr(::PROTOBUF_NAMESPACE_ID::int32 value) {
+ _internal_add_sfixed32_arr(value);
+ // @@protoc_insertion_point(field_add:test.vereign.grpc.json.pb.RepeatedTypes.sfixed32_arr)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
+RepeatedTypes::_internal_sfixed32_arr() const {
+ return sfixed32_arr_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
+RepeatedTypes::sfixed32_arr() const {
+ // @@protoc_insertion_point(field_list:test.vereign.grpc.json.pb.RepeatedTypes.sfixed32_arr)
+ return _internal_sfixed32_arr();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
+RepeatedTypes::_internal_mutable_sfixed32_arr() {
+ return &sfixed32_arr_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
+RepeatedTypes::mutable_sfixed32_arr() {
+ // @@protoc_insertion_point(field_mutable_list:test.vereign.grpc.json.pb.RepeatedTypes.sfixed32_arr)
+ return _internal_mutable_sfixed32_arr();
+}
+
+// repeated sfixed64 sfixed64_arr = 10;
+inline int RepeatedTypes::_internal_sfixed64_arr_size() const {
+ return sfixed64_arr_.size();
+}
+inline int RepeatedTypes::sfixed64_arr_size() const {
+ return _internal_sfixed64_arr_size();
+}
+inline void RepeatedTypes::clear_sfixed64_arr() {
+ sfixed64_arr_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 RepeatedTypes::_internal_sfixed64_arr(int index) const {
+ return sfixed64_arr_.Get(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 RepeatedTypes::sfixed64_arr(int index) const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.RepeatedTypes.sfixed64_arr)
+ return _internal_sfixed64_arr(index);
+}
+inline void RepeatedTypes::set_sfixed64_arr(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
+ sfixed64_arr_.Set(index, value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.RepeatedTypes.sfixed64_arr)
+}
+inline void RepeatedTypes::_internal_add_sfixed64_arr(::PROTOBUF_NAMESPACE_ID::int64 value) {
+ sfixed64_arr_.Add(value);
+}
+inline void RepeatedTypes::add_sfixed64_arr(::PROTOBUF_NAMESPACE_ID::int64 value) {
+ _internal_add_sfixed64_arr(value);
+ // @@protoc_insertion_point(field_add:test.vereign.grpc.json.pb.RepeatedTypes.sfixed64_arr)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
+RepeatedTypes::_internal_sfixed64_arr() const {
+ return sfixed64_arr_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
+RepeatedTypes::sfixed64_arr() const {
+ // @@protoc_insertion_point(field_list:test.vereign.grpc.json.pb.RepeatedTypes.sfixed64_arr)
+ return _internal_sfixed64_arr();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
+RepeatedTypes::_internal_mutable_sfixed64_arr() {
+ return &sfixed64_arr_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
+RepeatedTypes::mutable_sfixed64_arr() {
+ // @@protoc_insertion_point(field_mutable_list:test.vereign.grpc.json.pb.RepeatedTypes.sfixed64_arr)
+ return _internal_mutable_sfixed64_arr();
+}
+
+// repeated float float_arr = 11;
+inline int RepeatedTypes::_internal_float_arr_size() const {
+ return float_arr_.size();
+}
+inline int RepeatedTypes::float_arr_size() const {
+ return _internal_float_arr_size();
+}
+inline void RepeatedTypes::clear_float_arr() {
+ float_arr_.Clear();
+}
+inline float RepeatedTypes::_internal_float_arr(int index) const {
+ return float_arr_.Get(index);
+}
+inline float RepeatedTypes::float_arr(int index) const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.RepeatedTypes.float_arr)
+ return _internal_float_arr(index);
+}
+inline void RepeatedTypes::set_float_arr(int index, float value) {
+ float_arr_.Set(index, value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.RepeatedTypes.float_arr)
+}
+inline void RepeatedTypes::_internal_add_float_arr(float value) {
+ float_arr_.Add(value);
+}
+inline void RepeatedTypes::add_float_arr(float value) {
+ _internal_add_float_arr(value);
+ // @@protoc_insertion_point(field_add:test.vereign.grpc.json.pb.RepeatedTypes.float_arr)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
+RepeatedTypes::_internal_float_arr() const {
+ return float_arr_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
+RepeatedTypes::float_arr() const {
+ // @@protoc_insertion_point(field_list:test.vereign.grpc.json.pb.RepeatedTypes.float_arr)
+ return _internal_float_arr();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
+RepeatedTypes::_internal_mutable_float_arr() {
+ return &float_arr_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
+RepeatedTypes::mutable_float_arr() {
+ // @@protoc_insertion_point(field_mutable_list:test.vereign.grpc.json.pb.RepeatedTypes.float_arr)
+ return _internal_mutable_float_arr();
+}
+
+// repeated double double_arr = 12;
+inline int RepeatedTypes::_internal_double_arr_size() const {
+ return double_arr_.size();
+}
+inline int RepeatedTypes::double_arr_size() const {
+ return _internal_double_arr_size();
+}
+inline void RepeatedTypes::clear_double_arr() {
+ double_arr_.Clear();
+}
+inline double RepeatedTypes::_internal_double_arr(int index) const {
+ return double_arr_.Get(index);
+}
+inline double RepeatedTypes::double_arr(int index) const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.RepeatedTypes.double_arr)
+ return _internal_double_arr(index);
+}
+inline void RepeatedTypes::set_double_arr(int index, double value) {
+ double_arr_.Set(index, value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.RepeatedTypes.double_arr)
+}
+inline void RepeatedTypes::_internal_add_double_arr(double value) {
+ double_arr_.Add(value);
+}
+inline void RepeatedTypes::add_double_arr(double value) {
+ _internal_add_double_arr(value);
+ // @@protoc_insertion_point(field_add:test.vereign.grpc.json.pb.RepeatedTypes.double_arr)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
+RepeatedTypes::_internal_double_arr() const {
+ return double_arr_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
+RepeatedTypes::double_arr() const {
+ // @@protoc_insertion_point(field_list:test.vereign.grpc.json.pb.RepeatedTypes.double_arr)
+ return _internal_double_arr();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
+RepeatedTypes::_internal_mutable_double_arr() {
+ return &double_arr_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
+RepeatedTypes::mutable_double_arr() {
+ // @@protoc_insertion_point(field_mutable_list:test.vereign.grpc.json.pb.RepeatedTypes.double_arr)
+ return _internal_mutable_double_arr();
+}
+
+// repeated bool bool_arr = 13;
+inline int RepeatedTypes::_internal_bool_arr_size() const {
+ return bool_arr_.size();
+}
+inline int RepeatedTypes::bool_arr_size() const {
+ return _internal_bool_arr_size();
+}
+inline void RepeatedTypes::clear_bool_arr() {
+ bool_arr_.Clear();
+}
+inline bool RepeatedTypes::_internal_bool_arr(int index) const {
+ return bool_arr_.Get(index);
+}
+inline bool RepeatedTypes::bool_arr(int index) const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.RepeatedTypes.bool_arr)
+ return _internal_bool_arr(index);
+}
+inline void RepeatedTypes::set_bool_arr(int index, bool value) {
+ bool_arr_.Set(index, value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.RepeatedTypes.bool_arr)
+}
+inline void RepeatedTypes::_internal_add_bool_arr(bool value) {
+ bool_arr_.Add(value);
+}
+inline void RepeatedTypes::add_bool_arr(bool value) {
+ _internal_add_bool_arr(value);
+ // @@protoc_insertion_point(field_add:test.vereign.grpc.json.pb.RepeatedTypes.bool_arr)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
+RepeatedTypes::_internal_bool_arr() const {
+ return bool_arr_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
+RepeatedTypes::bool_arr() const {
+ // @@protoc_insertion_point(field_list:test.vereign.grpc.json.pb.RepeatedTypes.bool_arr)
+ return _internal_bool_arr();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
+RepeatedTypes::_internal_mutable_bool_arr() {
+ return &bool_arr_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
+RepeatedTypes::mutable_bool_arr() {
+ // @@protoc_insertion_point(field_mutable_list:test.vereign.grpc.json.pb.RepeatedTypes.bool_arr)
+ return _internal_mutable_bool_arr();
+}
+
+// repeated string string_arr = 14;
+inline int RepeatedTypes::_internal_string_arr_size() const {
+ return string_arr_.size();
+}
+inline int RepeatedTypes::string_arr_size() const {
+ return _internal_string_arr_size();
+}
+inline void RepeatedTypes::clear_string_arr() {
+ string_arr_.Clear();
+}
+inline std::string* RepeatedTypes::add_string_arr() {
+ // @@protoc_insertion_point(field_add_mutable:test.vereign.grpc.json.pb.RepeatedTypes.string_arr)
+ return _internal_add_string_arr();
+}
+inline const std::string& RepeatedTypes::_internal_string_arr(int index) const {
+ return string_arr_.Get(index);
+}
+inline const std::string& RepeatedTypes::string_arr(int index) const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.RepeatedTypes.string_arr)
+ return _internal_string_arr(index);
+}
+inline std::string* RepeatedTypes::mutable_string_arr(int index) {
+ // @@protoc_insertion_point(field_mutable:test.vereign.grpc.json.pb.RepeatedTypes.string_arr)
+ return string_arr_.Mutable(index);
+}
+inline void RepeatedTypes::set_string_arr(int index, const std::string& value) {
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.RepeatedTypes.string_arr)
+ string_arr_.Mutable(index)->assign(value);
+}
+inline void RepeatedTypes::set_string_arr(int index, std::string&& value) {
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.RepeatedTypes.string_arr)
+ string_arr_.Mutable(index)->assign(std::move(value));
+}
+inline void RepeatedTypes::set_string_arr(int index, const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+ string_arr_.Mutable(index)->assign(value);
+ // @@protoc_insertion_point(field_set_char:test.vereign.grpc.json.pb.RepeatedTypes.string_arr)
+}
+inline void RepeatedTypes::set_string_arr(int index, const char* value, size_t size) {
+ string_arr_.Mutable(index)->assign(
+ reinterpret_cast<const char*>(value), size);
+ // @@protoc_insertion_point(field_set_pointer:test.vereign.grpc.json.pb.RepeatedTypes.string_arr)
+}
+inline std::string* RepeatedTypes::_internal_add_string_arr() {
+ return string_arr_.Add();
+}
+inline void RepeatedTypes::add_string_arr(const std::string& value) {
+ string_arr_.Add()->assign(value);
+ // @@protoc_insertion_point(field_add:test.vereign.grpc.json.pb.RepeatedTypes.string_arr)
+}
+inline void RepeatedTypes::add_string_arr(std::string&& value) {
+ string_arr_.Add(std::move(value));
+ // @@protoc_insertion_point(field_add:test.vereign.grpc.json.pb.RepeatedTypes.string_arr)
+}
+inline void RepeatedTypes::add_string_arr(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+ string_arr_.Add()->assign(value);
+ // @@protoc_insertion_point(field_add_char:test.vereign.grpc.json.pb.RepeatedTypes.string_arr)
+}
+inline void RepeatedTypes::add_string_arr(const char* value, size_t size) {
+ string_arr_.Add()->assign(reinterpret_cast<const char*>(value), size);
+ // @@protoc_insertion_point(field_add_pointer:test.vereign.grpc.json.pb.RepeatedTypes.string_arr)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+RepeatedTypes::string_arr() const {
+ // @@protoc_insertion_point(field_list:test.vereign.grpc.json.pb.RepeatedTypes.string_arr)
+ return string_arr_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+RepeatedTypes::mutable_string_arr() {
+ // @@protoc_insertion_point(field_mutable_list:test.vereign.grpc.json.pb.RepeatedTypes.string_arr)
+ return &string_arr_;
+}
+
+// -------------------------------------------------------------------
+
+// Bar
+
+// string value = 2;
+inline void Bar::clear_value() {
+ value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline const std::string& Bar::value() const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.Bar.value)
+ return _internal_value();
+}
+inline void Bar::set_value(const std::string& value) {
+ _internal_set_value(value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.Bar.value)
+}
+inline std::string* Bar::mutable_value() {
+ // @@protoc_insertion_point(field_mutable:test.vereign.grpc.json.pb.Bar.value)
+ return _internal_mutable_value();
+}
+inline const std::string& Bar::_internal_value() const {
+ return value_.GetNoArena();
+}
+inline void Bar::_internal_set_value(const std::string& value) {
+
+ value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+}
+inline void Bar::set_value(std::string&& value) {
+
+ value_.SetNoArena(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+ // @@protoc_insertion_point(field_set_rvalue:test.vereign.grpc.json.pb.Bar.value)
+}
+inline void Bar::set_value(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+
+ value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+ // @@protoc_insertion_point(field_set_char:test.vereign.grpc.json.pb.Bar.value)
+}
+inline void Bar::set_value(const char* value, size_t size) {
+
+ value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ ::std::string(reinterpret_cast<const char*>(value), size));
+ // @@protoc_insertion_point(field_set_pointer:test.vereign.grpc.json.pb.Bar.value)
+}
+inline std::string* Bar::_internal_mutable_value() {
+
+ return value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline std::string* Bar::release_value() {
+ // @@protoc_insertion_point(field_release:test.vereign.grpc.json.pb.Bar.value)
+
+ return value_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline void Bar::set_allocated_value(std::string* value) {
+ if (value != nullptr) {
+
+ } else {
+
+ }
+ value_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+ // @@protoc_insertion_point(field_set_allocated:test.vereign.grpc.json.pb.Bar.value)
+}
+
+// -------------------------------------------------------------------
+
+// Foo
+
+// string value = 1;
+inline void Foo::clear_value() {
+ value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline const std::string& Foo::value() const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.Foo.value)
+ return _internal_value();
+}
+inline void Foo::set_value(const std::string& value) {
+ _internal_set_value(value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.Foo.value)
+}
+inline std::string* Foo::mutable_value() {
+ // @@protoc_insertion_point(field_mutable:test.vereign.grpc.json.pb.Foo.value)
+ return _internal_mutable_value();
+}
+inline const std::string& Foo::_internal_value() const {
+ return value_.GetNoArena();
+}
+inline void Foo::_internal_set_value(const std::string& value) {
+
+ value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+}
+inline void Foo::set_value(std::string&& value) {
+
+ value_.SetNoArena(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+ // @@protoc_insertion_point(field_set_rvalue:test.vereign.grpc.json.pb.Foo.value)
+}
+inline void Foo::set_value(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+
+ value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+ // @@protoc_insertion_point(field_set_char:test.vereign.grpc.json.pb.Foo.value)
+}
+inline void Foo::set_value(const char* value, size_t size) {
+
+ value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ ::std::string(reinterpret_cast<const char*>(value), size));
+ // @@protoc_insertion_point(field_set_pointer:test.vereign.grpc.json.pb.Foo.value)
+}
+inline std::string* Foo::_internal_mutable_value() {
+
+ return value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline std::string* Foo::release_value() {
+ // @@protoc_insertion_point(field_release:test.vereign.grpc.json.pb.Foo.value)
+
+ return value_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline void Foo::set_allocated_value(std::string* value) {
+ if (value != nullptr) {
+
+ } else {
+
+ }
+ value_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+ // @@protoc_insertion_point(field_set_allocated:test.vereign.grpc.json.pb.Foo.value)
+}
+
+// .test.vereign.grpc.json.pb.Bar bar = 2;
+inline bool Foo::_internal_has_bar() const {
+ return this != internal_default_instance() && bar_ != nullptr;
+}
+inline bool Foo::has_bar() const {
+ return _internal_has_bar();
+}
+inline void Foo::clear_bar() {
+ if (GetArenaNoVirtual() == nullptr && bar_ != nullptr) {
+ delete bar_;
+ }
+ bar_ = nullptr;
+}
+inline const ::test::vereign::grpc::json::pb::Bar& Foo::_internal_bar() const {
+ const ::test::vereign::grpc::json::pb::Bar* p = bar_;
+ return p != nullptr ? *p : *reinterpret_cast<const ::test::vereign::grpc::json::pb::Bar*>(
+ &::test::vereign::grpc::json::pb::_Bar_default_instance_);
+}
+inline const ::test::vereign::grpc::json::pb::Bar& Foo::bar() const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.Foo.bar)
+ return _internal_bar();
+}
+inline ::test::vereign::grpc::json::pb::Bar* Foo::release_bar() {
+ // @@protoc_insertion_point(field_release:test.vereign.grpc.json.pb.Foo.bar)
+
+ ::test::vereign::grpc::json::pb::Bar* temp = bar_;
+ bar_ = nullptr;
+ return temp;
+}
+inline ::test::vereign::grpc::json::pb::Bar* Foo::_internal_mutable_bar() {
+
+ if (bar_ == nullptr) {
+ auto* p = CreateMaybeMessage<::test::vereign::grpc::json::pb::Bar>(GetArenaNoVirtual());
+ bar_ = p;
+ }
+ return bar_;
+}
+inline ::test::vereign::grpc::json::pb::Bar* Foo::mutable_bar() {
+ // @@protoc_insertion_point(field_mutable:test.vereign.grpc.json.pb.Foo.bar)
+ return _internal_mutable_bar();
+}
+inline void Foo::set_allocated_bar(::test::vereign::grpc::json::pb::Bar* bar) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
+ if (message_arena == nullptr) {
+ delete bar_;
+ }
+ if (bar) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
+ if (message_arena != submessage_arena) {
+ bar = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, bar, submessage_arena);
+ }
+
+ } else {
+
+ }
+ bar_ = bar;
+ // @@protoc_insertion_point(field_set_allocated:test.vereign.grpc.json.pb.Foo.bar)
+}
+
+// -------------------------------------------------------------------
+
+// MessageType
+
+// .test.vereign.grpc.json.pb.Foo foo = 1;
+inline bool MessageType::_internal_has_foo() const {
+ return this != internal_default_instance() && foo_ != nullptr;
+}
+inline bool MessageType::has_foo() const {
+ return _internal_has_foo();
+}
+inline void MessageType::clear_foo() {
+ if (GetArenaNoVirtual() == nullptr && foo_ != nullptr) {
+ delete foo_;
+ }
+ foo_ = nullptr;
+}
+inline const ::test::vereign::grpc::json::pb::Foo& MessageType::_internal_foo() const {
+ const ::test::vereign::grpc::json::pb::Foo* p = foo_;
+ return p != nullptr ? *p : *reinterpret_cast<const ::test::vereign::grpc::json::pb::Foo*>(
+ &::test::vereign::grpc::json::pb::_Foo_default_instance_);
+}
+inline const ::test::vereign::grpc::json::pb::Foo& MessageType::foo() const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.MessageType.foo)
+ return _internal_foo();
+}
+inline ::test::vereign::grpc::json::pb::Foo* MessageType::release_foo() {
+ // @@protoc_insertion_point(field_release:test.vereign.grpc.json.pb.MessageType.foo)
+
+ ::test::vereign::grpc::json::pb::Foo* temp = foo_;
+ foo_ = nullptr;
+ return temp;
+}
+inline ::test::vereign::grpc::json::pb::Foo* MessageType::_internal_mutable_foo() {
+
+ if (foo_ == nullptr) {
+ auto* p = CreateMaybeMessage<::test::vereign::grpc::json::pb::Foo>(GetArenaNoVirtual());
+ foo_ = p;
+ }
+ return foo_;
+}
+inline ::test::vereign::grpc::json::pb::Foo* MessageType::mutable_foo() {
+ // @@protoc_insertion_point(field_mutable:test.vereign.grpc.json.pb.MessageType.foo)
+ return _internal_mutable_foo();
+}
+inline void MessageType::set_allocated_foo(::test::vereign::grpc::json::pb::Foo* foo) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
+ if (message_arena == nullptr) {
+ delete foo_;
+ }
+ if (foo) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
+ if (message_arena != submessage_arena) {
+ foo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, foo, submessage_arena);
+ }
+
+ } else {
+
+ }
+ foo_ = foo;
+ // @@protoc_insertion_point(field_set_allocated:test.vereign.grpc.json.pb.MessageType.foo)
+}
+
+// repeated .test.vereign.grpc.json.pb.Foo foo_arr = 2;
+inline int MessageType::_internal_foo_arr_size() const {
+ return foo_arr_.size();
+}
+inline int MessageType::foo_arr_size() const {
+ return _internal_foo_arr_size();
+}
+inline void MessageType::clear_foo_arr() {
+ foo_arr_.Clear();
+}
+inline ::test::vereign::grpc::json::pb::Foo* MessageType::mutable_foo_arr(int index) {
+ // @@protoc_insertion_point(field_mutable:test.vereign.grpc.json.pb.MessageType.foo_arr)
+ return foo_arr_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::test::vereign::grpc::json::pb::Foo >*
+MessageType::mutable_foo_arr() {
+ // @@protoc_insertion_point(field_mutable_list:test.vereign.grpc.json.pb.MessageType.foo_arr)
+ return &foo_arr_;
+}
+inline const ::test::vereign::grpc::json::pb::Foo& MessageType::_internal_foo_arr(int index) const {
+ return foo_arr_.Get(index);
+}
+inline const ::test::vereign::grpc::json::pb::Foo& MessageType::foo_arr(int index) const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.MessageType.foo_arr)
+ return _internal_foo_arr(index);
+}
+inline ::test::vereign::grpc::json::pb::Foo* MessageType::_internal_add_foo_arr() {
+ return foo_arr_.Add();
+}
+inline ::test::vereign::grpc::json::pb::Foo* MessageType::add_foo_arr() {
+ // @@protoc_insertion_point(field_add:test.vereign.grpc.json.pb.MessageType.foo_arr)
+ return _internal_add_foo_arr();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::test::vereign::grpc::json::pb::Foo >&
+MessageType::foo_arr() const {
+ // @@protoc_insertion_point(field_list:test.vereign.grpc.json.pb.MessageType.foo_arr)
+ return foo_arr_;
+}
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// MapType
+
+// map<int32, string> int32_key = 1;
+inline int MapType::_internal_int32_key_size() const {
+ return int32_key_.size();
+}
+inline int MapType::int32_key_size() const {
+ return _internal_int32_key_size();
+}
+inline void MapType::clear_int32_key() {
+ int32_key_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >&
+MapType::_internal_int32_key() const {
+ return int32_key_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >&
+MapType::int32_key() const {
+ // @@protoc_insertion_point(field_map:test.vereign.grpc.json.pb.MapType.int32_key)
+ return _internal_int32_key();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >*
+MapType::_internal_mutable_int32_key() {
+ return int32_key_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >*
+MapType::mutable_int32_key() {
+ // @@protoc_insertion_point(field_mutable_map:test.vereign.grpc.json.pb.MapType.int32_key)
+ return _internal_mutable_int32_key();
+}
+
+// map<int64, string> int64_key = 2;
+inline int MapType::_internal_int64_key_size() const {
+ return int64_key_.size();
+}
+inline int MapType::int64_key_size() const {
+ return _internal_int64_key_size();
+}
+inline void MapType::clear_int64_key() {
+ int64_key_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >&
+MapType::_internal_int64_key() const {
+ return int64_key_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >&
+MapType::int64_key() const {
+ // @@protoc_insertion_point(field_map:test.vereign.grpc.json.pb.MapType.int64_key)
+ return _internal_int64_key();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >*
+MapType::_internal_mutable_int64_key() {
+ return int64_key_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >*
+MapType::mutable_int64_key() {
+ // @@protoc_insertion_point(field_mutable_map:test.vereign.grpc.json.pb.MapType.int64_key)
+ return _internal_mutable_int64_key();
+}
+
+// map<uint32, string> uint32_key = 3;
+inline int MapType::_internal_uint32_key_size() const {
+ return uint32_key_.size();
+}
+inline int MapType::uint32_key_size() const {
+ return _internal_uint32_key_size();
+}
+inline void MapType::clear_uint32_key() {
+ uint32_key_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint32, std::string >&
+MapType::_internal_uint32_key() const {
+ return uint32_key_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint32, std::string >&
+MapType::uint32_key() const {
+ // @@protoc_insertion_point(field_map:test.vereign.grpc.json.pb.MapType.uint32_key)
+ return _internal_uint32_key();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint32, std::string >*
+MapType::_internal_mutable_uint32_key() {
+ return uint32_key_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint32, std::string >*
+MapType::mutable_uint32_key() {
+ // @@protoc_insertion_point(field_mutable_map:test.vereign.grpc.json.pb.MapType.uint32_key)
+ return _internal_mutable_uint32_key();
+}
+
+// map<uint64, string> uint64_key = 4;
+inline int MapType::_internal_uint64_key_size() const {
+ return uint64_key_.size();
+}
+inline int MapType::uint64_key_size() const {
+ return _internal_uint64_key_size();
+}
+inline void MapType::clear_uint64_key() {
+ uint64_key_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, std::string >&
+MapType::_internal_uint64_key() const {
+ return uint64_key_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, std::string >&
+MapType::uint64_key() const {
+ // @@protoc_insertion_point(field_map:test.vereign.grpc.json.pb.MapType.uint64_key)
+ return _internal_uint64_key();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, std::string >*
+MapType::_internal_mutable_uint64_key() {
+ return uint64_key_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, std::string >*
+MapType::mutable_uint64_key() {
+ // @@protoc_insertion_point(field_mutable_map:test.vereign.grpc.json.pb.MapType.uint64_key)
+ return _internal_mutable_uint64_key();
+}
+
+// map<sint32, string> sint32_key = 5;
+inline int MapType::_internal_sint32_key_size() const {
+ return sint32_key_.size();
+}
+inline int MapType::sint32_key_size() const {
+ return _internal_sint32_key_size();
+}
+inline void MapType::clear_sint32_key() {
+ sint32_key_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >&
+MapType::_internal_sint32_key() const {
+ return sint32_key_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >&
+MapType::sint32_key() const {
+ // @@protoc_insertion_point(field_map:test.vereign.grpc.json.pb.MapType.sint32_key)
+ return _internal_sint32_key();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >*
+MapType::_internal_mutable_sint32_key() {
+ return sint32_key_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >*
+MapType::mutable_sint32_key() {
+ // @@protoc_insertion_point(field_mutable_map:test.vereign.grpc.json.pb.MapType.sint32_key)
+ return _internal_mutable_sint32_key();
+}
+
+// map<sint64, string> sint64_key = 6;
+inline int MapType::_internal_sint64_key_size() const {
+ return sint64_key_.size();
+}
+inline int MapType::sint64_key_size() const {
+ return _internal_sint64_key_size();
+}
+inline void MapType::clear_sint64_key() {
+ sint64_key_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >&
+MapType::_internal_sint64_key() const {
+ return sint64_key_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >&
+MapType::sint64_key() const {
+ // @@protoc_insertion_point(field_map:test.vereign.grpc.json.pb.MapType.sint64_key)
+ return _internal_sint64_key();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >*
+MapType::_internal_mutable_sint64_key() {
+ return sint64_key_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >*
+MapType::mutable_sint64_key() {
+ // @@protoc_insertion_point(field_mutable_map:test.vereign.grpc.json.pb.MapType.sint64_key)
+ return _internal_mutable_sint64_key();
+}
+
+// map<fixed32, string> fixed32_key = 7;
+inline int MapType::_internal_fixed32_key_size() const {
+ return fixed32_key_.size();
+}
+inline int MapType::fixed32_key_size() const {
+ return _internal_fixed32_key_size();
+}
+inline void MapType::clear_fixed32_key() {
+ fixed32_key_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint32, std::string >&
+MapType::_internal_fixed32_key() const {
+ return fixed32_key_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint32, std::string >&
+MapType::fixed32_key() const {
+ // @@protoc_insertion_point(field_map:test.vereign.grpc.json.pb.MapType.fixed32_key)
+ return _internal_fixed32_key();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint32, std::string >*
+MapType::_internal_mutable_fixed32_key() {
+ return fixed32_key_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint32, std::string >*
+MapType::mutable_fixed32_key() {
+ // @@protoc_insertion_point(field_mutable_map:test.vereign.grpc.json.pb.MapType.fixed32_key)
+ return _internal_mutable_fixed32_key();
+}
+
+// map<fixed64, string> fixed64_key = 8;
+inline int MapType::_internal_fixed64_key_size() const {
+ return fixed64_key_.size();
+}
+inline int MapType::fixed64_key_size() const {
+ return _internal_fixed64_key_size();
+}
+inline void MapType::clear_fixed64_key() {
+ fixed64_key_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, std::string >&
+MapType::_internal_fixed64_key() const {
+ return fixed64_key_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, std::string >&
+MapType::fixed64_key() const {
+ // @@protoc_insertion_point(field_map:test.vereign.grpc.json.pb.MapType.fixed64_key)
+ return _internal_fixed64_key();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, std::string >*
+MapType::_internal_mutable_fixed64_key() {
+ return fixed64_key_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, std::string >*
+MapType::mutable_fixed64_key() {
+ // @@protoc_insertion_point(field_mutable_map:test.vereign.grpc.json.pb.MapType.fixed64_key)
+ return _internal_mutable_fixed64_key();
+}
+
+// map<sfixed32, string> sfixed32_key = 9;
+inline int MapType::_internal_sfixed32_key_size() const {
+ return sfixed32_key_.size();
+}
+inline int MapType::sfixed32_key_size() const {
+ return _internal_sfixed32_key_size();
+}
+inline void MapType::clear_sfixed32_key() {
+ sfixed32_key_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >&
+MapType::_internal_sfixed32_key() const {
+ return sfixed32_key_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >&
+MapType::sfixed32_key() const {
+ // @@protoc_insertion_point(field_map:test.vereign.grpc.json.pb.MapType.sfixed32_key)
+ return _internal_sfixed32_key();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >*
+MapType::_internal_mutable_sfixed32_key() {
+ return sfixed32_key_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >*
+MapType::mutable_sfixed32_key() {
+ // @@protoc_insertion_point(field_mutable_map:test.vereign.grpc.json.pb.MapType.sfixed32_key)
+ return _internal_mutable_sfixed32_key();
+}
+
+// map<sfixed64, string> sfixed64_key = 10;
+inline int MapType::_internal_sfixed64_key_size() const {
+ return sfixed64_key_.size();
+}
+inline int MapType::sfixed64_key_size() const {
+ return _internal_sfixed64_key_size();
+}
+inline void MapType::clear_sfixed64_key() {
+ sfixed64_key_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >&
+MapType::_internal_sfixed64_key() const {
+ return sfixed64_key_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >&
+MapType::sfixed64_key() const {
+ // @@protoc_insertion_point(field_map:test.vereign.grpc.json.pb.MapType.sfixed64_key)
+ return _internal_sfixed64_key();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >*
+MapType::_internal_mutable_sfixed64_key() {
+ return sfixed64_key_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int64, std::string >*
+MapType::mutable_sfixed64_key() {
+ // @@protoc_insertion_point(field_mutable_map:test.vereign.grpc.json.pb.MapType.sfixed64_key)
+ return _internal_mutable_sfixed64_key();
+}
+
+// map<string, string> string_key = 11;
+inline int MapType::_internal_string_key_size() const {
+ return string_key_.size();
+}
+inline int MapType::string_key_size() const {
+ return _internal_string_key_size();
+}
+inline void MapType::clear_string_key() {
+ string_key_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
+MapType::_internal_string_key() const {
+ return string_key_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
+MapType::string_key() const {
+ // @@protoc_insertion_point(field_map:test.vereign.grpc.json.pb.MapType.string_key)
+ return _internal_string_key();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
+MapType::_internal_mutable_string_key() {
+ return string_key_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
+MapType::mutable_string_key() {
+ // @@protoc_insertion_point(field_mutable_map:test.vereign.grpc.json.pb.MapType.string_key)
+ return _internal_mutable_string_key();
+}
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// MapMessageType
+
+// map<string, .test.vereign.grpc.json.pb.MessageType> msg = 1;
+inline int MapMessageType::_internal_msg_size() const {
+ return msg_.size();
+}
+inline int MapMessageType::msg_size() const {
+ return _internal_msg_size();
+}
+inline void MapMessageType::clear_msg() {
+ msg_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::test::vereign::grpc::json::pb::MessageType >&
+MapMessageType::_internal_msg() const {
+ return msg_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::test::vereign::grpc::json::pb::MessageType >&
+MapMessageType::msg() const {
+ // @@protoc_insertion_point(field_map:test.vereign.grpc.json.pb.MapMessageType.msg)
+ return _internal_msg();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::test::vereign::grpc::json::pb::MessageType >*
+MapMessageType::_internal_mutable_msg() {
+ return msg_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::test::vereign::grpc::json::pb::MessageType >*
+MapMessageType::mutable_msg() {
+ // @@protoc_insertion_point(field_mutable_map:test.vereign.grpc.json.pb.MapMessageType.msg)
+ return _internal_mutable_msg();
+}
+
+// -------------------------------------------------------------------
+
+// BytesType
+
+// bytes bytes_value = 1;
+inline void BytesType::clear_bytes_value() {
+ bytes_value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline const std::string& BytesType::bytes_value() const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.BytesType.bytes_value)
+ return _internal_bytes_value();
+}
+inline void BytesType::set_bytes_value(const std::string& value) {
+ _internal_set_bytes_value(value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.BytesType.bytes_value)
+}
+inline std::string* BytesType::mutable_bytes_value() {
+ // @@protoc_insertion_point(field_mutable:test.vereign.grpc.json.pb.BytesType.bytes_value)
+ return _internal_mutable_bytes_value();
+}
+inline const std::string& BytesType::_internal_bytes_value() const {
+ return bytes_value_.GetNoArena();
+}
+inline void BytesType::_internal_set_bytes_value(const std::string& value) {
+
+ bytes_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+}
+inline void BytesType::set_bytes_value(std::string&& value) {
+
+ bytes_value_.SetNoArena(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+ // @@protoc_insertion_point(field_set_rvalue:test.vereign.grpc.json.pb.BytesType.bytes_value)
+}
+inline void BytesType::set_bytes_value(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+
+ bytes_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+ // @@protoc_insertion_point(field_set_char:test.vereign.grpc.json.pb.BytesType.bytes_value)
+}
+inline void BytesType::set_bytes_value(const void* value, size_t size) {
+
+ bytes_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ ::std::string(reinterpret_cast<const char*>(value), size));
+ // @@protoc_insertion_point(field_set_pointer:test.vereign.grpc.json.pb.BytesType.bytes_value)
+}
+inline std::string* BytesType::_internal_mutable_bytes_value() {
+
+ return bytes_value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline std::string* BytesType::release_bytes_value() {
+ // @@protoc_insertion_point(field_release:test.vereign.grpc.json.pb.BytesType.bytes_value)
+
+ return bytes_value_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline void BytesType::set_allocated_bytes_value(std::string* bytes_value) {
+ if (bytes_value != nullptr) {
+
+ } else {
+
+ }
+ bytes_value_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), bytes_value);
+ // @@protoc_insertion_point(field_set_allocated:test.vereign.grpc.json.pb.BytesType.bytes_value)
+}
+
+// repeated bytes bytes_arr = 2;
+inline int BytesType::_internal_bytes_arr_size() const {
+ return bytes_arr_.size();
+}
+inline int BytesType::bytes_arr_size() const {
+ return _internal_bytes_arr_size();
+}
+inline void BytesType::clear_bytes_arr() {
+ bytes_arr_.Clear();
+}
+inline std::string* BytesType::add_bytes_arr() {
+ // @@protoc_insertion_point(field_add_mutable:test.vereign.grpc.json.pb.BytesType.bytes_arr)
+ return _internal_add_bytes_arr();
+}
+inline const std::string& BytesType::_internal_bytes_arr(int index) const {
+ return bytes_arr_.Get(index);
+}
+inline const std::string& BytesType::bytes_arr(int index) const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.BytesType.bytes_arr)
+ return _internal_bytes_arr(index);
+}
+inline std::string* BytesType::mutable_bytes_arr(int index) {
+ // @@protoc_insertion_point(field_mutable:test.vereign.grpc.json.pb.BytesType.bytes_arr)
+ return bytes_arr_.Mutable(index);
+}
+inline void BytesType::set_bytes_arr(int index, const std::string& value) {
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.BytesType.bytes_arr)
+ bytes_arr_.Mutable(index)->assign(value);
+}
+inline void BytesType::set_bytes_arr(int index, std::string&& value) {
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.BytesType.bytes_arr)
+ bytes_arr_.Mutable(index)->assign(std::move(value));
+}
+inline void BytesType::set_bytes_arr(int index, const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+ bytes_arr_.Mutable(index)->assign(value);
+ // @@protoc_insertion_point(field_set_char:test.vereign.grpc.json.pb.BytesType.bytes_arr)
+}
+inline void BytesType::set_bytes_arr(int index, const void* value, size_t size) {
+ bytes_arr_.Mutable(index)->assign(
+ reinterpret_cast<const char*>(value), size);
+ // @@protoc_insertion_point(field_set_pointer:test.vereign.grpc.json.pb.BytesType.bytes_arr)
+}
+inline std::string* BytesType::_internal_add_bytes_arr() {
+ return bytes_arr_.Add();
+}
+inline void BytesType::add_bytes_arr(const std::string& value) {
+ bytes_arr_.Add()->assign(value);
+ // @@protoc_insertion_point(field_add:test.vereign.grpc.json.pb.BytesType.bytes_arr)
+}
+inline void BytesType::add_bytes_arr(std::string&& value) {
+ bytes_arr_.Add(std::move(value));
+ // @@protoc_insertion_point(field_add:test.vereign.grpc.json.pb.BytesType.bytes_arr)
+}
+inline void BytesType::add_bytes_arr(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+ bytes_arr_.Add()->assign(value);
+ // @@protoc_insertion_point(field_add_char:test.vereign.grpc.json.pb.BytesType.bytes_arr)
+}
+inline void BytesType::add_bytes_arr(const void* value, size_t size) {
+ bytes_arr_.Add()->assign(reinterpret_cast<const char*>(value), size);
+ // @@protoc_insertion_point(field_add_pointer:test.vereign.grpc.json.pb.BytesType.bytes_arr)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+BytesType::bytes_arr() const {
+ // @@protoc_insertion_point(field_list:test.vereign.grpc.json.pb.BytesType.bytes_arr)
+ return bytes_arr_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+BytesType::mutable_bytes_arr() {
+ // @@protoc_insertion_point(field_mutable_list:test.vereign.grpc.json.pb.BytesType.bytes_arr)
+ return &bytes_arr_;
+}
+
+// -------------------------------------------------------------------
+
+// JsonNaming
+
+// int32 foo_value = 1;
+inline void JsonNaming::clear_foo_value() {
+ foo_value_ = 0;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 JsonNaming::_internal_foo_value() const {
+ return foo_value_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 JsonNaming::foo_value() const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.JsonNaming.foo_value)
+ return _internal_foo_value();
+}
+inline void JsonNaming::_internal_set_foo_value(::PROTOBUF_NAMESPACE_ID::int32 value) {
+
+ foo_value_ = value;
+}
+inline void JsonNaming::set_foo_value(::PROTOBUF_NAMESPACE_ID::int32 value) {
+ _internal_set_foo_value(value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.JsonNaming.foo_value)
+}
+
+// int32 barValue = 2;
+inline void JsonNaming::clear_barvalue() {
+ barvalue_ = 0;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 JsonNaming::_internal_barvalue() const {
+ return barvalue_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 JsonNaming::barvalue() const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.JsonNaming.barValue)
+ return _internal_barvalue();
+}
+inline void JsonNaming::_internal_set_barvalue(::PROTOBUF_NAMESPACE_ID::int32 value) {
+
+ barvalue_ = value;
+}
+inline void JsonNaming::set_barvalue(::PROTOBUF_NAMESPACE_ID::int32 value) {
+ _internal_set_barvalue(value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.JsonNaming.barValue)
+}
+
+// int32 BazValue = 3;
+inline void JsonNaming::clear_bazvalue() {
+ bazvalue_ = 0;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 JsonNaming::_internal_bazvalue() const {
+ return bazvalue_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 JsonNaming::bazvalue() const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.JsonNaming.BazValue)
+ return _internal_bazvalue();
+}
+inline void JsonNaming::_internal_set_bazvalue(::PROTOBUF_NAMESPACE_ID::int32 value) {
+
+ bazvalue_ = value;
+}
+inline void JsonNaming::set_bazvalue(::PROTOBUF_NAMESPACE_ID::int32 value) {
+ _internal_set_bazvalue(value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.JsonNaming.BazValue)
+}
+
+// int32 quX_Value = 4;
+inline void JsonNaming::clear_qux_value() {
+ qux_value_ = 0;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 JsonNaming::_internal_qux_value() const {
+ return qux_value_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 JsonNaming::qux_value() const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.JsonNaming.quX_Value)
+ return _internal_qux_value();
+}
+inline void JsonNaming::_internal_set_qux_value(::PROTOBUF_NAMESPACE_ID::int32 value) {
+
+ qux_value_ = value;
+}
+inline void JsonNaming::set_qux_value(::PROTOBUF_NAMESPACE_ID::int32 value) {
+ _internal_set_qux_value(value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.JsonNaming.quX_Value)
+}
+
+// -------------------------------------------------------------------
+
+// OneofValue
+
+// string string_value = 1;
+inline bool OneofValue::_internal_has_string_value() const {
+ return data_case() == kStringValue;
+}
+inline void OneofValue::set_has_string_value() {
+ _oneof_case_[0] = kStringValue;
+}
+inline void OneofValue::clear_string_value() {
+ if (_internal_has_string_value()) {
+ data_.string_value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ clear_has_data();
+ }
+}
+inline const std::string& OneofValue::string_value() const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.OneofValue.string_value)
+ return _internal_string_value();
+}
+inline void OneofValue::set_string_value(const std::string& value) {
+ _internal_set_string_value(value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.OneofValue.string_value)
+}
+inline std::string* OneofValue::mutable_string_value() {
+ // @@protoc_insertion_point(field_mutable:test.vereign.grpc.json.pb.OneofValue.string_value)
+ return _internal_mutable_string_value();
+}
+inline const std::string& OneofValue::_internal_string_value() const {
+ if (_internal_has_string_value()) {
+ return data_.string_value_.GetNoArena();
+ }
+ return *&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void OneofValue::_internal_set_string_value(const std::string& value) {
+ if (!_internal_has_string_value()) {
+ clear_data();
+ set_has_string_value();
+ data_.string_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.string_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+}
+inline void OneofValue::set_string_value(std::string&& value) {
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.OneofValue.string_value)
+ if (!_internal_has_string_value()) {
+ clear_data();
+ set_has_string_value();
+ data_.string_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.string_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+ // @@protoc_insertion_point(field_set_rvalue:test.vereign.grpc.json.pb.OneofValue.string_value)
+}
+inline void OneofValue::set_string_value(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+ if (!_internal_has_string_value()) {
+ clear_data();
+ set_has_string_value();
+ data_.string_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.string_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ ::std::string(value));
+ // @@protoc_insertion_point(field_set_char:test.vereign.grpc.json.pb.OneofValue.string_value)
+}
+inline void OneofValue::set_string_value(const char* value, size_t size) {
+ if (!_internal_has_string_value()) {
+ clear_data();
+ set_has_string_value();
+ data_.string_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.string_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
+ reinterpret_cast<const char*>(value), size));
+ // @@protoc_insertion_point(field_set_pointer:test.vereign.grpc.json.pb.OneofValue.string_value)
+}
+inline std::string* OneofValue::_internal_mutable_string_value() {
+ if (!_internal_has_string_value()) {
+ clear_data();
+ set_has_string_value();
+ data_.string_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ return data_.string_value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline std::string* OneofValue::release_string_value() {
+ // @@protoc_insertion_point(field_release:test.vereign.grpc.json.pb.OneofValue.string_value)
+ if (_internal_has_string_value()) {
+ clear_has_data();
+ return data_.string_value_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ } else {
+ return nullptr;
+ }
+}
+inline void OneofValue::set_allocated_string_value(std::string* string_value) {
+ if (has_data()) {
+ clear_data();
+ }
+ if (string_value != nullptr) {
+ set_has_string_value();
+ data_.string_value_.UnsafeSetDefault(string_value);
+ }
+ // @@protoc_insertion_point(field_set_allocated:test.vereign.grpc.json.pb.OneofValue.string_value)
+}
+
+// .test.vereign.grpc.json.pb.SimpleStruct struct_value = 2;
+inline bool OneofValue::_internal_has_struct_value() const {
+ return data_case() == kStructValue;
+}
+inline bool OneofValue::has_struct_value() const {
+ return _internal_has_struct_value();
+}
+inline void OneofValue::set_has_struct_value() {
+ _oneof_case_[0] = kStructValue;
+}
+inline void OneofValue::clear_struct_value() {
+ if (_internal_has_struct_value()) {
+ delete data_.struct_value_;
+ clear_has_data();
+ }
+}
+inline ::test::vereign::grpc::json::pb::SimpleStruct* OneofValue::release_struct_value() {
+ // @@protoc_insertion_point(field_release:test.vereign.grpc.json.pb.OneofValue.struct_value)
+ if (_internal_has_struct_value()) {
+ clear_has_data();
+ ::test::vereign::grpc::json::pb::SimpleStruct* temp = data_.struct_value_;
+ data_.struct_value_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::test::vereign::grpc::json::pb::SimpleStruct& OneofValue::_internal_struct_value() const {
+ return _internal_has_struct_value()
+ ? *data_.struct_value_
+ : *reinterpret_cast< ::test::vereign::grpc::json::pb::SimpleStruct*>(&::test::vereign::grpc::json::pb::_SimpleStruct_default_instance_);
+}
+inline const ::test::vereign::grpc::json::pb::SimpleStruct& OneofValue::struct_value() const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.OneofValue.struct_value)
+ return _internal_struct_value();
+}
+inline ::test::vereign::grpc::json::pb::SimpleStruct* OneofValue::_internal_mutable_struct_value() {
+ if (!_internal_has_struct_value()) {
+ clear_data();
+ set_has_struct_value();
+ data_.struct_value_ = CreateMaybeMessage< ::test::vereign::grpc::json::pb::SimpleStruct >(
+ GetArenaNoVirtual());
+ }
+ return data_.struct_value_;
+}
+inline ::test::vereign::grpc::json::pb::SimpleStruct* OneofValue::mutable_struct_value() {
+ // @@protoc_insertion_point(field_mutable:test.vereign.grpc.json.pb.OneofValue.struct_value)
+ return _internal_mutable_struct_value();
+}
+
+inline bool OneofValue::has_data() const {
+ return data_case() != DATA_NOT_SET;
+}
+inline void OneofValue::clear_has_data() {
+ _oneof_case_[0] = DATA_NOT_SET;
+}
+inline OneofValue::DataCase OneofValue::data_case() const {
+ return OneofValue::DataCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// EnumType
+
+// .test.vereign.grpc.json.pb.EnumType.Corpus corpus = 4;
+inline void EnumType::clear_corpus() {
+ corpus_ = 0;
+}
+inline ::test::vereign::grpc::json::pb::EnumType_Corpus EnumType::_internal_corpus() const {
+ return static_cast< ::test::vereign::grpc::json::pb::EnumType_Corpus >(corpus_);
+}
+inline ::test::vereign::grpc::json::pb::EnumType_Corpus EnumType::corpus() const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.EnumType.corpus)
+ return _internal_corpus();
+}
+inline void EnumType::_internal_set_corpus(::test::vereign::grpc::json::pb::EnumType_Corpus value) {
+
+ corpus_ = value;
+}
+inline void EnumType::set_corpus(::test::vereign::grpc::json::pb::EnumType_Corpus value) {
+ _internal_set_corpus(value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.EnumType.corpus)
+}
+
+// -------------------------------------------------------------------
+
+// RepeatedEnumType
+
+// repeated .test.vereign.grpc.json.pb.RepeatedEnumType.Corpus corpus = 4;
+inline int RepeatedEnumType::_internal_corpus_size() const {
+ return corpus_.size();
+}
+inline int RepeatedEnumType::corpus_size() const {
+ return _internal_corpus_size();
+}
+inline void RepeatedEnumType::clear_corpus() {
+ corpus_.Clear();
+}
+inline ::test::vereign::grpc::json::pb::RepeatedEnumType_Corpus RepeatedEnumType::_internal_corpus(int index) const {
+ return static_cast< ::test::vereign::grpc::json::pb::RepeatedEnumType_Corpus >(corpus_.Get(index));
+}
+inline ::test::vereign::grpc::json::pb::RepeatedEnumType_Corpus RepeatedEnumType::corpus(int index) const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.RepeatedEnumType.corpus)
+ return _internal_corpus(index);
+}
+inline void RepeatedEnumType::set_corpus(int index, ::test::vereign::grpc::json::pb::RepeatedEnumType_Corpus value) {
+ corpus_.Set(index, value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.RepeatedEnumType.corpus)
+}
+inline void RepeatedEnumType::_internal_add_corpus(::test::vereign::grpc::json::pb::RepeatedEnumType_Corpus value) {
+ corpus_.Add(value);
+}
+inline void RepeatedEnumType::add_corpus(::test::vereign::grpc::json::pb::RepeatedEnumType_Corpus value) {
+ // @@protoc_insertion_point(field_add:test.vereign.grpc.json.pb.RepeatedEnumType.corpus)
+ _internal_add_corpus(value);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
+RepeatedEnumType::corpus() const {
+ // @@protoc_insertion_point(field_list:test.vereign.grpc.json.pb.RepeatedEnumType.corpus)
+ return corpus_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+RepeatedEnumType::_internal_mutable_corpus() {
+ return &corpus_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+RepeatedEnumType::mutable_corpus() {
+ // @@protoc_insertion_point(field_mutable_list:test.vereign.grpc.json.pb.RepeatedEnumType.corpus)
+ return _internal_mutable_corpus();
+}
+
+// -------------------------------------------------------------------
+
+// NestedType_NestedFoo_NestedBar
+
+// string Value = 1;
+inline void NestedType_NestedFoo_NestedBar::clear_value() {
+ value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline const std::string& NestedType_NestedFoo_NestedBar::value() const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.NestedType.NestedFoo.NestedBar.Value)
+ return _internal_value();
+}
+inline void NestedType_NestedFoo_NestedBar::set_value(const std::string& value) {
+ _internal_set_value(value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.NestedType.NestedFoo.NestedBar.Value)
+}
+inline std::string* NestedType_NestedFoo_NestedBar::mutable_value() {
+ // @@protoc_insertion_point(field_mutable:test.vereign.grpc.json.pb.NestedType.NestedFoo.NestedBar.Value)
+ return _internal_mutable_value();
+}
+inline const std::string& NestedType_NestedFoo_NestedBar::_internal_value() const {
+ return value_.GetNoArena();
+}
+inline void NestedType_NestedFoo_NestedBar::_internal_set_value(const std::string& value) {
+
+ value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+}
+inline void NestedType_NestedFoo_NestedBar::set_value(std::string&& value) {
+
+ value_.SetNoArena(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+ // @@protoc_insertion_point(field_set_rvalue:test.vereign.grpc.json.pb.NestedType.NestedFoo.NestedBar.Value)
+}
+inline void NestedType_NestedFoo_NestedBar::set_value(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+
+ value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+ // @@protoc_insertion_point(field_set_char:test.vereign.grpc.json.pb.NestedType.NestedFoo.NestedBar.Value)
+}
+inline void NestedType_NestedFoo_NestedBar::set_value(const char* value, size_t size) {
+
+ value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ ::std::string(reinterpret_cast<const char*>(value), size));
+ // @@protoc_insertion_point(field_set_pointer:test.vereign.grpc.json.pb.NestedType.NestedFoo.NestedBar.Value)
+}
+inline std::string* NestedType_NestedFoo_NestedBar::_internal_mutable_value() {
+
+ return value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline std::string* NestedType_NestedFoo_NestedBar::release_value() {
+ // @@protoc_insertion_point(field_release:test.vereign.grpc.json.pb.NestedType.NestedFoo.NestedBar.Value)
+
+ return value_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline void NestedType_NestedFoo_NestedBar::set_allocated_value(std::string* value) {
+ if (value != nullptr) {
+
+ } else {
+
+ }
+ value_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+ // @@protoc_insertion_point(field_set_allocated:test.vereign.grpc.json.pb.NestedType.NestedFoo.NestedBar.Value)
+}
+
+// -------------------------------------------------------------------
+
+// NestedType_NestedFoo
+
+// string value = 1;
+inline void NestedType_NestedFoo::clear_value() {
+ value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline const std::string& NestedType_NestedFoo::value() const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.NestedType.NestedFoo.value)
+ return _internal_value();
+}
+inline void NestedType_NestedFoo::set_value(const std::string& value) {
+ _internal_set_value(value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.NestedType.NestedFoo.value)
+}
+inline std::string* NestedType_NestedFoo::mutable_value() {
+ // @@protoc_insertion_point(field_mutable:test.vereign.grpc.json.pb.NestedType.NestedFoo.value)
+ return _internal_mutable_value();
+}
+inline const std::string& NestedType_NestedFoo::_internal_value() const {
+ return value_.GetNoArena();
+}
+inline void NestedType_NestedFoo::_internal_set_value(const std::string& value) {
+
+ value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+}
+inline void NestedType_NestedFoo::set_value(std::string&& value) {
+
+ value_.SetNoArena(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+ // @@protoc_insertion_point(field_set_rvalue:test.vereign.grpc.json.pb.NestedType.NestedFoo.value)
+}
+inline void NestedType_NestedFoo::set_value(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+
+ value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+ // @@protoc_insertion_point(field_set_char:test.vereign.grpc.json.pb.NestedType.NestedFoo.value)
+}
+inline void NestedType_NestedFoo::set_value(const char* value, size_t size) {
+
+ value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ ::std::string(reinterpret_cast<const char*>(value), size));
+ // @@protoc_insertion_point(field_set_pointer:test.vereign.grpc.json.pb.NestedType.NestedFoo.value)
+}
+inline std::string* NestedType_NestedFoo::_internal_mutable_value() {
+
+ return value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline std::string* NestedType_NestedFoo::release_value() {
+ // @@protoc_insertion_point(field_release:test.vereign.grpc.json.pb.NestedType.NestedFoo.value)
+
+ return value_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline void NestedType_NestedFoo::set_allocated_value(std::string* value) {
+ if (value != nullptr) {
+
+ } else {
+
+ }
+ value_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+ // @@protoc_insertion_point(field_set_allocated:test.vereign.grpc.json.pb.NestedType.NestedFoo.value)
+}
+
+// .test.vereign.grpc.json.pb.NestedType.NestedFoo.NestedBar bar_value = 2;
+inline bool NestedType_NestedFoo::_internal_has_bar_value() const {
+ return this != internal_default_instance() && bar_value_ != nullptr;
+}
+inline bool NestedType_NestedFoo::has_bar_value() const {
+ return _internal_has_bar_value();
+}
+inline void NestedType_NestedFoo::clear_bar_value() {
+ if (GetArenaNoVirtual() == nullptr && bar_value_ != nullptr) {
+ delete bar_value_;
+ }
+ bar_value_ = nullptr;
+}
+inline const ::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar& NestedType_NestedFoo::_internal_bar_value() const {
+ const ::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar* p = bar_value_;
+ return p != nullptr ? *p : *reinterpret_cast<const ::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar*>(
+ &::test::vereign::grpc::json::pb::_NestedType_NestedFoo_NestedBar_default_instance_);
+}
+inline const ::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar& NestedType_NestedFoo::bar_value() const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.NestedType.NestedFoo.bar_value)
+ return _internal_bar_value();
+}
+inline ::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar* NestedType_NestedFoo::release_bar_value() {
+ // @@protoc_insertion_point(field_release:test.vereign.grpc.json.pb.NestedType.NestedFoo.bar_value)
+
+ ::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar* temp = bar_value_;
+ bar_value_ = nullptr;
+ return temp;
+}
+inline ::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar* NestedType_NestedFoo::_internal_mutable_bar_value() {
+
+ if (bar_value_ == nullptr) {
+ auto* p = CreateMaybeMessage<::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar>(GetArenaNoVirtual());
+ bar_value_ = p;
+ }
+ return bar_value_;
+}
+inline ::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar* NestedType_NestedFoo::mutable_bar_value() {
+ // @@protoc_insertion_point(field_mutable:test.vereign.grpc.json.pb.NestedType.NestedFoo.bar_value)
+ return _internal_mutable_bar_value();
+}
+inline void NestedType_NestedFoo::set_allocated_bar_value(::test::vereign::grpc::json::pb::NestedType_NestedFoo_NestedBar* bar_value) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
+ if (message_arena == nullptr) {
+ delete bar_value_;
+ }
+ if (bar_value) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
+ if (message_arena != submessage_arena) {
+ bar_value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, bar_value, submessage_arena);
+ }
+
+ } else {
+
+ }
+ bar_value_ = bar_value;
+ // @@protoc_insertion_point(field_set_allocated:test.vereign.grpc.json.pb.NestedType.NestedFoo.bar_value)
+}
+
+// -------------------------------------------------------------------
+
+// NestedType
+
+// string value = 1;
+inline void NestedType::clear_value() {
+ value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline const std::string& NestedType::value() const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.NestedType.value)
+ return _internal_value();
+}
+inline void NestedType::set_value(const std::string& value) {
+ _internal_set_value(value);
+ // @@protoc_insertion_point(field_set:test.vereign.grpc.json.pb.NestedType.value)
+}
+inline std::string* NestedType::mutable_value() {
+ // @@protoc_insertion_point(field_mutable:test.vereign.grpc.json.pb.NestedType.value)
+ return _internal_mutable_value();
+}
+inline const std::string& NestedType::_internal_value() const {
+ return value_.GetNoArena();
+}
+inline void NestedType::_internal_set_value(const std::string& value) {
+
+ value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+}
+inline void NestedType::set_value(std::string&& value) {
+
+ value_.SetNoArena(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+ // @@protoc_insertion_point(field_set_rvalue:test.vereign.grpc.json.pb.NestedType.value)
+}
+inline void NestedType::set_value(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+
+ value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+ // @@protoc_insertion_point(field_set_char:test.vereign.grpc.json.pb.NestedType.value)
+}
+inline void NestedType::set_value(const char* value, size_t size) {
+
+ value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ ::std::string(reinterpret_cast<const char*>(value), size));
+ // @@protoc_insertion_point(field_set_pointer:test.vereign.grpc.json.pb.NestedType.value)
+}
+inline std::string* NestedType::_internal_mutable_value() {
+
+ return value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline std::string* NestedType::release_value() {
+ // @@protoc_insertion_point(field_release:test.vereign.grpc.json.pb.NestedType.value)
+
+ return value_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline void NestedType::set_allocated_value(std::string* value) {
+ if (value != nullptr) {
+
+ } else {
+
+ }
+ value_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+ // @@protoc_insertion_point(field_set_allocated:test.vereign.grpc.json.pb.NestedType.value)
+}
+
+// .test.vereign.grpc.json.pb.NestedType.NestedFoo foo_value = 2;
+inline bool NestedType::_internal_has_foo_value() const {
+ return this != internal_default_instance() && foo_value_ != nullptr;
+}
+inline bool NestedType::has_foo_value() const {
+ return _internal_has_foo_value();
+}
+inline void NestedType::clear_foo_value() {
+ if (GetArenaNoVirtual() == nullptr && foo_value_ != nullptr) {
+ delete foo_value_;
+ }
+ foo_value_ = nullptr;
+}
+inline const ::test::vereign::grpc::json::pb::NestedType_NestedFoo& NestedType::_internal_foo_value() const {
+ const ::test::vereign::grpc::json::pb::NestedType_NestedFoo* p = foo_value_;
+ return p != nullptr ? *p : *reinterpret_cast<const ::test::vereign::grpc::json::pb::NestedType_NestedFoo*>(
+ &::test::vereign::grpc::json::pb::_NestedType_NestedFoo_default_instance_);
+}
+inline const ::test::vereign::grpc::json::pb::NestedType_NestedFoo& NestedType::foo_value() const {
+ // @@protoc_insertion_point(field_get:test.vereign.grpc.json.pb.NestedType.foo_value)
+ return _internal_foo_value();
+}
+inline ::test::vereign::grpc::json::pb::NestedType_NestedFoo* NestedType::release_foo_value() {
+ // @@protoc_insertion_point(field_release:test.vereign.grpc.json.pb.NestedType.foo_value)
+
+ ::test::vereign::grpc::json::pb::NestedType_NestedFoo* temp = foo_value_;
+ foo_value_ = nullptr;
+ return temp;
+}
+inline ::test::vereign::grpc::json::pb::NestedType_NestedFoo* NestedType::_internal_mutable_foo_value() {
+
+ if (foo_value_ == nullptr) {
+ auto* p = CreateMaybeMessage<::test::vereign::grpc::json::pb::NestedType_NestedFoo>(GetArenaNoVirtual());
+ foo_value_ = p;
+ }
+ return foo_value_;
+}
+inline ::test::vereign::grpc::json::pb::NestedType_NestedFoo* NestedType::mutable_foo_value() {
+ // @@protoc_insertion_point(field_mutable:test.vereign.grpc.json.pb.NestedType.foo_value)
+ return _internal_mutable_foo_value();
+}
+inline void NestedType::set_allocated_foo_value(::test::vereign::grpc::json::pb::NestedType_NestedFoo* foo_value) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
+ if (message_arena == nullptr) {
+ delete foo_value_;
+ }
+ if (foo_value) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
+ if (message_arena != submessage_arena) {
+ foo_value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, foo_value, submessage_arena);
+ }
+
+ } else {
+
+ }
+ foo_value_ = foo_value;
+ // @@protoc_insertion_point(field_set_allocated:test.vereign.grpc.json.pb.NestedType.foo_value)
+}
+
+#ifdef __GNUC__
+ #pragma GCC diagnostic pop
+#endif // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+} // namespace pb
+} // namespace json
+} // namespace grpc
+} // namespace vereign
+} // namespace test
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::test::vereign::grpc::json::pb::EnumType_Corpus> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::test::vereign::grpc::json::pb::EnumType_Corpus>() {
+ return ::test::vereign::grpc::json::pb::EnumType_Corpus_descriptor();
+}
+template <> struct is_proto_enum< ::test::vereign::grpc::json::pb::RepeatedEnumType_Corpus> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::test::vereign::grpc::json::pb::RepeatedEnumType_Corpus>() {
+ return ::test::vereign::grpc::json::pb::RepeatedEnumType_Corpus_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_messages_2eproto
diff --git a/cpp/tests/vereign/grpc/json/proto/messages.proto b/cpp/tests/vereign/grpc/json/proto/messages.proto
new file mode 100644
index 0000000000000000000000000000000000000000..d698eabaeab20d606ef6f517125a4f8f3fe1fd49
--- /dev/null
+++ b/cpp/tests/vereign/grpc/json/proto/messages.proto
@@ -0,0 +1,131 @@
+syntax = "proto3";
+
+package test.vereign.grpc.json.pb;
+
+message SimpleStruct {
+ int32 int32_value = 1;
+ int64 int64_value = 2;
+ uint32 uint32_value = 3;
+ uint64 uint64_value = 4;
+ sint32 sint32_value = 5;
+ sint64 sint64_value = 6;
+ fixed32 fixed32_value = 7;
+ fixed64 fixed64_value = 8;
+ sfixed32 sfixed32_value = 9;
+ sfixed64 sfixed64_value = 10;
+ float float_value = 11;
+ double double_value = 12;
+
+ bool bool_value = 13;
+ string string_value = 14;
+}
+
+message RepeatedTypes {
+ repeated int32 int32_arr = 1;
+ repeated int64 int64_arr = 2;
+ repeated uint32 uint32_arr = 3;
+ repeated uint64 uint64_arr = 4;
+ repeated sint32 sint32_arr = 5;
+ repeated sint64 sint64_arr = 6;
+ repeated fixed32 fixed32_arr = 7;
+ repeated fixed64 fixed64_arr = 8;
+ repeated sfixed32 sfixed32_arr = 9;
+ repeated sfixed64 sfixed64_arr = 10;
+ repeated float float_arr = 11;
+ repeated double double_arr = 12;
+
+ repeated bool bool_arr = 13;
+ repeated string string_arr = 14;
+}
+
+message Bar {
+ string value = 2;
+}
+
+message Foo {
+ string value = 1;
+ Bar bar = 2;
+}
+
+message MessageType {
+ Foo foo = 1;
+ repeated Foo foo_arr = 2;
+}
+
+message MapType {
+ map<int32, string> int32_key = 1;
+ map<int64, string> int64_key = 2;
+ map<uint32, string> uint32_key = 3;
+ map<uint64, string> uint64_key = 4;
+ map<sint32, string> sint32_key = 5;
+ map<sint64, string> sint64_key = 6;
+ map<fixed32, string> fixed32_key = 7;
+ map<fixed64, string> fixed64_key = 8;
+ map<sfixed32, string> sfixed32_key = 9;
+ map<sfixed64, string> sfixed64_key = 10;
+ map<string, string> string_key = 11;
+}
+
+message MapMessageType {
+ map<string, MessageType> msg = 1;
+}
+
+message BytesType {
+ bytes bytes_value = 1;
+ repeated bytes bytes_arr = 2;
+}
+
+message JsonNaming {
+ int32 foo_value = 1;
+ int32 barValue = 2;
+ int32 BazValue = 3;
+ int32 quX_Value = 4;
+}
+
+message OneofValue {
+ oneof data {
+ string string_value = 1;
+ SimpleStruct struct_value = 2;
+ }
+}
+
+message EnumType {
+ enum Corpus {
+ UNIVERSAL = 0;
+ WEB = 1;
+ IMAGES = 2;
+ LOCAL = 3;
+ NEWS = 4;
+ PRODUCTS = 5;
+ VIDEO = 6;
+ }
+ Corpus corpus = 4;
+}
+
+message RepeatedEnumType {
+ enum Corpus {
+ UNIVERSAL = 0;
+ WEB = 1;
+ IMAGES = 2;
+ LOCAL = 3;
+ NEWS = 4;
+ PRODUCTS = 5;
+ VIDEO = 6;
+ }
+
+ repeated Corpus corpus = 4;
+}
+
+message NestedType {
+ message NestedFoo {
+ message NestedBar {
+ string Value = 1;
+ }
+
+ string value = 1;
+ NestedBar bar_value = 2;
+ }
+
+ string value = 1;
+ NestedFoo foo_value = 2;
+}
diff --git a/cpp/tests/vereign/grpc/server_test.cc b/cpp/tests/vereign/grpc/server_test.cc
index 128d1677d14effcfce9d8334b39bb50338b89f63..61e2ea3874131d4aaff740fea19b6364c26b7273 100644
--- a/cpp/tests/vereign/grpc/server_test.cc
+++ b/cpp/tests/vereign/grpc/server_test.cc
@@ -4,12 +4,12 @@
#include <util/env.hh>
#include <util/protobuf.hh>
-#include "catch.hpp"
+#include <catch2/catch.hpp>
#include "vereign/client_library/types.gen.pb.h"
#include <grpcpp/create_channel.h>
-TEST_CASE("Server", "[vereign/grpc/server][.integration]") {
+TEST_CASE("grpc::Server", "[vereign/grpc/server][.integration]") {
auto publicKey = vereign::test::RequireEnv("TEST_VEREIGN_PUB_KEY");
auto host = vereign::test::RequireEnv("TEST_VEREIGN_API_HOST");
auto port = vereign::test::GetEnv("TEST_VEREIGN_API_PORT", "https");
@@ -25,7 +25,6 @@ TEST_CASE("Server", "[vereign/grpc/server][.integration]") {
);
auto client = vereign::client_library::PassportAPI::NewStub(channel);
- // vereign::client_library::
vereign::client_library::ListPassportsForm req;
vereign::client_library::ListPassportsFormResponse resp;
@@ -60,6 +59,7 @@ TEST_CASE("Server", "[vereign/grpc/server][.integration]") {
}
vereign::client_library::GetInteractionsForm getInterReq;
+ getInterReq.set_uuid(resp.data().at(0).uuid());
vereign::client_library::GetInteractionsFormResponse getInterResp;
::grpc::ClientContext getInterCtx;
status = client->GetInteractions(&getInterCtx, getInterReq, &getInterResp);
diff --git a/cpp/tests/vereign/init_tests.cc b/cpp/tests/vereign/init_tests.cc
new file mode 100644
index 0000000000000000000000000000000000000000..4ed06df1f7bea8cc18ee161389b9c3e2741b08a0
--- /dev/null
+++ b/cpp/tests/vereign/init_tests.cc
@@ -0,0 +1,2 @@
+#define CATCH_CONFIG_MAIN
+#include <catch2/catch.hpp>
diff --git a/cpp/tests/vereign/restapi/client_session_test.cc b/cpp/tests/vereign/restapi/client_session_test.cc
index 3f5bfc4954090610798b84d2c1552a319bc2cd49..36a824999a5c725e0d5443d91c91369fac619c51 100644
--- a/cpp/tests/vereign/restapi/client_session_test.cc
+++ b/cpp/tests/vereign/restapi/client_session_test.cc
@@ -5,7 +5,7 @@
#include <util/env.hh>
#include <util/protobuf.hh>
-#include "catch.hpp"
+#include <catch2/catch.hpp>
#include <boost/asio/io_context.hpp>
#include <boost/asio/ssl/context.hpp>
diff --git a/cpp/tests/vereign/restapi/client_test.cc b/cpp/tests/vereign/restapi/client_test.cc
index 77d23b0f697ac29e1c8ebf418c5a7085037b9fdb..175501b247e0b321e04bd7aa39649094212f2783 100644
--- a/cpp/tests/vereign/restapi/client_test.cc
+++ b/cpp/tests/vereign/restapi/client_test.cc
@@ -7,7 +7,8 @@
#include <util/env.hh>
#include "boost/asio/executor_work_guard.hpp"
-#include "catch.hpp"
+#include "boost/beast/core/error.hpp"
+#include <catch2/catch.hpp>
#include <thread>
#include <boost/asio/io_context.hpp>
diff --git a/cpp/tests/vereign/service/gen/passport_service_test.cc b/cpp/tests/vereign/service/gen/passport_service_test.cc
index 2a296ff5c00688198db49933c6a6266acb925c9b..ec0375b559d44d09d6452604b38af0660932da7e 100644
--- a/cpp/tests/vereign/service/gen/passport_service_test.cc
+++ b/cpp/tests/vereign/service/gen/passport_service_test.cc
@@ -4,7 +4,7 @@
#include <util/env.hh>
#include <util/protobuf.hh>
-#include "catch.hpp"
+#include <catch2/catch.hpp>
#include <boost/asio/io_context.hpp>
#include <boost/asio/ssl/context.hpp>
diff --git a/cpp/tests/vereign/sync/channel_test.cc b/cpp/tests/vereign/sync/channel_test.cc
index aad0ad75914a1085799bf103b20c0e0d4b6b321e..a8fb938eb335f304ea1bf41e681ff2e85f980b7a 100644
--- a/cpp/tests/vereign/sync/channel_test.cc
+++ b/cpp/tests/vereign/sync/channel_test.cc
@@ -1,7 +1,7 @@
#include <vereign/sync/channel.hh>
#include <thread>
-#include "catch.hpp"
+#include <catch2/catch.hpp>
TEST_CASE("Channel::Channel", "[vereign/sync/channel]") {
vereign::sync::Channel<std::string>{10};