diff --git a/cpp/.clang-tidy b/cpp/.clang-tidy
new file mode 100644
index 0000000000000000000000000000000000000000..756a03e01eb88879438b18d2cfd27e75c3092d8b
--- /dev/null
+++ b/cpp/.clang-tidy
@@ -0,0 +1,35 @@
+---
+Checks: 'clang-diagnostic-*,clang-analyzer-*,modernize-*,readability-*,-readability-container-size-empty,-readability-magic-numbers'
+WarningsAsErrors: ''
+HeaderFilterRegex: ''
+AnalyzeTemporaryDtors: false
+FormatStyle: none
+CheckOptions:
+ - key: cert-dcl16-c.NewSuffixes
+ value: 'L;LL;LU;LLU'
+ - key: cert-oop54-cpp.WarnOnlyIfThisHasSuspiciousField
+ value: '0'
+ - key: cppcoreguidelines-explicit-virtual-functions.IgnoreDestructors
+ value: '1'
+ - key: cppcoreguidelines-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic
+ value: '1'
+ - key: google-readability-braces-around-statements.ShortStatementLines
+ value: '1'
+ - key: google-readability-function-size.StatementThreshold
+ value: '800'
+ - key: google-readability-namespace-comments.ShortNamespaceLines
+ value: '10'
+ - key: google-readability-namespace-comments.SpacesBeforeComments
+ value: '2'
+ - key: modernize-loop-convert.MaxCopySize
+ value: '16'
+ - key: modernize-loop-convert.MinConfidence
+ value: reasonable
+ - key: modernize-loop-convert.NamingStyle
+ value: CamelCase
+ - key: modernize-pass-by-value.IncludeStyle
+ value: llvm
+ - key: modernize-replace-auto-ptr.IncludeStyle
+ value: llvm
+ - key: modernize-use-nullptr.NullMacros
+ value: 'NULL'
diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
index a07568a7288588e6d3664098812f19354f4bef7c..81ddf56dc84ab8900038e8c42d02b11bc720bcf4 100644
--- a/cpp/CMakeLists.txt
+++ b/cpp/CMakeLists.txt
@@ -6,6 +6,12 @@ endif()
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 "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")
message(FATAL_ERROR "Microsoft Visual C++ version MSVC 19.0.24215.1 required")
@@ -46,6 +52,9 @@ endif()
if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
set(CMAKE_CXX_FLAGS_RELEASE "-g -O3 -Wall -Wextra -pedantic")
set(CMAKE_CXX_FLAGS_DEBUG "-g -O0 -Wall -Wextra -pedantic")
+ if (VEREIGN_USE_LLD)
+ set(CMAKE_EXE_LINKER_FLAGS "-fuse-ld=lld")
+ endif()
endif()
if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
@@ -78,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 "")
@@ -120,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")
@@ -141,13 +153,14 @@ message(STATUS "summary of build options:
Install prefix: ${CMAKE_INSTALL_PREFIX}
Target system: ${CMAKE_SYSTEM_NAME}
Compiler:
- Build type: ${CMAKE_BUILD_TYPE}
- C compiler: ${CMAKE_C_COMPILER}
- CFLAGS: ${CMAKE_C_FLAGS_${_build_type}} ${CMAKE_C_FLAGS}
- C++ compiler: ${CMAKE_CXX_COMPILER}
- CXXFLAGS: ${CMAKE_CXX_FLAGS_${_build_type}} ${CMAKE_CXX_FLAGS}
- WARNCFLAGS: ${WARNCFLAGS}
- CXX1XCXXFLAGS: ${CXX1XCXXFLAGS}
+ Build type: ${CMAKE_BUILD_TYPE}
+ C compiler: ${CMAKE_C_COMPILER}
+ CFLAGS: ${CMAKE_C_FLAGS_${_build_type}} ${CMAKE_C_FLAGS}
+ C++ compiler: ${CMAKE_CXX_COMPILER}
+ CXXFLAGS: ${CMAKE_CXX_FLAGS_${_build_type}} ${CMAKE_CXX_FLAGS}
+ EXE_LINKER_FLAGS: ${CMAKE_EXE_LINKER_FLAGS_${_build_type}} ${CMAKE_EXE_LINKER_FLAGS}
+ WARNCFLAGS: ${WARNCFLAGS}
+ CXX1XCXXFLAGS: ${CXX1XCXXFLAGS}
Libs:
fmt: ${fmt_FOUND} [${fmt_VERSION}] (DIR='${fmt_DIR}')
OpenSSL: ${OpenSSL_FOUND} [${OPENSSL_VERSION}] (LIBS='${OPENSSL_LIBRARIES}')
@@ -155,4 +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_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/proto b/cpp/proto
index 910d2c372559e31a0f0df6a6e7048e4256d02028..e861100984116aacf6d84cb8a09dc0ef81041509 160000
--- a/cpp/proto
+++ b/cpp/proto
@@ -1 +1 @@
-Subproject commit 910d2c372559e31a0f0df6a6e7048e4256d02028
+Subproject commit e861100984116aacf6d84cb8a09dc0ef81041509
diff --git a/cpp/src/CMakeLists.txt b/cpp/src/CMakeLists.txt
index 4f3b7b095f4b4c6e24219e3013c2a157875c2146..c986d16357924b039fc541d518c51c45906c7578 100644
--- a/cpp/src/CMakeLists.txt
+++ b/cpp/src/CMakeLists.txt
@@ -16,8 +16,14 @@ list(APPEND PROTO_SRC
${CMAKE_SOURCE_DIR}/proto/cpp/google/api/annotations.pb.cc
${CMAKE_SOURCE_DIR}/proto/cpp/google/api/http.pb.cc
- ${CMAKE_SOURCE_DIR}/proto/cpp/code.vereign.com/code/viam-apis/entities-management-agent/api/api.pb.cc
${CMAKE_SOURCE_DIR}/proto/cpp/code.vereign.com/code/viam-apis/versions/api/api.pb.cc
+ ${CMAKE_SOURCE_DIR}/proto/cpp/code.vereign.com/code/viam-apis/audit-log-agent/api/api.pb.cc
+ ${CMAKE_SOURCE_DIR}/proto/cpp/code.vereign.com/code/viam-apis/entities-management-agent/api/api.pb.cc
+ ${CMAKE_SOURCE_DIR}/proto/cpp/code.vereign.com/code/viam-apis/hyperledger-agent/api/api.pb.cc
+ ${CMAKE_SOURCE_DIR}/proto/cpp/code.vereign.com/code/viam-apis/image-storage-agent/api/api.pb.cc
+ ${CMAKE_SOURCE_DIR}/proto/cpp/code.vereign.com/code/viam-apis/restful-api/api/api.pb.cc
+ ${CMAKE_SOURCE_DIR}/proto/cpp/code.vereign.com/code/viam-apis/signing-service-agent/api/api.pb.cc
+ ${CMAKE_SOURCE_DIR}/proto/cpp/code.vereign.com/code/viam-apis/passport-generation-agent/api/api.pb.cc
)
add_library(vereignproto STATIC ${PROTO_SRC})
@@ -29,18 +35,27 @@ target_link_libraries(
OpenSSL::Crypto
$<$<CXX_COMPILER_ID:MSVC>:CRYPT32.LIB>
)
+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
+set(VEREIGNLIB_SRC
vereign/restapi/detail/http_reader.cc
vereign/restapi/client.cc
- vereign/service/gen/passport_service.cc
- vereign/grpc/server.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
)
-add_library(vereignlib STATIC ${vereignlib_src})
-target_link_libraries(
- vereignlib
+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 PRIVATE nlohmann_json::nlohmann_json)
+target_link_libraries(vereignlib PUBLIC
vereignproto
gRPC::grpc++_reflection
gRPC::grpc++
@@ -56,9 +71,22 @@ set(csandbox_sources
add_executable(csandbox ${csandbox_sources})
target_link_libraries(csandbox
- fmt::fmt
- Boost::regex
- Threads::Threads
- OpenSSL::SSL
- $<$<CXX_COMPILER_ID:MSVC>:CRYPT32.LIB>
+ vereignlib
+ # fmt::fmt
+ # Boost::regex
+ # Threads::Threads
+ # OpenSSL::SSL
+ # $<$<CXX_COMPILER_ID:MSVC>:CRYPT32.LIB>
+)
+if (VEREIGN_USE_TIME_TRACE AND CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+ target_compile_options(csandbox
+ PRIVATE "-ftime-trace"
+ )
+endif()
+
+# Generates the gRPC and Vereign services source code.
+add_custom_target(
+ vcl-gen
+ COMMAND vcl-gen generate -v --templates-path=templates --output-path src
+ WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
)
diff --git a/cpp/src/csandbox.cc b/cpp/src/csandbox.cc
index 01b0beb7c2180f353cd1b87e2ae1b4958b297872..7a1eb95ff82436b8f836f9d8e2bdf1e73651a087 100644
--- a/cpp/src/csandbox.cc
+++ b/cpp/src/csandbox.cc
@@ -1,108 +1,6 @@
-#include <functional>
-#include <memory>
-#include <thread>
-#include <future>
#include <iostream>
-#include <type_traits>
-#include <vector>
-#include <boost/bind.hpp>
-#include <boost/optional.hpp>
-namespace experiment {
-
-/**
- * Array with c++11 move semantics for research purposes.
- *
- * @note Do not use this in real code.
- */
-class Array {
- public:
- Array() : arr_{nullptr}, size_{0} {
- std::cout << "default construct " << to_s() << "\n";
- }
-
- Array(std::initializer_list<int> l)
- : arr_(new int[l.size()]{})
- , size_(l.size()) {
-
- std::copy(l.begin(), l.end(), arr_);
- std::cout << "create list " << to_s() << "\n";
- }
-
- Array(const std::vector<int>& src) {
- arr_ = new int[src.size()]{};
- size_ = src.size();
- std::copy(src.begin(), src.end(), arr_);
- std::cout << "create " << to_s() << "\n";
- }
-
- Array(const Array& other) : arr_(new int[other.size_]{}), size_{other.size_} {
- std::copy(other.arr_, other.arr_ + other.size_, arr_);
- std::cout << "copy construct " << to_s() << "\n";
- }
-
- Array& operator=(const Array& other) {
- Array tmp{other};
- swap(*this, tmp);
- std::cout << "copy assign " << to_s() << "\n";
- return *this;
- }
-
- Array(Array&& other) noexcept : arr_{other.arr_}, size_(other.size_) {
- other.arr_ = nullptr;
- other.size_ = 0;
- std::cout << "move construct " << to_s() << "\n";
- }
-
- Array& operator=(Array&& other) noexcept {
- swap(*this, other);
- std::cout << "move assign " << to_s() << "\n";
- return *this;
- }
-
- ~Array() {
- std::cout << "destroy " << to_s() << "\n";
- if (arr_) {
- delete [] arr_;
- }
- }
-
- void reset() {
- if (arr_) {
- delete [] arr_;
- arr_ = nullptr;
- }
- size_ = 0;
- }
-
- std::string to_s() const {
- std::string ret = std::to_string(intptr_t(this)) + " ";
- if (!arr_) {
- return ret;
- }
-
- for (int i = 0; i < size_; i++) {
- ret += std::to_string(arr_[i]) + " ";
- }
-
- return ret;
- }
-
- friend void swap(Array& lhs, Array& rhs) noexcept;
-
- private:
- int* arr_;
- int size_;
-};
-
-void swap(Array& lhs, Array& rhs) noexcept {
- using std::swap;
- swap(lhs.arr_, rhs.arr_);
- swap(lhs.size_, rhs.size_);
-}
-}
-
-using namespace experiment;
-
-int main(int , char* []) {
+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/core/scope_guard.hh b/cpp/src/vereign/core/scope_guard.hh
index 72e40869443fb3b15a342daaee6a1a5a5d8b0402..7c45af0c5b888b76e3782a4262f46d46c5fa51d8 100644
--- a/cpp/src/vereign/core/scope_guard.hh
+++ b/cpp/src/vereign/core/scope_guard.hh
@@ -1,6 +1,9 @@
#ifndef __VEREIGN_CORE_SCOPE_GUARD_HH
#define __VEREIGN_CORE_SCOPE_GUARD_HH
+#include <type_traits>
+#include <utility>
+
namespace vereign {
namespace core {
@@ -23,11 +26,11 @@ private:
};
template<typename Func>
-ScopeGuard<Func> MakeScopeGuard(Func&& func) {
+auto MakeScopeGuard(Func&& func) -> ScopeGuard<Func> {
return ScopeGuard<Func>{std::move(func)};
}
}
}
-#endif
\ No newline at end of file
+#endif
diff --git a/cpp/src/vereign/grpc/gen/action_api.hh b/cpp/src/vereign/grpc/gen/action_api.hh
new file mode 100644
index 0000000000000000000000000000000000000000..22d5f90fda7b335ef1b2742c55c23daeef03a7cc
--- /dev/null
+++ b/cpp/src/vereign/grpc/gen/action_api.hh
@@ -0,0 +1,77 @@
+#ifndef __VEREIGN_GRPC_GEN_ACTION_API_HH
+#define __VEREIGN_GRPC_GEN_ACTION_API_HH
+
+#include <vereign/client_library/action_api.gen.grpc.pb.h>
+
+namespace vereign {
+namespace grpc {
+namespace gen {
+
+template <class VereignService>
+class ActionAPI : public client_library::ActionAPI::Service {
+public:
+ static constexpr const char* Name = "action";
+
+ using VereignServiceType = VereignService;
+ using VereignServicePtr = std::unique_ptr<VereignService>;
+
+ ActionAPI(VereignServicePtr&& service)
+ : service_{std::move(service)}
+ {}
+
+ ActionAPI(const ActionAPI&) = delete;
+ ActionAPI& operator=(const ActionAPI&) = delete;
+
+ ::grpc::Status GetActions(
+ ::grpc::ServerContext*,
+ const client_library::GetActionsForm* request,
+ client_library::GetActionsFormResponse* response
+ ) override {
+ auto result_future = service_->GetActions(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status GetActionsWithoutSession(
+ ::grpc::ServerContext*,
+ const client_library::GetActionsForm* request,
+ client_library::GetActionsFormResponse* response
+ ) override {
+ auto result_future = service_->GetActionsWithoutSession(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+protected:
+ VereignServicePtr service_;
+};
+
+} // gen
+} // namespace grpc
+} // namespace vereign
+
+#endif // __VEREIGN_GRPC_GEN_ACTION_API_HH
diff --git a/cpp/src/vereign/grpc/gen/activity_api.hh b/cpp/src/vereign/grpc/gen/activity_api.hh
new file mode 100644
index 0000000000000000000000000000000000000000..c35dbb03c5a29662dfcbb241fa7494373abbda27
--- /dev/null
+++ b/cpp/src/vereign/grpc/gen/activity_api.hh
@@ -0,0 +1,55 @@
+#ifndef __VEREIGN_GRPC_GEN_ACTIVITY_API_HH
+#define __VEREIGN_GRPC_GEN_ACTIVITY_API_HH
+
+#include <vereign/client_library/activity_api.gen.grpc.pb.h>
+
+namespace vereign {
+namespace grpc {
+namespace gen {
+
+template <class VereignService>
+class ActivityAPI : public client_library::ActivityAPI::Service {
+public:
+ static constexpr const char* Name = "activity";
+
+ using VereignServiceType = VereignService;
+ using VereignServicePtr = std::unique_ptr<VereignService>;
+
+ ActivityAPI(VereignServicePtr&& service)
+ : service_{std::move(service)}
+ {}
+
+ ActivityAPI(const ActivityAPI&) = delete;
+ ActivityAPI& operator=(const ActivityAPI&) = delete;
+
+ ::grpc::Status GetActivity(
+ ::grpc::ServerContext*,
+ const client_library::GetActivityForm* request,
+ client_library::GetActivityFormResponse* response
+ ) override {
+ auto result_future = service_->GetActivity(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+protected:
+ VereignServicePtr service_;
+};
+
+} // gen
+} // namespace grpc
+} // namespace vereign
+
+#endif // __VEREIGN_GRPC_GEN_ACTIVITY_API_HH
diff --git a/cpp/src/vereign/grpc/gen/company_api.hh b/cpp/src/vereign/grpc/gen/company_api.hh
new file mode 100644
index 0000000000000000000000000000000000000000..0dcb8aebb17fe24ed2f8604c418feb28671777d3
--- /dev/null
+++ b/cpp/src/vereign/grpc/gen/company_api.hh
@@ -0,0 +1,517 @@
+#ifndef __VEREIGN_GRPC_GEN_COMPANY_API_HH
+#define __VEREIGN_GRPC_GEN_COMPANY_API_HH
+
+#include <vereign/client_library/company_api.gen.grpc.pb.h>
+
+namespace vereign {
+namespace grpc {
+namespace gen {
+
+template <class VereignService>
+class CompanyAPI : public client_library::CompanyAPI::Service {
+public:
+ static constexpr const char* Name = "company";
+
+ using VereignServiceType = VereignService;
+ using VereignServicePtr = std::unique_ptr<VereignService>;
+
+ CompanyAPI(VereignServicePtr&& service)
+ : service_{std::move(service)}
+ {}
+
+ CompanyAPI(const CompanyAPI&) = delete;
+ CompanyAPI& operator=(const CompanyAPI&) = delete;
+
+ ::grpc::Status AddClaimToProfileTemplate(
+ ::grpc::ServerContext*,
+ const client_library::AddClaimToProfileTemplateForm* request,
+ client_library::AddClaimToProfileTemplateFormResponse* response
+ ) override {
+ auto result_future = service_->AddClaimToProfileTemplate(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status AddEmployee(
+ ::grpc::ServerContext*,
+ const client_library::AddEmployeeForm* request,
+ client_library::AddEmployeeFormResponse* response
+ ) override {
+ auto result_future = service_->AddEmployee(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status AddProfileTemplate(
+ ::grpc::ServerContext*,
+ const client_library::AddProfileTemplateForm* request,
+ client_library::AddProfileTemplateFormResponse* response
+ ) override {
+ auto result_future = service_->AddProfileTemplate(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status AddRole(
+ ::grpc::ServerContext*,
+ const client_library::AddRoleForm* request,
+ client_library::AddRoleFormResponse* response
+ ) override {
+ auto result_future = service_->AddRole(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status AddSharedIdentity(
+ ::grpc::ServerContext*,
+ const client_library::AddSharedIdentityForm* request,
+ client_library::AddSharedIdentityFormResponse* response
+ ) override {
+ auto result_future = service_->AddSharedIdentity(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status ApplyProfileTemplate(
+ ::grpc::ServerContext*,
+ const client_library::ApplyProfileTemplateForm* request,
+ client_library::ApplyProfileTemplateFormResponse* response
+ ) override {
+ auto result_future = service_->ApplyProfileTemplate(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status ApplyRoleTemplatesToEmployee(
+ ::grpc::ServerContext*,
+ const client_library::ApplyRoleTemplatesToEmployeeForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->ApplyRoleTemplatesToEmployee(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status CreateCompany(
+ ::grpc::ServerContext*,
+ const client_library::CreateCompanyForm* request,
+ client_library::CreateCompanyFormResponse* response
+ ) override {
+ auto result_future = service_->CreateCompany(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status DeleteCompanyLogo(
+ ::grpc::ServerContext*,
+ const client_library::DeleteCompanyLogoForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->DeleteCompanyLogo(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status DeleteRole(
+ ::grpc::ServerContext*,
+ const client_library::DeleteRoleForm* request,
+ client_library::DeleteRoleFormResponse* response
+ ) override {
+ auto result_future = service_->DeleteRole(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status GetCompanyLogo(
+ ::grpc::ServerContext*,
+ const client_library::GetCompanyLogoForm* request,
+ client_library::GetCompanyLogoFormResponse* response
+ ) override {
+ auto result_future = service_->GetCompanyLogo(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status GetInfrastructure(
+ ::grpc::ServerContext*,
+ const client_library::GetInfrastructureForm* request,
+ client_library::GetInfrastructureFormResponse* response
+ ) override {
+ auto result_future = service_->GetInfrastructure(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status ListCompanies(
+ ::grpc::ServerContext*,
+ const client_library::ListCompaniesForm* request,
+ client_library::ListCompaniesFormResponse* response
+ ) override {
+ auto result_future = service_->ListCompanies(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status ListEmployees(
+ ::grpc::ServerContext*,
+ const client_library::ListEmployeesForm* request,
+ client_library::ListEmployeesFormResponse* response
+ ) override {
+ auto result_future = service_->ListEmployees(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status ListEmployeesForSharedIdentity(
+ ::grpc::ServerContext*,
+ const client_library::ListEmployeesForSharedIdentityForm* request,
+ client_library::ListEmployeesForSharedIdentityFormResponse* response
+ ) override {
+ auto result_future = service_->ListEmployeesForSharedIdentity(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status ListProfileTemplates(
+ ::grpc::ServerContext*,
+ const client_library::ListProfileTemplatesForm* request,
+ client_library::ListProfileTemplatesFormResponse* response
+ ) override {
+ auto result_future = service_->ListProfileTemplates(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status ListSharedIdentities(
+ ::grpc::ServerContext*,
+ const client_library::ListSharedIdentitiesForm* request,
+ client_library::ListSharedIdentitiesFormResponse* response
+ ) override {
+ auto result_future = service_->ListSharedIdentities(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status ListSharedIdentitiesForEmployee(
+ ::grpc::ServerContext*,
+ const client_library::ListSharedIdentitiesForEmployeeForm* request,
+ client_library::ListSharedIdentitiesForEmployeeFormResponse* response
+ ) override {
+ auto result_future = service_->ListSharedIdentitiesForEmployee(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status ListSubscribedTemplatesToRole(
+ ::grpc::ServerContext*,
+ const client_library::ListSubscribedTemplatesToRoleForm* request,
+ client_library::ListSubscribedTemplatesToRoleFormResponse* response
+ ) override {
+ auto result_future = service_->ListSubscribedTemplatesToRole(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status PutCompanyLogo(
+ ::grpc::ServerContext*,
+ const client_library::PutCompanyLogoForm* request,
+ client_library::PutCompanyLogoFormResponse* response
+ ) override {
+ auto result_future = service_->PutCompanyLogo(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status RemoveClaimFromProfileTemplate(
+ ::grpc::ServerContext*,
+ const client_library::RemoveClaimFromProfileTemplateForm* request,
+ client_library::RemoveClaimFromProfileTemplateFormResponse* response
+ ) override {
+ auto result_future = service_->RemoveClaimFromProfileTemplate(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status UpdateEmployeeStatus(
+ ::grpc::ServerContext*,
+ const client_library::UpdateEmployeeStatusForm* request,
+ client_library::UpdateEmployeeStatusFormResponse* response
+ ) override {
+ auto result_future = service_->UpdateEmployeeStatus(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+protected:
+ VereignServicePtr service_;
+};
+
+} // gen
+} // namespace grpc
+} // namespace vereign
+
+#endif // __VEREIGN_GRPC_GEN_COMPANY_API_HH
diff --git a/cpp/src/vereign/grpc/gen/contacts_api.hh b/cpp/src/vereign/grpc/gen/contacts_api.hh
new file mode 100644
index 0000000000000000000000000000000000000000..86e0c45f2fc2db616a0b4e655b46c54eb8d981af
--- /dev/null
+++ b/cpp/src/vereign/grpc/gen/contacts_api.hh
@@ -0,0 +1,121 @@
+#ifndef __VEREIGN_GRPC_GEN_CONTACTS_API_HH
+#define __VEREIGN_GRPC_GEN_CONTACTS_API_HH
+
+#include <vereign/client_library/contacts_api.gen.grpc.pb.h>
+
+namespace vereign {
+namespace grpc {
+namespace gen {
+
+template <class VereignService>
+class ContactsAPI : public client_library::ContactsAPI::Service {
+public:
+ static constexpr const char* Name = "contacts";
+
+ using VereignServiceType = VereignService;
+ using VereignServicePtr = std::unique_ptr<VereignService>;
+
+ ContactsAPI(VereignServicePtr&& service)
+ : service_{std::move(service)}
+ {}
+
+ ContactsAPI(const ContactsAPI&) = delete;
+ ContactsAPI& operator=(const ContactsAPI&) = delete;
+
+ ::grpc::Status ChangeStatus(
+ ::grpc::ServerContext*,
+ const client_library::ChangeStatusForm* request,
+ client_library::ChangeStatusFormResponse* response
+ ) override {
+ auto result_future = service_->ChangeStatus(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status GetUserContacts(
+ ::grpc::ServerContext*,
+ const client_library::GetUserContactsForm* request,
+ client_library::GetUserContactsFormResponse* response
+ ) override {
+ auto result_future = service_->GetUserContacts(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status ListContacts(
+ ::grpc::ServerContext*,
+ const client_library::ListContactsForm* request,
+ client_library::ListContactsFormResponse* response
+ ) override {
+ auto result_future = service_->ListContacts(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status SearchContacts(
+ ::grpc::ServerContext*,
+ const client_library::SearchContactsForm* request,
+ client_library::SearchContactsFormResponse* response
+ ) override {
+ auto result_future = service_->SearchContacts(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+protected:
+ VereignServicePtr service_;
+};
+
+} // gen
+} // namespace grpc
+} // namespace vereign
+
+#endif // __VEREIGN_GRPC_GEN_CONTACTS_API_HH
diff --git a/cpp/src/vereign/grpc/gen/conversation_api.hh b/cpp/src/vereign/grpc/gen/conversation_api.hh
new file mode 100644
index 0000000000000000000000000000000000000000..9e45baeba539a6b27125dcc3b142ec3e2ff2c3f6
--- /dev/null
+++ b/cpp/src/vereign/grpc/gen/conversation_api.hh
@@ -0,0 +1,121 @@
+#ifndef __VEREIGN_GRPC_GEN_CONVERSATION_API_HH
+#define __VEREIGN_GRPC_GEN_CONVERSATION_API_HH
+
+#include <vereign/client_library/conversation_api.gen.grpc.pb.h>
+
+namespace vereign {
+namespace grpc {
+namespace gen {
+
+template <class VereignService>
+class ConversationAPI : public client_library::ConversationAPI::Service {
+public:
+ static constexpr const char* Name = "conversation";
+
+ using VereignServiceType = VereignService;
+ using VereignServicePtr = std::unique_ptr<VereignService>;
+
+ ConversationAPI(VereignServicePtr&& service)
+ : service_{std::move(service)}
+ {}
+
+ ConversationAPI(const ConversationAPI&) = delete;
+ ConversationAPI& operator=(const ConversationAPI&) = delete;
+
+ ::grpc::Status AddEmail(
+ ::grpc::ServerContext*,
+ const client_library::AddEmailForm* request,
+ client_library::AddEmailFormResponse* response
+ ) override {
+ auto result_future = service_->AddEmail(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status GetConversations(
+ ::grpc::ServerContext*,
+ const client_library::GetConversationsForm* request,
+ client_library::GetConversationsFormResponse* response
+ ) override {
+ auto result_future = service_->GetConversations(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status GetConversationsAndMessageIDByMessageUUID(
+ ::grpc::ServerContext*,
+ const client_library::GetConversationsAndMessageIDByMessageUUIDForm* request,
+ client_library::GetConversationsAndMessageIDByMessageUUIDResponse* response
+ ) override {
+ auto result_future = service_->GetConversationsAndMessageIDByMessageUUID(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status GetEmails(
+ ::grpc::ServerContext*,
+ const client_library::GetEmailsForm* request,
+ client_library::GetEmailsFormResponse* response
+ ) override {
+ auto result_future = service_->GetEmails(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+protected:
+ VereignServicePtr service_;
+};
+
+} // gen
+} // namespace grpc
+} // namespace vereign
+
+#endif // __VEREIGN_GRPC_GEN_CONVERSATION_API_HH
diff --git a/cpp/src/vereign/grpc/gen/delete_api.hh b/cpp/src/vereign/grpc/gen/delete_api.hh
new file mode 100644
index 0000000000000000000000000000000000000000..2a59a2d79dc0cfc5100a1554492398a59151b29c
--- /dev/null
+++ b/cpp/src/vereign/grpc/gen/delete_api.hh
@@ -0,0 +1,77 @@
+#ifndef __VEREIGN_GRPC_GEN_DELETE_API_HH
+#define __VEREIGN_GRPC_GEN_DELETE_API_HH
+
+#include <vereign/client_library/delete_api.gen.grpc.pb.h>
+
+namespace vereign {
+namespace grpc {
+namespace gen {
+
+template <class VereignService>
+class DeleteAPI : public client_library::DeleteAPI::Service {
+public:
+ static constexpr const char* Name = "delete";
+
+ using VereignServiceType = VereignService;
+ using VereignServicePtr = std::unique_ptr<VereignService>;
+
+ DeleteAPI(VereignServicePtr&& service)
+ : service_{std::move(service)}
+ {}
+
+ DeleteAPI(const DeleteAPI&) = delete;
+ DeleteAPI& operator=(const DeleteAPI&) = delete;
+
+ ::grpc::Status DeleteInteraction(
+ ::grpc::ServerContext*,
+ const client_library::DeleteInteractionForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->DeleteInteraction(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status DeletePassport(
+ ::grpc::ServerContext*,
+ const client_library::DeletePassportForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->DeletePassport(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+protected:
+ VereignServicePtr service_;
+};
+
+} // gen
+} // namespace grpc
+} // namespace vereign
+
+#endif // __VEREIGN_GRPC_GEN_DELETE_API_HH
diff --git a/cpp/src/vereign/grpc/gen/document_api.hh b/cpp/src/vereign/grpc/gen/document_api.hh
new file mode 100644
index 0000000000000000000000000000000000000000..47c9a98a13293fcb437c1b66a856128cf8f70b8c
--- /dev/null
+++ b/cpp/src/vereign/grpc/gen/document_api.hh
@@ -0,0 +1,275 @@
+#ifndef __VEREIGN_GRPC_GEN_DOCUMENT_API_HH
+#define __VEREIGN_GRPC_GEN_DOCUMENT_API_HH
+
+#include <vereign/client_library/document_api.gen.grpc.pb.h>
+
+namespace vereign {
+namespace grpc {
+namespace gen {
+
+template <class VereignService>
+class DocumentAPI : public client_library::DocumentAPI::Service {
+public:
+ static constexpr const char* Name = "document";
+
+ using VereignServiceType = VereignService;
+ using VereignServicePtr = std::unique_ptr<VereignService>;
+
+ DocumentAPI(VereignServicePtr&& service)
+ : service_{std::move(service)}
+ {}
+
+ DocumentAPI(const DocumentAPI&) = delete;
+ DocumentAPI& operator=(const DocumentAPI&) = delete;
+
+ ::grpc::Status ConvertDocumentByUUID(
+ ::grpc::ServerContext*,
+ const client_library::ConvertDocumentByUUIDForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->ConvertDocumentByUUID(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status DeleteIdentityImage(
+ ::grpc::ServerContext*,
+ const client_library::DeleteIdentityImageForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->DeleteIdentityImage(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status GetDocument(
+ ::grpc::ServerContext*,
+ const client_library::EmptyRequest* request,
+ client_library::ListDocumentsResponse* response
+ ) override {
+ auto result_future = service_->GetDocument(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status GetDocumentByResourceID(
+ ::grpc::ServerContext*,
+ const client_library::GetDocumentByResourceIDForm* request,
+ client_library::GetDocumentByResourceIDFormResponse* response
+ ) override {
+ auto result_future = service_->GetDocumentByResourceID(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status GetDocumentByUUID(
+ ::grpc::ServerContext*,
+ const client_library::GetDocumentByUUIDForm* request,
+ client_library::GetDocumentByUUIDFormResponse* response
+ ) override {
+ auto result_future = service_->GetDocumentByUUID(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status GetFileInfo(
+ ::grpc::ServerContext*,
+ const client_library::EmptyRequest* request,
+ client_library::GetFileInfoResponse* response
+ ) override {
+ auto result_future = service_->GetFileInfo(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status GetIdentityImage(
+ ::grpc::ServerContext*,
+ const client_library::GetIdentityImageForm* request,
+ client_library::GetIdentityImageFormResponse* response
+ ) override {
+ auto result_future = service_->GetIdentityImage(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status ListDocuments(
+ ::grpc::ServerContext*,
+ const client_library::EmptyRequest* request,
+ client_library::ListDocumentsResponse* response
+ ) override {
+ auto result_future = service_->ListDocuments(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status PutDocumentByUUID(
+ ::grpc::ServerContext*,
+ const client_library::PutDocumentByUUIDForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->PutDocumentByUUID(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status PutIdentityImage(
+ ::grpc::ServerContext*,
+ const client_library::PutIdentityImageForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->PutIdentityImage(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status SignDocumentByUUID(
+ ::grpc::ServerContext*,
+ const client_library::SignDocumentByUUIDForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->SignDocumentByUUID(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+protected:
+ VereignServicePtr service_;
+};
+
+} // gen
+} // namespace grpc
+} // namespace vereign
+
+#endif // __VEREIGN_GRPC_GEN_DOCUMENT_API_HH
diff --git a/cpp/src/vereign/grpc/gen/email_api.hh b/cpp/src/vereign/grpc/gen/email_api.hh
new file mode 100644
index 0000000000000000000000000000000000000000..ce70d4a720b0065d89aa78d617123ebfbb7d16fc
--- /dev/null
+++ b/cpp/src/vereign/grpc/gen/email_api.hh
@@ -0,0 +1,231 @@
+#ifndef __VEREIGN_GRPC_GEN_EMAIL_API_HH
+#define __VEREIGN_GRPC_GEN_EMAIL_API_HH
+
+#include <vereign/client_library/email_api.gen.grpc.pb.h>
+
+namespace vereign {
+namespace grpc {
+namespace gen {
+
+template <class VereignService>
+class EmailAPI : public client_library::EmailAPI::Service {
+public:
+ static constexpr const char* Name = "email";
+
+ using VereignServiceType = VereignService;
+ using VereignServicePtr = std::unique_ptr<VereignService>;
+
+ EmailAPI(VereignServicePtr&& service)
+ : service_{std::move(service)}
+ {}
+
+ EmailAPI(const EmailAPI&) = delete;
+ EmailAPI& operator=(const EmailAPI&) = delete;
+
+ ::grpc::Status GetEmailStatusAll(
+ ::grpc::ServerContext*,
+ const client_library::GetEmailStatusAllForm* request,
+ client_library::GetEmailStatusAllFormResponse* response
+ ) override {
+ auto result_future = service_->GetEmailStatusAll(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status GetEmailStatusList(
+ ::grpc::ServerContext*,
+ const client_library::GetEmailStatusListForm* request,
+ client_library::GetEmailStatusListFormResponse* response
+ ) override {
+ auto result_future = service_->GetEmailStatusList(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status GetGmailMessageIDsByGmailThreadID(
+ ::grpc::ServerContext*,
+ const client_library::GetGmailMessageIDsByGmailThreadIDForm* request,
+ client_library::GetGmailMessageIDsByGmailThreadIDFormResponse* response
+ ) override {
+ auto result_future = service_->GetGmailMessageIDsByGmailThreadID(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status GetMessageIDsByGmailMessageIDs(
+ ::grpc::ServerContext*,
+ const client_library::GetMessageIDsByGmailMessageIDsForm* request,
+ client_library::GetMessageIDsByGmailMessageIDsFormResponse* response
+ ) override {
+ auto result_future = service_->GetMessageIDsByGmailMessageIDs(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status InitializeEmailStatus(
+ ::grpc::ServerContext*,
+ const client_library::InitializeEmailStatusForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->InitializeEmailStatus(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status SendEmailSmtp(
+ ::grpc::ServerContext*,
+ const client_library::SendEmailSmtpForm* request,
+ client_library::SendEmailSmtpFormResponse* response
+ ) override {
+ auto result_future = service_->SendEmailSmtp(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status SendFeedback(
+ ::grpc::ServerContext*,
+ const client_library::SendFeedbackForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->SendFeedback(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status StoreGmailMessageId(
+ ::grpc::ServerContext*,
+ const client_library::StoreGmailMessageIdForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->StoreGmailMessageId(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status UpdateRecipientEmailStatus(
+ ::grpc::ServerContext*,
+ const client_library::UpdateRecipientEmailStatusForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->UpdateRecipientEmailStatus(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+protected:
+ VereignServicePtr service_;
+};
+
+} // gen
+} // namespace grpc
+} // namespace vereign
+
+#endif // __VEREIGN_GRPC_GEN_EMAIL_API_HH
diff --git a/cpp/src/vereign/grpc/gen/entity_api.hh b/cpp/src/vereign/grpc/gen/entity_api.hh
new file mode 100644
index 0000000000000000000000000000000000000000..01f8a0a03de6da27e71c69ee688b23372dc255a8
--- /dev/null
+++ b/cpp/src/vereign/grpc/gen/entity_api.hh
@@ -0,0 +1,517 @@
+#ifndef __VEREIGN_GRPC_GEN_ENTITY_API_HH
+#define __VEREIGN_GRPC_GEN_ENTITY_API_HH
+
+#include <vereign/client_library/entity_api.gen.grpc.pb.h>
+
+namespace vereign {
+namespace grpc {
+namespace gen {
+
+template <class VereignService>
+class EntityAPI : public client_library::EntityAPI::Service {
+public:
+ static constexpr const char* Name = "entity";
+
+ using VereignServiceType = VereignService;
+ using VereignServicePtr = std::unique_ptr<VereignService>;
+
+ EntityAPI(VereignServicePtr&& service)
+ : service_{std::move(service)}
+ {}
+
+ EntityAPI(const EntityAPI&) = delete;
+ EntityAPI& operator=(const EntityAPI&) = delete;
+
+ ::grpc::Status AddChild(
+ ::grpc::ServerContext*,
+ const client_library::AddChildForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->AddChild(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status AddClaim(
+ ::grpc::ServerContext*,
+ const client_library::AddClaimForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->AddClaim(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status AddGuarded(
+ ::grpc::ServerContext*,
+ const client_library::AddGuardedForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->AddGuarded(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status AddGuardian(
+ ::grpc::ServerContext*,
+ const client_library::AddGuardianForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->AddGuardian(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status AddMember(
+ ::grpc::ServerContext*,
+ const client_library::AddMemberForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->AddMember(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status AddMemberOf(
+ ::grpc::ServerContext*,
+ const client_library::AddMemberOfForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->AddMemberOf(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status AddParent(
+ ::grpc::ServerContext*,
+ const client_library::AddParentForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->AddParent(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status AddViewer(
+ ::grpc::ServerContext*,
+ const client_library::AddViewerForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->AddViewer(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status CreateEntity(
+ ::grpc::ServerContext*,
+ const client_library::CreateEntityForm* request,
+ client_library::CreateEntityFormResponse* response
+ ) override {
+ auto result_future = service_->CreateEntity(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status DeleteClaim(
+ ::grpc::ServerContext*,
+ const client_library::DeleteClaimForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->DeleteClaim(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status GetClaim(
+ ::grpc::ServerContext*,
+ const client_library::GetClaimForm* request,
+ client_library::GetClaimFormResponse* response
+ ) override {
+ auto result_future = service_->GetClaim(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status GetEntity(
+ ::grpc::ServerContext*,
+ const client_library::GetEntityForm* request,
+ client_library::GetEntityFormResponse* response
+ ) override {
+ auto result_future = service_->GetEntity(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status RemoveChild(
+ ::grpc::ServerContext*,
+ const client_library::RemoveChildForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->RemoveChild(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status RemoveGuarded(
+ ::grpc::ServerContext*,
+ const client_library::RemoveGuardedForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->RemoveGuarded(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status RemoveGuardian(
+ ::grpc::ServerContext*,
+ const client_library::RemoveGuardianForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->RemoveGuardian(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status RemoveMember(
+ ::grpc::ServerContext*,
+ const client_library::RemoveMemberForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->RemoveMember(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status RemoveMemberOf(
+ ::grpc::ServerContext*,
+ const client_library::RemoveMemberOfForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->RemoveMemberOf(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status RemoveParent(
+ ::grpc::ServerContext*,
+ const client_library::RemoveParentForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->RemoveParent(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status RemoveViewer(
+ ::grpc::ServerContext*,
+ const client_library::RemoveViewerForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->RemoveViewer(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status SendClaimCode(
+ ::grpc::ServerContext*,
+ const client_library::ClaimSendCodeForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->SendClaimCode(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status UpdateClaim(
+ ::grpc::ServerContext*,
+ const client_library::AddClaimForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->UpdateClaim(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status VerifyClaimCode(
+ ::grpc::ServerContext*,
+ const client_library::ClaimVerifyCodeForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->VerifyClaimCode(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+protected:
+ VereignServicePtr service_;
+};
+
+} // gen
+} // namespace grpc
+} // namespace vereign
+
+#endif // __VEREIGN_GRPC_GEN_ENTITY_API_HH
diff --git a/cpp/src/vereign/grpc/gen/event_api.hh b/cpp/src/vereign/grpc/gen/event_api.hh
new file mode 100644
index 0000000000000000000000000000000000000000..4bfbebab356e0134b14bca9ad9b381f0b7eb553f
--- /dev/null
+++ b/cpp/src/vereign/grpc/gen/event_api.hh
@@ -0,0 +1,55 @@
+#ifndef __VEREIGN_GRPC_GEN_EVENT_API_HH
+#define __VEREIGN_GRPC_GEN_EVENT_API_HH
+
+#include <vereign/client_library/event_api.gen.grpc.pb.h>
+
+namespace vereign {
+namespace grpc {
+namespace gen {
+
+template <class VereignService>
+class EventAPI : public client_library::EventAPI::Service {
+public:
+ static constexpr const char* Name = "event";
+
+ using VereignServiceType = VereignService;
+ using VereignServicePtr = std::unique_ptr<VereignService>;
+
+ EventAPI(VereignServicePtr&& service)
+ : service_{std::move(service)}
+ {}
+
+ EventAPI(const EventAPI&) = delete;
+ EventAPI& operator=(const EventAPI&) = delete;
+
+ ::grpc::Status GetEvents(
+ ::grpc::ServerContext*,
+ const client_library::GetEventsForm* request,
+ client_library::GetEventsFormResponse* response
+ ) override {
+ auto result_future = service_->GetEvents(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+protected:
+ VereignServicePtr service_;
+};
+
+} // gen
+} // namespace grpc
+} // namespace vereign
+
+#endif // __VEREIGN_GRPC_GEN_EVENT_API_HH
diff --git a/cpp/src/vereign/grpc/gen/ews_api.hh b/cpp/src/vereign/grpc/gen/ews_api.hh
new file mode 100644
index 0000000000000000000000000000000000000000..15288f41f06170075c2fe6a6a812b18e405ca6c0
--- /dev/null
+++ b/cpp/src/vereign/grpc/gen/ews_api.hh
@@ -0,0 +1,55 @@
+#ifndef __VEREIGN_GRPC_GEN_EWS_API_HH
+#define __VEREIGN_GRPC_GEN_EWS_API_HH
+
+#include <vereign/client_library/ews_api.gen.grpc.pb.h>
+
+namespace vereign {
+namespace grpc {
+namespace gen {
+
+template <class VereignService>
+class EwsAPI : public client_library::EwsAPI::Service {
+public:
+ static constexpr const char* Name = "ews";
+
+ using VereignServiceType = VereignService;
+ using VereignServicePtr = std::unique_ptr<VereignService>;
+
+ EwsAPI(VereignServicePtr&& service)
+ : service_{std::move(service)}
+ {}
+
+ EwsAPI(const EwsAPI&) = delete;
+ EwsAPI& operator=(const EwsAPI&) = delete;
+
+ ::grpc::Status ProxyRequest(
+ ::grpc::ServerContext*,
+ const client_library::EWSProxyRequestForm* request,
+ client_library::EWSProxyRequestFormResponse* response
+ ) override {
+ auto result_future = service_->ProxyRequest(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+protected:
+ VereignServicePtr service_;
+};
+
+} // gen
+} // namespace grpc
+} // namespace vereign
+
+#endif // __VEREIGN_GRPC_GEN_EWS_API_HH
diff --git a/cpp/src/vereign/grpc/gen/gen.cc b/cpp/src/vereign/grpc/gen/gen.cc
new file mode 100644
index 0000000000000000000000000000000000000000..b8e6dcca2553fbdd94197538d44c78dd7b0a6e5e
--- /dev/null
+++ b/cpp/src/vereign/grpc/gen/gen.cc
@@ -0,0 +1,37 @@
+#include <vereign/grpc/gen/gen.hh>
+
+#include <vereign/service/gen/gen.hh>
+#include <vereign/grpc/service_registry.hh>
+
+namespace vereign {
+namespace grpc {
+namespace gen {
+
+void RegisterAll(
+ restapi::ClientSession& client_session,
+ vereign::grpc::ServiceRegistry& service_registry
+) {
+ service_registry.RegisterIfNotExist<ActionAPI<service::gen::ActionService>>(client_session);
+ service_registry.RegisterIfNotExist<ActivityAPI<service::gen::ActivityService>>(client_session);
+ service_registry.RegisterIfNotExist<CompanyAPI<service::gen::CompanyService>>(client_session);
+ service_registry.RegisterIfNotExist<ContactsAPI<service::gen::ContactsService>>(client_session);
+ service_registry.RegisterIfNotExist<ConversationAPI<service::gen::ConversationService>>(client_session);
+ service_registry.RegisterIfNotExist<DeleteAPI<service::gen::DeleteService>>(client_session);
+ service_registry.RegisterIfNotExist<DocumentAPI<service::gen::DocumentService>>(client_session);
+ service_registry.RegisterIfNotExist<EmailAPI<service::gen::EmailService>>(client_session);
+ service_registry.RegisterIfNotExist<EntityAPI<service::gen::EntityService>>(client_session);
+ service_registry.RegisterIfNotExist<EventAPI<service::gen::EventService>>(client_session);
+ service_registry.RegisterIfNotExist<EwsAPI<service::gen::EwsService>>(client_session);
+ service_registry.RegisterIfNotExist<IdentityAPI<service::gen::IdentityService>>(client_session);
+ service_registry.RegisterIfNotExist<InteractionsAPI<service::gen::InteractionsService>>(client_session);
+ service_registry.RegisterIfNotExist<OrdersAPI<service::gen::OrdersService>>(client_session);
+ service_registry.RegisterIfNotExist<PassportAPI<service::gen::PassportService>>(client_session);
+ service_registry.RegisterIfNotExist<ReportingAPI<service::gen::ReportingService>>(client_session);
+ service_registry.RegisterIfNotExist<ResourceAPI<service::gen::ResourceService>>(client_session);
+ service_registry.RegisterIfNotExist<SharingAPI<service::gen::SharingService>>(client_session);
+ service_registry.RegisterIfNotExist<SignAPI<service::gen::SignService>>(client_session);
+}
+
+}
+}
+}
diff --git a/cpp/src/vereign/grpc/gen/gen.hh b/cpp/src/vereign/grpc/gen/gen.hh
index 19a6a01ae58b77428facf215524c6868e9589e64..1f0d44be5fea9c6af85ea0bb1611f19c812d7c0d 100644
--- a/cpp/src/vereign/grpc/gen/gen.hh
+++ b/cpp/src/vereign/grpc/gen/gen.hh
@@ -1,6 +1,42 @@
#ifndef __VEREIGN_GRPC_GEN_GEN_HH
#define __VEREIGN_GRPC_GEN_GEN_HH
+
+#include <vereign/grpc/gen/action_api.hh>
+#include <vereign/grpc/gen/activity_api.hh>
+#include <vereign/grpc/gen/company_api.hh>
+#include <vereign/grpc/gen/contacts_api.hh>
+#include <vereign/grpc/gen/conversation_api.hh>
+#include <vereign/grpc/gen/delete_api.hh>
+#include <vereign/grpc/gen/document_api.hh>
+#include <vereign/grpc/gen/email_api.hh>
+#include <vereign/grpc/gen/entity_api.hh>
+#include <vereign/grpc/gen/event_api.hh>
+#include <vereign/grpc/gen/ews_api.hh>
+#include <vereign/grpc/gen/identity_api.hh>
+#include <vereign/grpc/gen/interactions_api.hh>
+#include <vereign/grpc/gen/orders_api.hh>
#include <vereign/grpc/gen/passport_api.hh>
+#include <vereign/grpc/gen/reporting_api.hh>
+#include <vereign/grpc/gen/resource_api.hh>
+#include <vereign/grpc/gen/sharing_api.hh>
+#include <vereign/grpc/gen/sign_api.hh>
+
+namespace vereign {
+namespace restapi {
+class ClientSession;
+}
+
+namespace grpc {
+
+class ServiceRegistry;
+
+namespace gen {
+
+void RegisterAll(restapi::ClientSession& client_session, grpc::ServiceRegistry& service_registry);
+
+} // namespace gen
+} // namespace grpc
+} // namespace vereign
-#endif
+#endif // __VEREIGN_GRPC_GEN_GEN_HH
diff --git a/cpp/src/vereign/grpc/gen/identity_api.hh b/cpp/src/vereign/grpc/gen/identity_api.hh
new file mode 100644
index 0000000000000000000000000000000000000000..2d9f4dc8501b396ac883b6cc1bd21dbf71edede7
--- /dev/null
+++ b/cpp/src/vereign/grpc/gen/identity_api.hh
@@ -0,0 +1,385 @@
+#ifndef __VEREIGN_GRPC_GEN_IDENTITY_API_HH
+#define __VEREIGN_GRPC_GEN_IDENTITY_API_HH
+
+#include <vereign/client_library/identity_api.gen.grpc.pb.h>
+
+namespace vereign {
+namespace grpc {
+namespace gen {
+
+template <class VereignService>
+class IdentityAPI : public client_library::IdentityAPI::Service {
+public:
+ static constexpr const char* Name = "identity";
+
+ using VereignServiceType = VereignService;
+ using VereignServicePtr = std::unique_ptr<VereignService>;
+
+ IdentityAPI(VereignServicePtr&& service)
+ : service_{std::move(service)}
+ {}
+
+ IdentityAPI(const IdentityAPI&) = delete;
+ IdentityAPI& operator=(const IdentityAPI&) = delete;
+
+ ::grpc::Status AuthorizeDevice(
+ ::grpc::ServerContext*,
+ const client_library::AuthorizeDeviceForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->AuthorizeDevice(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status CancelAction(
+ ::grpc::ServerContext*,
+ const client_library::CancelActionForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->CancelAction(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status ConfirmAction(
+ ::grpc::ServerContext*,
+ const client_library::ConfirmActionExecutionForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->ConfirmAction(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status ConfirmNewCarddavPublicKey(
+ ::grpc::ServerContext*,
+ const client_library::ConfirmNewCarddavPublicKeyForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->ConfirmNewCarddavPublicKey(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status ConfirmNewDevice(
+ ::grpc::ServerContext*,
+ const client_library::ConfirmNewDeviceForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->ConfirmNewDevice(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status GenerateCredentials(
+ ::grpc::ServerContext*,
+ const client_library::GenerateCredentialsForm* request,
+ client_library::GenerateCredentialsFormResponse* response
+ ) override {
+ auto result_future = service_->GenerateCredentials(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status GetAvatar(
+ ::grpc::ServerContext*,
+ const client_library::GetIdentityAvatarForm* request,
+ client_library::GetIdentityAvatarFormResponse* response
+ ) override {
+ auto result_future = service_->GetAvatar(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status GetIdentityProfileData(
+ ::grpc::ServerContext*,
+ const client_library::GetIdentityProfileDataForm* request,
+ client_library::GetIdentityProfileDataFormResponse* response
+ ) override {
+ auto result_future = service_->GetIdentityProfileData(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status HasUnauthorizedDevices(
+ ::grpc::ServerContext*,
+ const client_library::EmptyRequest* request,
+ client_library::HasUnauthorizedDevicesHandlerFormResponse* response
+ ) override {
+ auto result_future = service_->HasUnauthorizedDevices(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status ListDevices(
+ ::grpc::ServerContext*,
+ const client_library::EmptyRequest* request,
+ client_library::ListDevicesHandlerFormResponse* response
+ ) override {
+ auto result_future = service_->ListDevices(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status PullAvatarFromGravatar(
+ ::grpc::ServerContext*,
+ const client_library::PullAvatarFromGravatarForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->PullAvatarFromGravatar(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status Register2FAPublicKey(
+ ::grpc::ServerContext*,
+ const client_library::Register2FAPublicKeyForm* request,
+ client_library::Register2FAPublicKeyFormResponse* response
+ ) override {
+ auto result_future = service_->Register2FAPublicKey(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status RenameDevice(
+ ::grpc::ServerContext*,
+ const client_library::RenameDeviceForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->RenameDevice(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status ResumeDevice(
+ ::grpc::ServerContext*,
+ const client_library::ResumeDeviceForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->ResumeDevice(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status RevokeDevice(
+ ::grpc::ServerContext*,
+ const client_library::RevokeDeviceForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->RevokeDevice(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status SuspendDevice(
+ ::grpc::ServerContext*,
+ const client_library::SuspendDeviceForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->SuspendDevice(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+protected:
+ VereignServicePtr service_;
+};
+
+} // gen
+} // namespace grpc
+} // namespace vereign
+
+#endif // __VEREIGN_GRPC_GEN_IDENTITY_API_HH
diff --git a/cpp/src/vereign/grpc/gen/interactions_api.hh b/cpp/src/vereign/grpc/gen/interactions_api.hh
new file mode 100644
index 0000000000000000000000000000000000000000..b0947b6331d12c93dfd1bcb8cadbf2380beccc6b
--- /dev/null
+++ b/cpp/src/vereign/grpc/gen/interactions_api.hh
@@ -0,0 +1,55 @@
+#ifndef __VEREIGN_GRPC_GEN_INTERACTIONS_API_HH
+#define __VEREIGN_GRPC_GEN_INTERACTIONS_API_HH
+
+#include <vereign/client_library/interactions_api.gen.grpc.pb.h>
+
+namespace vereign {
+namespace grpc {
+namespace gen {
+
+template <class VereignService>
+class InteractionsAPI : public client_library::InteractionsAPI::Service {
+public:
+ static constexpr const char* Name = "interactions";
+
+ using VereignServiceType = VereignService;
+ using VereignServicePtr = std::unique_ptr<VereignService>;
+
+ InteractionsAPI(VereignServicePtr&& service)
+ : service_{std::move(service)}
+ {}
+
+ InteractionsAPI(const InteractionsAPI&) = delete;
+ InteractionsAPI& operator=(const InteractionsAPI&) = delete;
+
+ ::grpc::Status SearchInteractions(
+ ::grpc::ServerContext*,
+ const client_library::SearchInteractionsForm* request,
+ client_library::SearchInteractionsFormResponse* response
+ ) override {
+ auto result_future = service_->SearchInteractions(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+protected:
+ VereignServicePtr service_;
+};
+
+} // gen
+} // namespace grpc
+} // namespace vereign
+
+#endif // __VEREIGN_GRPC_GEN_INTERACTIONS_API_HH
diff --git a/cpp/src/vereign/grpc/gen/orders_api.hh b/cpp/src/vereign/grpc/gen/orders_api.hh
new file mode 100644
index 0000000000000000000000000000000000000000..1fae8e728c7ac5fbae33f5a4cdf689291551c772
--- /dev/null
+++ b/cpp/src/vereign/grpc/gen/orders_api.hh
@@ -0,0 +1,143 @@
+#ifndef __VEREIGN_GRPC_GEN_ORDERS_API_HH
+#define __VEREIGN_GRPC_GEN_ORDERS_API_HH
+
+#include <vereign/client_library/orders_api.gen.grpc.pb.h>
+
+namespace vereign {
+namespace grpc {
+namespace gen {
+
+template <class VereignService>
+class OrdersAPI : public client_library::OrdersAPI::Service {
+public:
+ static constexpr const char* Name = "orders";
+
+ using VereignServiceType = VereignService;
+ using VereignServicePtr = std::unique_ptr<VereignService>;
+
+ OrdersAPI(VereignServicePtr&& service)
+ : service_{std::move(service)}
+ {}
+
+ OrdersAPI(const OrdersAPI&) = delete;
+ OrdersAPI& operator=(const OrdersAPI&) = delete;
+
+ ::grpc::Status ConfirmCardPayment(
+ ::grpc::ServerContext*,
+ const client_library::ConfirmCardPaymentForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->ConfirmCardPayment(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status GetGeneratedInvoiceForOrder(
+ ::grpc::ServerContext*,
+ const client_library::GetGeneratedInvoiceForOrderForm* request,
+ client_library::GetGeneratedInvoiceForOrderFormResponse* response
+ ) override {
+ auto result_future = service_->GetGeneratedInvoiceForOrder(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status GetOrder(
+ ::grpc::ServerContext*,
+ const client_library::GetOrderForm* request,
+ client_library::GetOrderFormResponse* response
+ ) override {
+ auto result_future = service_->GetOrder(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status InitializeCardPayment(
+ ::grpc::ServerContext*,
+ const client_library::InitializeCardPaymentForm* request,
+ client_library::InitializeCardPaymentFormResponse* response
+ ) override {
+ auto result_future = service_->InitializeCardPayment(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status ListOrders(
+ ::grpc::ServerContext*,
+ const client_library::ListOrdersForm* request,
+ client_library::ListOrdersFormResponse* response
+ ) override {
+ auto result_future = service_->ListOrders(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+protected:
+ VereignServicePtr service_;
+};
+
+} // gen
+} // namespace grpc
+} // namespace vereign
+
+#endif // __VEREIGN_GRPC_GEN_ORDERS_API_HH
diff --git a/cpp/src/vereign/grpc/gen/passport_api.hh b/cpp/src/vereign/grpc/gen/passport_api.hh
index 6375e25a71be2adc9f211dbad8d4f6a1126c7c47..14f05684fc6d0e8737c5858ac7f847e073e6c5b4 100644
--- a/cpp/src/vereign/grpc/gen/passport_api.hh
+++ b/cpp/src/vereign/grpc/gen/passport_api.hh
@@ -10,6 +10,9 @@ namespace gen {
template <class VereignService>
class PassportAPI : public client_library::PassportAPI::Service {
public:
+ static constexpr const char* Name = "passport";
+
+ using VereignServiceType = VereignService;
using VereignServicePtr = std::unique_ptr<VereignService>;
PassportAPI(VereignServicePtr&& service)
@@ -19,6 +22,248 @@ public:
PassportAPI(const PassportAPI&) = delete;
PassportAPI& operator=(const PassportAPI&) = delete;
+ ::grpc::Status AttachFunction(
+ ::grpc::ServerContext*,
+ const client_library::AttachFunctionToPassportClaimForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->AttachFunction(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status CallFunction(
+ ::grpc::ServerContext*,
+ const client_library::CallFunctionForm* request,
+ client_library::CallFunctionFormResponse* response
+ ) override {
+ auto result_future = service_->CallFunction(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status GenerateDIDs(
+ ::grpc::ServerContext*,
+ const client_library::GenerateDIDsForm* request,
+ client_library::GenerateDIDsFormResponse* response
+ ) override {
+ auto result_future = service_->GenerateDIDs(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status GetAvatarByPassport(
+ ::grpc::ServerContext*,
+ const client_library::GetAvatarByPassportForm* request,
+ client_library::GetAvatarByPassportFormResponse* response
+ ) override {
+ auto result_future = service_->GetAvatarByPassport(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status GetDIDs(
+ ::grpc::ServerContext*,
+ const client_library::GetDIDsForm* request,
+ client_library::GetDIDsFormResponse* response
+ ) override {
+ auto result_future = service_->GetDIDs(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status GetEmailWithHeaderByPassport(
+ ::grpc::ServerContext*,
+ const client_library::GetEmailWithHeaderByPassportForm* request,
+ client_library::GetEmailWithHeaderByPassportFormResponse* response
+ ) override {
+ auto result_future = service_->GetEmailWithHeaderByPassport(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status GetInteractions(
+ ::grpc::ServerContext*,
+ const client_library::GetInteractionsForm* request,
+ client_library::GetInteractionsFormResponse* response
+ ) override {
+ auto result_future = service_->GetInteractions(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status GetVCardImage(
+ ::grpc::ServerContext*,
+ const client_library::GetVCardImageForm* request,
+ client_library::GetVCardImageFormResponse* response
+ ) override {
+ auto result_future = service_->GetVCardImage(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status GetVCardTemplate(
+ ::grpc::ServerContext*,
+ const client_library::GetVCardTemplateForm* request,
+ client_library::GetVCardTemplateFormResponse* response
+ ) override {
+ auto result_future = service_->GetVCardTemplate(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status LinkClaim(
+ ::grpc::ServerContext*,
+ const client_library::LinkClaimToPassportForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->LinkClaim(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status ListFunctions(
+ ::grpc::ServerContext*,
+ const client_library::EmptyRequest* request,
+ client_library::ListFunctionsResponse* response
+ ) override {
+ auto result_future = service_->ListFunctions(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
::grpc::Status ListPassports(
::grpc::ServerContext*,
const client_library::ListPassportsForm* request,
@@ -41,6 +286,94 @@ public:
return ::grpc::Status::OK;
}
+ ::grpc::Status ListPassportsForSharedIdentity(
+ ::grpc::ServerContext*,
+ const client_library::ListPassportsForSharedIdentityForm* request,
+ client_library::ListPassportsForSharedIdentityFormResponse* response
+ ) override {
+ auto result_future = service_->ListPassportsForSharedIdentity(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status ListSharedIdentitiesWithUser(
+ ::grpc::ServerContext*,
+ const client_library::ListSharedIdentitiesWithUserForm* request,
+ client_library::ListSharedIdentitiesWithUserFormResponse* response
+ ) override {
+ auto result_future = service_->ListSharedIdentitiesWithUser(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status SetVCardImage(
+ ::grpc::ServerContext*,
+ const client_library::SetVCardImageForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->SetVCardImage(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status StoreDIDs(
+ ::grpc::ServerContext*,
+ const client_library::StoreDIDsForm* request,
+ client_library::StoreDIDsFormResponse* response
+ ) override {
+ auto result_future = service_->StoreDIDs(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
protected:
VereignServicePtr service_;
};
diff --git a/cpp/src/vereign/grpc/gen/reporting_api.hh b/cpp/src/vereign/grpc/gen/reporting_api.hh
new file mode 100644
index 0000000000000000000000000000000000000000..bbbf4f0af92943e973006cba9722c138d78c8a88
--- /dev/null
+++ b/cpp/src/vereign/grpc/gen/reporting_api.hh
@@ -0,0 +1,77 @@
+#ifndef __VEREIGN_GRPC_GEN_REPORTING_API_HH
+#define __VEREIGN_GRPC_GEN_REPORTING_API_HH
+
+#include <vereign/client_library/reporting_api.gen.grpc.pb.h>
+
+namespace vereign {
+namespace grpc {
+namespace gen {
+
+template <class VereignService>
+class ReportingAPI : public client_library::ReportingAPI::Service {
+public:
+ static constexpr const char* Name = "reporting";
+
+ using VereignServiceType = VereignService;
+ using VereignServicePtr = std::unique_ptr<VereignService>;
+
+ ReportingAPI(VereignServicePtr&& service)
+ : service_{std::move(service)}
+ {}
+
+ ReportingAPI(const ReportingAPI&) = delete;
+ ReportingAPI& operator=(const ReportingAPI&) = delete;
+
+ ::grpc::Status Getbillingdataforperiod(
+ ::grpc::ServerContext*,
+ const client_library::GetBillingDataForPeriodForm* request,
+ client_library::GetBillingDataForPeriodFormResponse* response
+ ) override {
+ auto result_future = service_->Getbillingdataforperiod(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status Getreporttotaldata(
+ ::grpc::ServerContext*,
+ const client_library::GetReportTotalDataForm* request,
+ client_library::GetReportTotalDataFormResponse* response
+ ) override {
+ auto result_future = service_->Getreporttotaldata(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+protected:
+ VereignServicePtr service_;
+};
+
+} // gen
+} // namespace grpc
+} // namespace vereign
+
+#endif // __VEREIGN_GRPC_GEN_REPORTING_API_HH
diff --git a/cpp/src/vereign/grpc/gen/resource_api.hh b/cpp/src/vereign/grpc/gen/resource_api.hh
new file mode 100644
index 0000000000000000000000000000000000000000..13f6ba243537c313d8f81064199e46a4fe6c7301
--- /dev/null
+++ b/cpp/src/vereign/grpc/gen/resource_api.hh
@@ -0,0 +1,77 @@
+#ifndef __VEREIGN_GRPC_GEN_RESOURCE_API_HH
+#define __VEREIGN_GRPC_GEN_RESOURCE_API_HH
+
+#include <vereign/client_library/resource_api.gen.grpc.pb.h>
+
+namespace vereign {
+namespace grpc {
+namespace gen {
+
+template <class VereignService>
+class ResourceAPI : public client_library::ResourceAPI::Service {
+public:
+ static constexpr const char* Name = "resource";
+
+ using VereignServiceType = VereignService;
+ using VereignServicePtr = std::unique_ptr<VereignService>;
+
+ ResourceAPI(VereignServicePtr&& service)
+ : service_{std::move(service)}
+ {}
+
+ ResourceAPI(const ResourceAPI&) = delete;
+ ResourceAPI& operator=(const ResourceAPI&) = delete;
+
+ ::grpc::Status DeleteResourceByToken(
+ ::grpc::ServerContext*,
+ const client_library::DeleteResourceForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->DeleteResourceByToken(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status StoreResource(
+ ::grpc::ServerContext*,
+ const client_library::StoreResourceForm* request,
+ client_library::StoreResourceFormResponse* response
+ ) override {
+ auto result_future = service_->StoreResource(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+protected:
+ VereignServicePtr service_;
+};
+
+} // gen
+} // namespace grpc
+} // namespace vereign
+
+#endif // __VEREIGN_GRPC_GEN_RESOURCE_API_HH
diff --git a/cpp/src/vereign/grpc/gen/sharing_api.hh b/cpp/src/vereign/grpc/gen/sharing_api.hh
new file mode 100644
index 0000000000000000000000000000000000000000..e52aea713ea225b880fff06a47b6b85c7dbe73c2
--- /dev/null
+++ b/cpp/src/vereign/grpc/gen/sharing_api.hh
@@ -0,0 +1,165 @@
+#ifndef __VEREIGN_GRPC_GEN_SHARING_API_HH
+#define __VEREIGN_GRPC_GEN_SHARING_API_HH
+
+#include <vereign/client_library/sharing_api.gen.grpc.pb.h>
+
+namespace vereign {
+namespace grpc {
+namespace gen {
+
+template <class VereignService>
+class SharingAPI : public client_library::SharingAPI::Service {
+public:
+ static constexpr const char* Name = "sharing";
+
+ using VereignServiceType = VereignService;
+ using VereignServicePtr = std::unique_ptr<VereignService>;
+
+ SharingAPI(VereignServicePtr&& service)
+ : service_{std::move(service)}
+ {}
+
+ SharingAPI(const SharingAPI&) = delete;
+ SharingAPI& operator=(const SharingAPI&) = delete;
+
+ ::grpc::Status AcceptSharingRequestMovePassport(
+ ::grpc::ServerContext*,
+ const client_library::AcceptSharingRequestMovePassportForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->AcceptSharingRequestMovePassport(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status AcceptSharingRequestPersistPassport(
+ ::grpc::ServerContext*,
+ const client_library::AcceptSharingRequestPersistPassportForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->AcceptSharingRequestPersistPassport(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status ListPendingSharingRequests(
+ ::grpc::ServerContext*,
+ const client_library::ListPendingSharingRequestsForm* request,
+ client_library::ListPendingSharingRequestsFormResponse* response
+ ) override {
+ auto result_future = service_->ListPendingSharingRequests(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status ListRejectedSharingRequests(
+ ::grpc::ServerContext*,
+ const client_library::ListRejectedSharingRequestsForm* request,
+ client_library::ListRejectedSharingRequestsFormResponse* response
+ ) override {
+ auto result_future = service_->ListRejectedSharingRequests(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status RejectSharingRequest(
+ ::grpc::ServerContext*,
+ const client_library::RejectSharingRequestForm* request,
+ client_library::EmptyResponse* response
+ ) override {
+ auto result_future = service_->RejectSharingRequest(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status SendShareDocumentRequest(
+ ::grpc::ServerContext*,
+ const client_library::SendShareDocumentRequestForm* request,
+ client_library::SendShareDocumentRequestFormResponse* response
+ ) override {
+ auto result_future = service_->SendShareDocumentRequest(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+protected:
+ VereignServicePtr service_;
+};
+
+} // gen
+} // namespace grpc
+} // namespace vereign
+
+#endif // __VEREIGN_GRPC_GEN_SHARING_API_HH
diff --git a/cpp/src/vereign/grpc/gen/sign_api.hh b/cpp/src/vereign/grpc/gen/sign_api.hh
new file mode 100644
index 0000000000000000000000000000000000000000..7d9cf59d6cda7fd40664b00edaae9f2014907b81
--- /dev/null
+++ b/cpp/src/vereign/grpc/gen/sign_api.hh
@@ -0,0 +1,165 @@
+#ifndef __VEREIGN_GRPC_GEN_SIGN_API_HH
+#define __VEREIGN_GRPC_GEN_SIGN_API_HH
+
+#include <vereign/client_library/sign_api.gen.grpc.pb.h>
+
+namespace vereign {
+namespace grpc {
+namespace gen {
+
+template <class VereignService>
+class SignAPI : public client_library::SignAPI::Service {
+public:
+ static constexpr const char* Name = "sign";
+
+ using VereignServiceType = VereignService;
+ using VereignServicePtr = std::unique_ptr<VereignService>;
+
+ SignAPI(VereignServicePtr&& service)
+ : service_{std::move(service)}
+ {}
+
+ SignAPI(const SignAPI&) = delete;
+ SignAPI& operator=(const SignAPI&) = delete;
+
+ ::grpc::Status GenerateCmsForChain(
+ ::grpc::ServerContext*,
+ const client_library::GenerateCmsForChainForm* request,
+ client_library::GenerateCmsForChainFormResponse* response
+ ) override {
+ auto result_future = service_->GenerateCmsForChain(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status GenerateCmsForPassport(
+ ::grpc::ServerContext*,
+ const client_library::GenerateCmsForPassportForm* request,
+ client_library::GenerateCmsForPassportFormResponse* response
+ ) override {
+ auto result_future = service_->GenerateCmsForPassport(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status ResignEmail(
+ ::grpc::ServerContext*,
+ const client_library::ResignSMIMEForm* request,
+ client_library::ResignSMIMEFormResponse* response
+ ) override {
+ auto result_future = service_->ResignEmail(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status RetrieveRootCertificate(
+ ::grpc::ServerContext*,
+ const client_library::RetrieveRootCertificateForm* request,
+ client_library::RetrieveRootCertificateFormResponse* response
+ ) override {
+ auto result_future = service_->RetrieveRootCertificate(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status SignVCardForChain(
+ ::grpc::ServerContext*,
+ const client_library::SignVCardForChainForm* request,
+ client_library::SignVCardForChainFormResponse* response
+ ) override {
+ auto result_future = service_->SignVCardForChain(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+ ::grpc::Status ValidateVMime(
+ ::grpc::ServerContext*,
+ const client_library::ValidateVMimeForm* request,
+ client_library::ValidateVMimeFormResponse* response
+ ) override {
+ auto result_future = service_->ValidateVMime(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+
+protected:
+ VereignServicePtr service_;
+};
+
+} // gen
+} // namespace grpc
+} // namespace vereign
+
+#endif // __VEREIGN_GRPC_GEN_SIGN_API_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/grpc/passport_api.hh b/cpp/src/vereign/grpc/passport_api.hh
index 09023d481911070168659d49794460aaf6df305e..02eb2b36c07dfe12e4d7f46c9bf67d5a5ffac6bf 100644
--- a/cpp/src/vereign/grpc/passport_api.hh
+++ b/cpp/src/vereign/grpc/passport_api.hh
@@ -9,6 +9,9 @@ namespace grpc {
template <class VereignService>
class PassportAPI final : public gen::PassportAPI<VereignService> {
public:
+ static constexpr const char* Name = gen::PassportAPI<VereignService>::Name;
+
+ using VereignServiceType = VereignService;
using VereignServicePtr = std::unique_ptr<VereignService>;
PassportAPI(VereignServicePtr&& service)
diff --git a/cpp/src/vereign/grpc/server.cc b/cpp/src/vereign/grpc/server.cc
index 1bc187025132bae591bea5271109cf26820aa041..c89a27433ec2628e1feccfa54030c47cb80b3d70 100644
--- a/cpp/src/vereign/grpc/server.cc
+++ b/cpp/src/vereign/grpc/server.cc
@@ -1,31 +1,38 @@
-#include "boost/asio/executor_work_guard.hpp"
-#include "vereign/grpc/gen/passport_api.hh"
-#include "vereign/service/gen/passport_service.hh"
#include <vereign/grpc/server.hh>
+
#include <vereign/restapi/client.hh>
#include <vereign/restapi/client_session.hh>
-
#include <vereign/service/gen/gen.hh>
-#include <vereign/service/passport_service.hh>
-
#include <vereign/grpc/gen/gen.hh>
+#include <vereign/grpc/service_registry.hh>
+
+#include <vereign/service/passport_service.hh>
#include <vereign/grpc/passport_api.hh>
+#include <grpcpp/server.h>
+#include <boost/asio/io_context.hpp>
+#include <boost/asio/ssl/context.hpp>
+#include <boost/asio/executor_work_guard.hpp>
#include <grpcpp/server_builder.h>
#include <grpcpp/server_context.h>
#include <grpcpp/security/server_credentials.h>
+#include <boost/asio/executor_work_guard.hpp>
+
namespace vereign {
namespace grpc {
-Server::Server(
- const std::string& listenAddress,
- const std::string& vereignHost,
- const std::string& vereignPort,
- // FIXME: the public key must come from a storage
- const std::string& publicKey
-)
- : work_guard_{asio::make_work_guard(ioc_)},
+namespace asio = boost::asio;
+
+class Server::Impl {
+public:
+ Impl(
+ const std::string& listenAddress,
+ const std::string& vereignHost,
+ const std::string& vereignPort,
+ // FIXME: the public key must come from a storage
+ const std::string& publicKey
+ ) : work_guard_{asio::make_work_guard(ioc_)},
ssl_context_{asio::ssl::context::tlsv12_client},
client_{std::make_unique<restapi::Client>(
ioc_, ssl_context_, vereignHost, vereignPort
@@ -33,39 +40,79 @@ Server::Server(
client_session_{std::make_unique<restapi::ClientSession>(
*client_, publicKey
)}
-{
- // FIXME: Verify the remote server's certificate
- // ssl_context.set_verify_mode(ssl::verify_peer);
-
- ::grpc::ServerBuilder builder;
- builder.AddListeningPort(
- listenAddress,
- ::grpc::InsecureServerCredentials(),
- &selected_port_
- );
-
- services_.emplace_back(
- std::make_unique<grpc::PassportAPI<service::PassportService>>(
- std::make_unique<service::PassportService>(*client_session_)
- )
- );
-
- for (auto& service : services_) {
- builder.RegisterService(service.get());
+ {
+
+ // FIXME: Verify the remote server's certificate
+ // ssl_context.set_verify_mode(ssl::verify_peer);
+ ::grpc::ServerBuilder builder;
+ builder.AddListeningPort(
+ listenAddress,
+ ::grpc::InsecureServerCredentials(),
+ &selected_port_
+ );
+
+ // register manually written services
+ services_registry_.RegisterIfNotExist<PassportAPI<service::PassportService>>(*client_session_);
+
+ // register all generated services
+ grpc::gen::RegisterAll(*client_session_, services_registry_);
+
+ services_registry_.RegisterIntoBuilder(builder);
+
+ server_ = builder.BuildAndStart();
+ if (server_ == nullptr) {
+ throw std::runtime_error("server start failed");
+ }
+
+ server_thread_ = std::thread([this]() {
+ server_->Wait();
+ });
+
+ service_thread_ = std::thread([this]() {
+ ioc_.run();
+ });
+ }
+
+ void Shutdown() {
+ client_session_->Close();
+
+ server_->Shutdown();
+ if (server_thread_.joinable()) {
+ server_thread_.join();
+ }
+
+ work_guard_.reset();
+ if (service_thread_.joinable()) {
+ service_thread_.join();
+ }
}
- server_ = builder.BuildAndStart();
- if (server_ == nullptr) {
- throw std::runtime_error("server start failed");
+ auto SelectedPort() const -> int {
+ return selected_port_;
}
- server_thread_ = std::thread([this]() {
- server_->Wait();
- });
+private:
+ int selected_port_;
+ asio::io_context ioc_;
+ asio::executor_work_guard<asio::io_context::executor_type> work_guard_;
+ asio::ssl::context ssl_context_;
+ std::unique_ptr<vereign::restapi::Client> client_;
+ std::unique_ptr<vereign::restapi::ClientSession> client_session_;
+ ServiceRegistry services_registry_;
+ std::unique_ptr<::grpc::Server> server_;
+ std::thread server_thread_;
+ std::thread service_thread_;
+};
- service_thread_ = std::thread([this]() {
- ioc_.run();
- });
+Server::Server(
+ const std::string& listenAddress,
+ const std::string& vereignHost,
+ const std::string& vereignPort,
+ // FIXME: the public key must come from a storage
+ const std::string& publicKey
+)
+ : impl_{std::make_unique<Impl>(listenAddress, vereignHost, vereignPort, publicKey)}
+{
}
Server::~Server() {
@@ -73,22 +120,12 @@ Server::~Server() {
}
void Server::Shutdown() {
- client_session_->Close();
-
- server_->Shutdown();
- if (server_thread_.joinable()) {
- server_thread_.join();
- }
-
- work_guard_.reset();
- if (service_thread_.joinable()) {
- service_thread_.join();
- }
+ impl_->Shutdown();
}
-int Server::SelectedPort() const {
- return selected_port_;
+auto Server::SelectedPort() const -> int {
+ return impl_->SelectedPort();
}
-}
-}
+} // namespace grpc
+} // namespace vereign
diff --git a/cpp/src/vereign/grpc/server.hh b/cpp/src/vereign/grpc/server.hh
index f72c981a293b5a957d2aea36f4a443e48d74d189..d2c4cba704280e820ae024d0108c8f892911af40 100644
--- a/cpp/src/vereign/grpc/server.hh
+++ b/cpp/src/vereign/grpc/server.hh
@@ -1,23 +1,12 @@
#ifndef __VEREIGN_GRPC_SERVER_API_HH
#define __VEREIGN_GRPC_SERVER_API_HH
-#include <thread>
-#include <grpcpp/server.h>
-#include <boost/asio/io_context.hpp>
-#include <boost/asio/ssl/context.hpp>
-#include <boost/asio/executor_work_guard.hpp>
+#include <string>
+#include <memory>
namespace vereign {
-
-namespace restapi {
-class Client;
-class ClientSession;
-}
-
namespace grpc {
-namespace asio = boost::asio;
-
/**
* Server is a grpc server that provides the Vereign services.
*
@@ -50,7 +39,7 @@ public:
// Disable copying
Server(const Server&) = delete;
- Server& operator=(const Server&) = delete;
+ auto operator=(const Server&) -> Server& = delete;
/**
* Shutdown the server.
@@ -67,22 +56,14 @@ public:
* Then this method will return the port that the OS assigned to the gRPC
* socket.
*/
- int SelectedPort() const;
+ auto SelectedPort() const -> int;
private:
- int selected_port_;
- asio::io_context ioc_;
- asio::executor_work_guard<asio::io_context::executor_type> work_guard_;
- asio::ssl::context ssl_context_;
- std::unique_ptr<vereign::restapi::Client> client_;
- std::unique_ptr<vereign::restapi::ClientSession> client_session_;
- std::vector<std::unique_ptr<::grpc::Service>> services_;
- std::unique_ptr<::grpc::Server> server_;
- std::thread server_thread_;
- std::thread service_thread_;
+ class Impl;
+ std::unique_ptr<Impl> impl_;
};
-}
-}
+} // namespace grpc
+} // namespace vereign
#endif
diff --git a/cpp/src/vereign/grpc/service_registry.cc b/cpp/src/vereign/grpc/service_registry.cc
new file mode 100644
index 0000000000000000000000000000000000000000..357689f828d972635524f615a4b881bb848b7b2c
--- /dev/null
+++ b/cpp/src/vereign/grpc/service_registry.cc
@@ -0,0 +1,13 @@
+#include <vereign/grpc/service_registry.hh>
+
+namespace vereign {
+namespace grpc {
+
+void ServiceRegistry::RegisterIntoBuilder(::grpc::ServerBuilder& builder) {
+ for (auto& pair : services_) {
+ builder.RegisterService(pair.second.get());
+ }
+}
+
+} // namespace grpc
+} // namespace vereign
diff --git a/cpp/src/vereign/grpc/service_registry.hh b/cpp/src/vereign/grpc/service_registry.hh
new file mode 100644
index 0000000000000000000000000000000000000000..cddc32a89d1a323761bcaa6fa54bb4262a613a89
--- /dev/null
+++ b/cpp/src/vereign/grpc/service_registry.hh
@@ -0,0 +1,36 @@
+#ifndef __VEREIGN_GRPC_SERVICE_REGISTRY_HH
+#define __VEREIGN_GRPC_SERVICE_REGISTRY_HH
+
+#include <grpcpp/server_builder.h>
+#include <vereign/restapi/client_session.hh>
+
+#include <unordered_map>
+
+namespace vereign {
+namespace grpc {
+
+class ServiceRegistry {
+public:
+ void RegisterIntoBuilder(::grpc::ServerBuilder& builder);
+
+ template <class API>
+ bool RegisterIfNotExist(restapi::ClientSession& client_session) {
+ auto it = services_.find(API::Name);
+ if (it != services_.end()) {
+ return false;
+ }
+
+ using Service = typename API::VereignServiceType;
+ services_[API::Name] = std::make_unique<API>(std::make_unique<Service>(client_session));
+
+ return true;
+ }
+
+private:
+ std::unordered_map<std::string, std::unique_ptr<::grpc::Service>> services_;
+};
+
+} // namespace grpc
+} // namespace vereign
+
+#endif // __VEREIGN_GRPC_SERVICE_REGISTRY_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 302ea11046e98f5b65b4f4a4b0034e9942ba50a4..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,46 +40,46 @@ 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 {
- google::protobuf::util::JsonParseOptions options;
- options.ignore_unknown_fields = true;
-
if (httpResp.result() != beast::http::status::ok) {
decodeErrorResponse(httpResp);
return;
}
+ google::protobuf::util::JsonParseOptions options;
+ options.ignore_unknown_fields = true;
+
auto status = google::protobuf::util::JsonStringToMessage(
httpResp.body(),
&*resp_,
@@ -94,29 +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 = true;
- 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 {
@@ -130,7 +118,7 @@ public:
});
}
- const std::string& Path() const override {
+ auto Path() const -> const std::string& override {
return path_;
}
diff --git a/cpp/src/vereign/service/gen/action_service.cc b/cpp/src/vereign/service/gen/action_service.cc
new file mode 100644
index 0000000000000000000000000000000000000000..53d3d6b19b8715e1b5779d73b5d1e29e1567bf19
--- /dev/null
+++ b/cpp/src/vereign/service/gen/action_service.cc
@@ -0,0 +1,45 @@
+#include <vereign/service/gen/action_service.hh>
+#include <vereign/restapi/client_session.hh>
+
+namespace {
+ const std::string getActionsPath = "getActions";
+ const std::string getActionsWithoutSessionPath = "getActionsWithoutSession";
+}
+
+namespace vereign {
+namespace service {
+namespace gen {
+
+const std::string ActionService::ServicePath = "/action/";
+
+ActionService::ActionService(restapi::ClientSession& client_session)
+ : client_session_{client_session}
+{}
+
+std::future<ActionService::GetActionsResult>
+ActionService::GetActions(
+ const client_library::GetActionsForm* req,
+ client_library::GetActionsFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getActionsPath,
+ req,
+ resp
+ );
+}
+
+std::future<ActionService::GetActionsWithoutSessionResult>
+ActionService::GetActionsWithoutSession(
+ const client_library::GetActionsForm* req,
+ client_library::GetActionsFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getActionsWithoutSessionPath,
+ req,
+ resp
+ );
+}
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
diff --git a/cpp/src/vereign/service/gen/action_service.hh b/cpp/src/vereign/service/gen/action_service.hh
new file mode 100644
index 0000000000000000000000000000000000000000..cc2432361053975f973467ea51c7dc3f95af28e6
--- /dev/null
+++ b/cpp/src/vereign/service/gen/action_service.hh
@@ -0,0 +1,57 @@
+#ifndef __VEREIGN_SERVICE_GEN_ACTION_SERVICE_HH
+#define __VEREIGN_SERVICE_GEN_ACTION_SERVICE_HH
+
+#include <vereign/restapi/client_session.hh>
+#include <vereign/restapi/post_result.hh>
+#include <vereign/client_library/types.gen.pb.h>
+
+#include <future>
+
+namespace vereign {
+
+namespace restapi {
+ class ClientSession;
+}
+
+namespace service {
+namespace gen {
+
+template <class Request, class Response>
+using Result = restapi::PostResult<Request, Response>;
+
+class ActionService {
+public:
+ static const std::string ServicePath;
+
+ explicit ActionService(restapi::ClientSession& client_session);
+
+ ActionService(const ActionService&) = delete;
+ ActionService& operator=(const ActionService&) = delete;
+
+ using GetActionsResult = Result<
+ const client_library::GetActionsForm*,
+ client_library::GetActionsFormResponse*>;
+
+ std::future<GetActionsResult> GetActions(
+ const client_library::GetActionsForm* req,
+ client_library::GetActionsFormResponse* resp
+ );
+
+ using GetActionsWithoutSessionResult = Result<
+ const client_library::GetActionsForm*,
+ client_library::GetActionsFormResponse*>;
+
+ std::future<GetActionsWithoutSessionResult> GetActionsWithoutSession(
+ const client_library::GetActionsForm* req,
+ client_library::GetActionsFormResponse* resp
+ );
+
+private:
+ restapi::ClientSession& client_session_;
+};
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
+
+#endif // __VEREIGN_SERVICE_GEN_ACTION_SERVICE_HH
diff --git a/cpp/src/vereign/service/gen/activity_service.cc b/cpp/src/vereign/service/gen/activity_service.cc
new file mode 100644
index 0000000000000000000000000000000000000000..1fc83d3a2b2100d9ec5476d327fba3847dd2187d
--- /dev/null
+++ b/cpp/src/vereign/service/gen/activity_service.cc
@@ -0,0 +1,32 @@
+#include <vereign/service/gen/activity_service.hh>
+#include <vereign/restapi/client_session.hh>
+
+namespace {
+ const std::string getActivityPath = "getActivity";
+}
+
+namespace vereign {
+namespace service {
+namespace gen {
+
+const std::string ActivityService::ServicePath = "/activity/";
+
+ActivityService::ActivityService(restapi::ClientSession& client_session)
+ : client_session_{client_session}
+{}
+
+std::future<ActivityService::GetActivityResult>
+ActivityService::GetActivity(
+ const client_library::GetActivityForm* req,
+ client_library::GetActivityFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getActivityPath,
+ req,
+ resp
+ );
+}
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
diff --git a/cpp/src/vereign/service/gen/activity_service.hh b/cpp/src/vereign/service/gen/activity_service.hh
new file mode 100644
index 0000000000000000000000000000000000000000..620bb3b3404207329bf04cdd0e3a1d7a14459beb
--- /dev/null
+++ b/cpp/src/vereign/service/gen/activity_service.hh
@@ -0,0 +1,48 @@
+#ifndef __VEREIGN_SERVICE_GEN_ACTIVITY_SERVICE_HH
+#define __VEREIGN_SERVICE_GEN_ACTIVITY_SERVICE_HH
+
+#include <vereign/restapi/client_session.hh>
+#include <vereign/restapi/post_result.hh>
+#include <vereign/client_library/types.gen.pb.h>
+
+#include <future>
+
+namespace vereign {
+
+namespace restapi {
+ class ClientSession;
+}
+
+namespace service {
+namespace gen {
+
+template <class Request, class Response>
+using Result = restapi::PostResult<Request, Response>;
+
+class ActivityService {
+public:
+ static const std::string ServicePath;
+
+ explicit ActivityService(restapi::ClientSession& client_session);
+
+ ActivityService(const ActivityService&) = delete;
+ ActivityService& operator=(const ActivityService&) = delete;
+
+ using GetActivityResult = Result<
+ const client_library::GetActivityForm*,
+ client_library::GetActivityFormResponse*>;
+
+ std::future<GetActivityResult> GetActivity(
+ const client_library::GetActivityForm* req,
+ client_library::GetActivityFormResponse* resp
+ );
+
+private:
+ restapi::ClientSession& client_session_;
+};
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
+
+#endif // __VEREIGN_SERVICE_GEN_ACTIVITY_SERVICE_HH
diff --git a/cpp/src/vereign/service/gen/company_service.cc b/cpp/src/vereign/service/gen/company_service.cc
new file mode 100644
index 0000000000000000000000000000000000000000..9cd740d1f6a5140329ed768ac4ed7fbf8e3b36f9
--- /dev/null
+++ b/cpp/src/vereign/service/gen/company_service.cc
@@ -0,0 +1,305 @@
+#include <vereign/service/gen/company_service.hh>
+#include <vereign/restapi/client_session.hh>
+
+namespace {
+ const std::string addClaimToProfileTemplatePath = "addClaimToProfileTemplate";
+ const std::string addEmployeePath = "addEmployee";
+ const std::string addProfileTemplatePath = "addProfileTemplate";
+ const std::string addRolePath = "addRole";
+ const std::string addSharedIdentityPath = "addSharedIdentity";
+ const std::string applyProfileTemplatePath = "applyProfileTemplate";
+ const std::string applyRoleTemplatesToEmployeePath = "applyRoleTemplatesToEmployee";
+ const std::string createCompanyPath = "createCompany";
+ const std::string deleteCompanyLogoPath = "deleteCompanyLogo";
+ const std::string deleteRolePath = "deleteRole";
+ const std::string getCompanyLogoPath = "getCompanyLogo";
+ const std::string getInfrastructurePath = "getInfrastructure";
+ const std::string listCompaniesPath = "listCompanies";
+ const std::string listEmployeesPath = "listEmployees";
+ const std::string listEmployeesForSharedIdentityPath = "listEmployeesForSharedIdentity";
+ const std::string listProfileTemplatesPath = "listProfileTemplates";
+ const std::string listSharedIdentitiesPath = "listSharedIdentities";
+ const std::string listSharedIdentitiesForEmployeePath = "listSharedIdentitiesForEmployee";
+ const std::string listSubscribedTemplatesToRolePath = "listSubscribedTemplatesToRole";
+ const std::string putCompanyLogoPath = "putCompanyLogo";
+ const std::string removeClaimFromProfileTemplatePath = "removeClaimFromProfileTemplate";
+ const std::string updateEmployeeStatusPath = "updateEmployeeStatus";
+}
+
+namespace vereign {
+namespace service {
+namespace gen {
+
+const std::string CompanyService::ServicePath = "/company/";
+
+CompanyService::CompanyService(restapi::ClientSession& client_session)
+ : client_session_{client_session}
+{}
+
+std::future<CompanyService::AddClaimToProfileTemplateResult>
+CompanyService::AddClaimToProfileTemplate(
+ const client_library::AddClaimToProfileTemplateForm* req,
+ client_library::AddClaimToProfileTemplateFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + addClaimToProfileTemplatePath,
+ req,
+ resp
+ );
+}
+
+std::future<CompanyService::AddEmployeeResult>
+CompanyService::AddEmployee(
+ const client_library::AddEmployeeForm* req,
+ client_library::AddEmployeeFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + addEmployeePath,
+ req,
+ resp
+ );
+}
+
+std::future<CompanyService::AddProfileTemplateResult>
+CompanyService::AddProfileTemplate(
+ const client_library::AddProfileTemplateForm* req,
+ client_library::AddProfileTemplateFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + addProfileTemplatePath,
+ req,
+ resp
+ );
+}
+
+std::future<CompanyService::AddRoleResult>
+CompanyService::AddRole(
+ const client_library::AddRoleForm* req,
+ client_library::AddRoleFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + addRolePath,
+ req,
+ resp
+ );
+}
+
+std::future<CompanyService::AddSharedIdentityResult>
+CompanyService::AddSharedIdentity(
+ const client_library::AddSharedIdentityForm* req,
+ client_library::AddSharedIdentityFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + addSharedIdentityPath,
+ req,
+ resp
+ );
+}
+
+std::future<CompanyService::ApplyProfileTemplateResult>
+CompanyService::ApplyProfileTemplate(
+ const client_library::ApplyProfileTemplateForm* req,
+ client_library::ApplyProfileTemplateFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + applyProfileTemplatePath,
+ req,
+ resp
+ );
+}
+
+std::future<CompanyService::ApplyRoleTemplatesToEmployeeResult>
+CompanyService::ApplyRoleTemplatesToEmployee(
+ const client_library::ApplyRoleTemplatesToEmployeeForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + applyRoleTemplatesToEmployeePath,
+ req,
+ resp
+ );
+}
+
+std::future<CompanyService::CreateCompanyResult>
+CompanyService::CreateCompany(
+ const client_library::CreateCompanyForm* req,
+ client_library::CreateCompanyFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + createCompanyPath,
+ req,
+ resp
+ );
+}
+
+std::future<CompanyService::DeleteCompanyLogoResult>
+CompanyService::DeleteCompanyLogo(
+ const client_library::DeleteCompanyLogoForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + deleteCompanyLogoPath,
+ req,
+ resp
+ );
+}
+
+std::future<CompanyService::DeleteRoleResult>
+CompanyService::DeleteRole(
+ const client_library::DeleteRoleForm* req,
+ client_library::DeleteRoleFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + deleteRolePath,
+ req,
+ resp
+ );
+}
+
+std::future<CompanyService::GetCompanyLogoResult>
+CompanyService::GetCompanyLogo(
+ const client_library::GetCompanyLogoForm* req,
+ client_library::GetCompanyLogoFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getCompanyLogoPath,
+ req,
+ resp
+ );
+}
+
+std::future<CompanyService::GetInfrastructureResult>
+CompanyService::GetInfrastructure(
+ const client_library::GetInfrastructureForm* req,
+ client_library::GetInfrastructureFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getInfrastructurePath,
+ req,
+ resp
+ );
+}
+
+std::future<CompanyService::ListCompaniesResult>
+CompanyService::ListCompanies(
+ const client_library::ListCompaniesForm* req,
+ client_library::ListCompaniesFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + listCompaniesPath,
+ req,
+ resp
+ );
+}
+
+std::future<CompanyService::ListEmployeesResult>
+CompanyService::ListEmployees(
+ const client_library::ListEmployeesForm* req,
+ client_library::ListEmployeesFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + listEmployeesPath,
+ req,
+ resp
+ );
+}
+
+std::future<CompanyService::ListEmployeesForSharedIdentityResult>
+CompanyService::ListEmployeesForSharedIdentity(
+ const client_library::ListEmployeesForSharedIdentityForm* req,
+ client_library::ListEmployeesForSharedIdentityFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + listEmployeesForSharedIdentityPath,
+ req,
+ resp
+ );
+}
+
+std::future<CompanyService::ListProfileTemplatesResult>
+CompanyService::ListProfileTemplates(
+ const client_library::ListProfileTemplatesForm* req,
+ client_library::ListProfileTemplatesFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + listProfileTemplatesPath,
+ req,
+ resp
+ );
+}
+
+std::future<CompanyService::ListSharedIdentitiesResult>
+CompanyService::ListSharedIdentities(
+ const client_library::ListSharedIdentitiesForm* req,
+ client_library::ListSharedIdentitiesFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + listSharedIdentitiesPath,
+ req,
+ resp
+ );
+}
+
+std::future<CompanyService::ListSharedIdentitiesForEmployeeResult>
+CompanyService::ListSharedIdentitiesForEmployee(
+ const client_library::ListSharedIdentitiesForEmployeeForm* req,
+ client_library::ListSharedIdentitiesForEmployeeFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + listSharedIdentitiesForEmployeePath,
+ req,
+ resp
+ );
+}
+
+std::future<CompanyService::ListSubscribedTemplatesToRoleResult>
+CompanyService::ListSubscribedTemplatesToRole(
+ const client_library::ListSubscribedTemplatesToRoleForm* req,
+ client_library::ListSubscribedTemplatesToRoleFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + listSubscribedTemplatesToRolePath,
+ req,
+ resp
+ );
+}
+
+std::future<CompanyService::PutCompanyLogoResult>
+CompanyService::PutCompanyLogo(
+ const client_library::PutCompanyLogoForm* req,
+ client_library::PutCompanyLogoFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + putCompanyLogoPath,
+ req,
+ resp
+ );
+}
+
+std::future<CompanyService::RemoveClaimFromProfileTemplateResult>
+CompanyService::RemoveClaimFromProfileTemplate(
+ const client_library::RemoveClaimFromProfileTemplateForm* req,
+ client_library::RemoveClaimFromProfileTemplateFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + removeClaimFromProfileTemplatePath,
+ req,
+ resp
+ );
+}
+
+std::future<CompanyService::UpdateEmployeeStatusResult>
+CompanyService::UpdateEmployeeStatus(
+ const client_library::UpdateEmployeeStatusForm* req,
+ client_library::UpdateEmployeeStatusFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + updateEmployeeStatusPath,
+ req,
+ resp
+ );
+}
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
diff --git a/cpp/src/vereign/service/gen/company_service.hh b/cpp/src/vereign/service/gen/company_service.hh
new file mode 100644
index 0000000000000000000000000000000000000000..ee59d4fe9deecc893a6dfe7ade367ed2f2f8e223
--- /dev/null
+++ b/cpp/src/vereign/service/gen/company_service.hh
@@ -0,0 +1,237 @@
+#ifndef __VEREIGN_SERVICE_GEN_COMPANY_SERVICE_HH
+#define __VEREIGN_SERVICE_GEN_COMPANY_SERVICE_HH
+
+#include <vereign/restapi/client_session.hh>
+#include <vereign/restapi/post_result.hh>
+#include <vereign/client_library/types.gen.pb.h>
+
+#include <future>
+
+namespace vereign {
+
+namespace restapi {
+ class ClientSession;
+}
+
+namespace service {
+namespace gen {
+
+template <class Request, class Response>
+using Result = restapi::PostResult<Request, Response>;
+
+class CompanyService {
+public:
+ static const std::string ServicePath;
+
+ explicit CompanyService(restapi::ClientSession& client_session);
+
+ CompanyService(const CompanyService&) = delete;
+ CompanyService& operator=(const CompanyService&) = delete;
+
+ using AddClaimToProfileTemplateResult = Result<
+ const client_library::AddClaimToProfileTemplateForm*,
+ client_library::AddClaimToProfileTemplateFormResponse*>;
+
+ std::future<AddClaimToProfileTemplateResult> AddClaimToProfileTemplate(
+ const client_library::AddClaimToProfileTemplateForm* req,
+ client_library::AddClaimToProfileTemplateFormResponse* resp
+ );
+
+ using AddEmployeeResult = Result<
+ const client_library::AddEmployeeForm*,
+ client_library::AddEmployeeFormResponse*>;
+
+ std::future<AddEmployeeResult> AddEmployee(
+ const client_library::AddEmployeeForm* req,
+ client_library::AddEmployeeFormResponse* resp
+ );
+
+ using AddProfileTemplateResult = Result<
+ const client_library::AddProfileTemplateForm*,
+ client_library::AddProfileTemplateFormResponse*>;
+
+ std::future<AddProfileTemplateResult> AddProfileTemplate(
+ const client_library::AddProfileTemplateForm* req,
+ client_library::AddProfileTemplateFormResponse* resp
+ );
+
+ using AddRoleResult = Result<
+ const client_library::AddRoleForm*,
+ client_library::AddRoleFormResponse*>;
+
+ std::future<AddRoleResult> AddRole(
+ const client_library::AddRoleForm* req,
+ client_library::AddRoleFormResponse* resp
+ );
+
+ using AddSharedIdentityResult = Result<
+ const client_library::AddSharedIdentityForm*,
+ client_library::AddSharedIdentityFormResponse*>;
+
+ std::future<AddSharedIdentityResult> AddSharedIdentity(
+ const client_library::AddSharedIdentityForm* req,
+ client_library::AddSharedIdentityFormResponse* resp
+ );
+
+ using ApplyProfileTemplateResult = Result<
+ const client_library::ApplyProfileTemplateForm*,
+ client_library::ApplyProfileTemplateFormResponse*>;
+
+ std::future<ApplyProfileTemplateResult> ApplyProfileTemplate(
+ const client_library::ApplyProfileTemplateForm* req,
+ client_library::ApplyProfileTemplateFormResponse* resp
+ );
+
+ using ApplyRoleTemplatesToEmployeeResult = Result<
+ const client_library::ApplyRoleTemplatesToEmployeeForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<ApplyRoleTemplatesToEmployeeResult> ApplyRoleTemplatesToEmployee(
+ const client_library::ApplyRoleTemplatesToEmployeeForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using CreateCompanyResult = Result<
+ const client_library::CreateCompanyForm*,
+ client_library::CreateCompanyFormResponse*>;
+
+ std::future<CreateCompanyResult> CreateCompany(
+ const client_library::CreateCompanyForm* req,
+ client_library::CreateCompanyFormResponse* resp
+ );
+
+ using DeleteCompanyLogoResult = Result<
+ const client_library::DeleteCompanyLogoForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<DeleteCompanyLogoResult> DeleteCompanyLogo(
+ const client_library::DeleteCompanyLogoForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using DeleteRoleResult = Result<
+ const client_library::DeleteRoleForm*,
+ client_library::DeleteRoleFormResponse*>;
+
+ std::future<DeleteRoleResult> DeleteRole(
+ const client_library::DeleteRoleForm* req,
+ client_library::DeleteRoleFormResponse* resp
+ );
+
+ using GetCompanyLogoResult = Result<
+ const client_library::GetCompanyLogoForm*,
+ client_library::GetCompanyLogoFormResponse*>;
+
+ std::future<GetCompanyLogoResult> GetCompanyLogo(
+ const client_library::GetCompanyLogoForm* req,
+ client_library::GetCompanyLogoFormResponse* resp
+ );
+
+ using GetInfrastructureResult = Result<
+ const client_library::GetInfrastructureForm*,
+ client_library::GetInfrastructureFormResponse*>;
+
+ std::future<GetInfrastructureResult> GetInfrastructure(
+ const client_library::GetInfrastructureForm* req,
+ client_library::GetInfrastructureFormResponse* resp
+ );
+
+ using ListCompaniesResult = Result<
+ const client_library::ListCompaniesForm*,
+ client_library::ListCompaniesFormResponse*>;
+
+ std::future<ListCompaniesResult> ListCompanies(
+ const client_library::ListCompaniesForm* req,
+ client_library::ListCompaniesFormResponse* resp
+ );
+
+ using ListEmployeesResult = Result<
+ const client_library::ListEmployeesForm*,
+ client_library::ListEmployeesFormResponse*>;
+
+ std::future<ListEmployeesResult> ListEmployees(
+ const client_library::ListEmployeesForm* req,
+ client_library::ListEmployeesFormResponse* resp
+ );
+
+ using ListEmployeesForSharedIdentityResult = Result<
+ const client_library::ListEmployeesForSharedIdentityForm*,
+ client_library::ListEmployeesForSharedIdentityFormResponse*>;
+
+ std::future<ListEmployeesForSharedIdentityResult> ListEmployeesForSharedIdentity(
+ const client_library::ListEmployeesForSharedIdentityForm* req,
+ client_library::ListEmployeesForSharedIdentityFormResponse* resp
+ );
+
+ using ListProfileTemplatesResult = Result<
+ const client_library::ListProfileTemplatesForm*,
+ client_library::ListProfileTemplatesFormResponse*>;
+
+ std::future<ListProfileTemplatesResult> ListProfileTemplates(
+ const client_library::ListProfileTemplatesForm* req,
+ client_library::ListProfileTemplatesFormResponse* resp
+ );
+
+ using ListSharedIdentitiesResult = Result<
+ const client_library::ListSharedIdentitiesForm*,
+ client_library::ListSharedIdentitiesFormResponse*>;
+
+ std::future<ListSharedIdentitiesResult> ListSharedIdentities(
+ const client_library::ListSharedIdentitiesForm* req,
+ client_library::ListSharedIdentitiesFormResponse* resp
+ );
+
+ using ListSharedIdentitiesForEmployeeResult = Result<
+ const client_library::ListSharedIdentitiesForEmployeeForm*,
+ client_library::ListSharedIdentitiesForEmployeeFormResponse*>;
+
+ std::future<ListSharedIdentitiesForEmployeeResult> ListSharedIdentitiesForEmployee(
+ const client_library::ListSharedIdentitiesForEmployeeForm* req,
+ client_library::ListSharedIdentitiesForEmployeeFormResponse* resp
+ );
+
+ using ListSubscribedTemplatesToRoleResult = Result<
+ const client_library::ListSubscribedTemplatesToRoleForm*,
+ client_library::ListSubscribedTemplatesToRoleFormResponse*>;
+
+ std::future<ListSubscribedTemplatesToRoleResult> ListSubscribedTemplatesToRole(
+ const client_library::ListSubscribedTemplatesToRoleForm* req,
+ client_library::ListSubscribedTemplatesToRoleFormResponse* resp
+ );
+
+ using PutCompanyLogoResult = Result<
+ const client_library::PutCompanyLogoForm*,
+ client_library::PutCompanyLogoFormResponse*>;
+
+ std::future<PutCompanyLogoResult> PutCompanyLogo(
+ const client_library::PutCompanyLogoForm* req,
+ client_library::PutCompanyLogoFormResponse* resp
+ );
+
+ using RemoveClaimFromProfileTemplateResult = Result<
+ const client_library::RemoveClaimFromProfileTemplateForm*,
+ client_library::RemoveClaimFromProfileTemplateFormResponse*>;
+
+ std::future<RemoveClaimFromProfileTemplateResult> RemoveClaimFromProfileTemplate(
+ const client_library::RemoveClaimFromProfileTemplateForm* req,
+ client_library::RemoveClaimFromProfileTemplateFormResponse* resp
+ );
+
+ using UpdateEmployeeStatusResult = Result<
+ const client_library::UpdateEmployeeStatusForm*,
+ client_library::UpdateEmployeeStatusFormResponse*>;
+
+ std::future<UpdateEmployeeStatusResult> UpdateEmployeeStatus(
+ const client_library::UpdateEmployeeStatusForm* req,
+ client_library::UpdateEmployeeStatusFormResponse* resp
+ );
+
+private:
+ restapi::ClientSession& client_session_;
+};
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
+
+#endif // __VEREIGN_SERVICE_GEN_COMPANY_SERVICE_HH
diff --git a/cpp/src/vereign/service/gen/contacts_service.cc b/cpp/src/vereign/service/gen/contacts_service.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e23a6623b958d6ba28f47cee706ba1595d910726
--- /dev/null
+++ b/cpp/src/vereign/service/gen/contacts_service.cc
@@ -0,0 +1,71 @@
+#include <vereign/service/gen/contacts_service.hh>
+#include <vereign/restapi/client_session.hh>
+
+namespace {
+ const std::string changeStatusPath = "changeStatus";
+ const std::string getUserContactsPath = "getUserContacts";
+ const std::string listContactsPath = "listContacts";
+ const std::string searchContactsPath = "searchContacts";
+}
+
+namespace vereign {
+namespace service {
+namespace gen {
+
+const std::string ContactsService::ServicePath = "/contacts/";
+
+ContactsService::ContactsService(restapi::ClientSession& client_session)
+ : client_session_{client_session}
+{}
+
+std::future<ContactsService::ChangeStatusResult>
+ContactsService::ChangeStatus(
+ const client_library::ChangeStatusForm* req,
+ client_library::ChangeStatusFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + changeStatusPath,
+ req,
+ resp
+ );
+}
+
+std::future<ContactsService::GetUserContactsResult>
+ContactsService::GetUserContacts(
+ const client_library::GetUserContactsForm* req,
+ client_library::GetUserContactsFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getUserContactsPath,
+ req,
+ resp
+ );
+}
+
+std::future<ContactsService::ListContactsResult>
+ContactsService::ListContacts(
+ const client_library::ListContactsForm* req,
+ client_library::ListContactsFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + listContactsPath,
+ req,
+ resp
+ );
+}
+
+std::future<ContactsService::SearchContactsResult>
+ContactsService::SearchContacts(
+ const client_library::SearchContactsForm* req,
+ client_library::SearchContactsFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + searchContactsPath,
+ req,
+ resp
+ );
+}
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
diff --git a/cpp/src/vereign/service/gen/contacts_service.hh b/cpp/src/vereign/service/gen/contacts_service.hh
new file mode 100644
index 0000000000000000000000000000000000000000..3b11f3b5e859fd82af6d220d2d1a30018c54bec0
--- /dev/null
+++ b/cpp/src/vereign/service/gen/contacts_service.hh
@@ -0,0 +1,75 @@
+#ifndef __VEREIGN_SERVICE_GEN_CONTACTS_SERVICE_HH
+#define __VEREIGN_SERVICE_GEN_CONTACTS_SERVICE_HH
+
+#include <vereign/restapi/client_session.hh>
+#include <vereign/restapi/post_result.hh>
+#include <vereign/client_library/types.gen.pb.h>
+
+#include <future>
+
+namespace vereign {
+
+namespace restapi {
+ class ClientSession;
+}
+
+namespace service {
+namespace gen {
+
+template <class Request, class Response>
+using Result = restapi::PostResult<Request, Response>;
+
+class ContactsService {
+public:
+ static const std::string ServicePath;
+
+ explicit ContactsService(restapi::ClientSession& client_session);
+
+ ContactsService(const ContactsService&) = delete;
+ ContactsService& operator=(const ContactsService&) = delete;
+
+ using ChangeStatusResult = Result<
+ const client_library::ChangeStatusForm*,
+ client_library::ChangeStatusFormResponse*>;
+
+ std::future<ChangeStatusResult> ChangeStatus(
+ const client_library::ChangeStatusForm* req,
+ client_library::ChangeStatusFormResponse* resp
+ );
+
+ using GetUserContactsResult = Result<
+ const client_library::GetUserContactsForm*,
+ client_library::GetUserContactsFormResponse*>;
+
+ std::future<GetUserContactsResult> GetUserContacts(
+ const client_library::GetUserContactsForm* req,
+ client_library::GetUserContactsFormResponse* resp
+ );
+
+ using ListContactsResult = Result<
+ const client_library::ListContactsForm*,
+ client_library::ListContactsFormResponse*>;
+
+ std::future<ListContactsResult> ListContacts(
+ const client_library::ListContactsForm* req,
+ client_library::ListContactsFormResponse* resp
+ );
+
+ using SearchContactsResult = Result<
+ const client_library::SearchContactsForm*,
+ client_library::SearchContactsFormResponse*>;
+
+ std::future<SearchContactsResult> SearchContacts(
+ const client_library::SearchContactsForm* req,
+ client_library::SearchContactsFormResponse* resp
+ );
+
+private:
+ restapi::ClientSession& client_session_;
+};
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
+
+#endif // __VEREIGN_SERVICE_GEN_CONTACTS_SERVICE_HH
diff --git a/cpp/src/vereign/service/gen/conversation_service.cc b/cpp/src/vereign/service/gen/conversation_service.cc
new file mode 100644
index 0000000000000000000000000000000000000000..1074092a371a4f8c5a3bb3626e5a3a52b98f6ebc
--- /dev/null
+++ b/cpp/src/vereign/service/gen/conversation_service.cc
@@ -0,0 +1,71 @@
+#include <vereign/service/gen/conversation_service.hh>
+#include <vereign/restapi/client_session.hh>
+
+namespace {
+ const std::string addEmailPath = "addEmail";
+ const std::string getConversationsPath = "getConversations";
+ const std::string getConversationsAndMessageIDByMessageUUIDPath = "getConversationsAndMessageIDByMessageUUID";
+ const std::string getEmailsPath = "getEmails";
+}
+
+namespace vereign {
+namespace service {
+namespace gen {
+
+const std::string ConversationService::ServicePath = "/conversation/";
+
+ConversationService::ConversationService(restapi::ClientSession& client_session)
+ : client_session_{client_session}
+{}
+
+std::future<ConversationService::AddEmailResult>
+ConversationService::AddEmail(
+ const client_library::AddEmailForm* req,
+ client_library::AddEmailFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + addEmailPath,
+ req,
+ resp
+ );
+}
+
+std::future<ConversationService::GetConversationsResult>
+ConversationService::GetConversations(
+ const client_library::GetConversationsForm* req,
+ client_library::GetConversationsFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getConversationsPath,
+ req,
+ resp
+ );
+}
+
+std::future<ConversationService::GetConversationsAndMessageIDByMessageUUIDResult>
+ConversationService::GetConversationsAndMessageIDByMessageUUID(
+ const client_library::GetConversationsAndMessageIDByMessageUUIDForm* req,
+ client_library::GetConversationsAndMessageIDByMessageUUIDResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getConversationsAndMessageIDByMessageUUIDPath,
+ req,
+ resp
+ );
+}
+
+std::future<ConversationService::GetEmailsResult>
+ConversationService::GetEmails(
+ const client_library::GetEmailsForm* req,
+ client_library::GetEmailsFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getEmailsPath,
+ req,
+ resp
+ );
+}
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
diff --git a/cpp/src/vereign/service/gen/conversation_service.hh b/cpp/src/vereign/service/gen/conversation_service.hh
new file mode 100644
index 0000000000000000000000000000000000000000..01031de41cbc7cff453b3883bed71d6bc5b6c4e5
--- /dev/null
+++ b/cpp/src/vereign/service/gen/conversation_service.hh
@@ -0,0 +1,75 @@
+#ifndef __VEREIGN_SERVICE_GEN_CONVERSATION_SERVICE_HH
+#define __VEREIGN_SERVICE_GEN_CONVERSATION_SERVICE_HH
+
+#include <vereign/restapi/client_session.hh>
+#include <vereign/restapi/post_result.hh>
+#include <vereign/client_library/types.gen.pb.h>
+
+#include <future>
+
+namespace vereign {
+
+namespace restapi {
+ class ClientSession;
+}
+
+namespace service {
+namespace gen {
+
+template <class Request, class Response>
+using Result = restapi::PostResult<Request, Response>;
+
+class ConversationService {
+public:
+ static const std::string ServicePath;
+
+ explicit ConversationService(restapi::ClientSession& client_session);
+
+ ConversationService(const ConversationService&) = delete;
+ ConversationService& operator=(const ConversationService&) = delete;
+
+ using AddEmailResult = Result<
+ const client_library::AddEmailForm*,
+ client_library::AddEmailFormResponse*>;
+
+ std::future<AddEmailResult> AddEmail(
+ const client_library::AddEmailForm* req,
+ client_library::AddEmailFormResponse* resp
+ );
+
+ using GetConversationsResult = Result<
+ const client_library::GetConversationsForm*,
+ client_library::GetConversationsFormResponse*>;
+
+ std::future<GetConversationsResult> GetConversations(
+ const client_library::GetConversationsForm* req,
+ client_library::GetConversationsFormResponse* resp
+ );
+
+ using GetConversationsAndMessageIDByMessageUUIDResult = Result<
+ const client_library::GetConversationsAndMessageIDByMessageUUIDForm*,
+ client_library::GetConversationsAndMessageIDByMessageUUIDResponse*>;
+
+ std::future<GetConversationsAndMessageIDByMessageUUIDResult> GetConversationsAndMessageIDByMessageUUID(
+ const client_library::GetConversationsAndMessageIDByMessageUUIDForm* req,
+ client_library::GetConversationsAndMessageIDByMessageUUIDResponse* resp
+ );
+
+ using GetEmailsResult = Result<
+ const client_library::GetEmailsForm*,
+ client_library::GetEmailsFormResponse*>;
+
+ std::future<GetEmailsResult> GetEmails(
+ const client_library::GetEmailsForm* req,
+ client_library::GetEmailsFormResponse* resp
+ );
+
+private:
+ restapi::ClientSession& client_session_;
+};
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
+
+#endif // __VEREIGN_SERVICE_GEN_CONVERSATION_SERVICE_HH
diff --git a/cpp/src/vereign/service/gen/delete_service.cc b/cpp/src/vereign/service/gen/delete_service.cc
new file mode 100644
index 0000000000000000000000000000000000000000..11da596808a5f1093a1f16d880d15e35263c9648
--- /dev/null
+++ b/cpp/src/vereign/service/gen/delete_service.cc
@@ -0,0 +1,45 @@
+#include <vereign/service/gen/delete_service.hh>
+#include <vereign/restapi/client_session.hh>
+
+namespace {
+ const std::string deleteInteractionPath = "deleteInteraction";
+ const std::string deletePassportPath = "deletePassport";
+}
+
+namespace vereign {
+namespace service {
+namespace gen {
+
+const std::string DeleteService::ServicePath = "/delete/";
+
+DeleteService::DeleteService(restapi::ClientSession& client_session)
+ : client_session_{client_session}
+{}
+
+std::future<DeleteService::DeleteInteractionResult>
+DeleteService::DeleteInteraction(
+ const client_library::DeleteInteractionForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + deleteInteractionPath,
+ req,
+ resp
+ );
+}
+
+std::future<DeleteService::DeletePassportResult>
+DeleteService::DeletePassport(
+ const client_library::DeletePassportForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + deletePassportPath,
+ req,
+ resp
+ );
+}
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
diff --git a/cpp/src/vereign/service/gen/delete_service.hh b/cpp/src/vereign/service/gen/delete_service.hh
new file mode 100644
index 0000000000000000000000000000000000000000..7e5ddfd5eb7f9b7950d1a569ff1668ad8ef4c274
--- /dev/null
+++ b/cpp/src/vereign/service/gen/delete_service.hh
@@ -0,0 +1,57 @@
+#ifndef __VEREIGN_SERVICE_GEN_DELETE_SERVICE_HH
+#define __VEREIGN_SERVICE_GEN_DELETE_SERVICE_HH
+
+#include <vereign/restapi/client_session.hh>
+#include <vereign/restapi/post_result.hh>
+#include <vereign/client_library/types.gen.pb.h>
+
+#include <future>
+
+namespace vereign {
+
+namespace restapi {
+ class ClientSession;
+}
+
+namespace service {
+namespace gen {
+
+template <class Request, class Response>
+using Result = restapi::PostResult<Request, Response>;
+
+class DeleteService {
+public:
+ static const std::string ServicePath;
+
+ explicit DeleteService(restapi::ClientSession& client_session);
+
+ DeleteService(const DeleteService&) = delete;
+ DeleteService& operator=(const DeleteService&) = delete;
+
+ using DeleteInteractionResult = Result<
+ const client_library::DeleteInteractionForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<DeleteInteractionResult> DeleteInteraction(
+ const client_library::DeleteInteractionForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using DeletePassportResult = Result<
+ const client_library::DeletePassportForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<DeletePassportResult> DeletePassport(
+ const client_library::DeletePassportForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+private:
+ restapi::ClientSession& client_session_;
+};
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
+
+#endif // __VEREIGN_SERVICE_GEN_DELETE_SERVICE_HH
diff --git a/cpp/src/vereign/service/gen/document_service.cc b/cpp/src/vereign/service/gen/document_service.cc
new file mode 100644
index 0000000000000000000000000000000000000000..68d18f8ea5e626d7002cde492c8d35a665d1d156
--- /dev/null
+++ b/cpp/src/vereign/service/gen/document_service.cc
@@ -0,0 +1,162 @@
+#include <vereign/service/gen/document_service.hh>
+#include <vereign/restapi/client_session.hh>
+
+namespace {
+ const std::string convertDocumentByUUIDPath = "convertDocumentByUUID";
+ const std::string deleteIdentityImagePath = "deleteIdentityImage";
+ const std::string getDocumentPath = "getDocument";
+ const std::string getDocumentByResourceIDPath = "getDocumentByResourceID";
+ const std::string getDocumentByUUIDPath = "getDocumentByUUID";
+ const std::string getFileInfoPath = "getFileInfo";
+ const std::string getIdentityImagePath = "getIdentityImage";
+ const std::string listDocumentsPath = "listDocuments";
+ const std::string putDocumentByUUIDPath = "putDocumentByUUID";
+ const std::string putIdentityImagePath = "putIdentityImage";
+ const std::string signDocumentByUUIDPath = "signDocumentByUUID";
+}
+
+namespace vereign {
+namespace service {
+namespace gen {
+
+const std::string DocumentService::ServicePath = "/document/";
+
+DocumentService::DocumentService(restapi::ClientSession& client_session)
+ : client_session_{client_session}
+{}
+
+std::future<DocumentService::ConvertDocumentByUUIDResult>
+DocumentService::ConvertDocumentByUUID(
+ const client_library::ConvertDocumentByUUIDForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + convertDocumentByUUIDPath,
+ req,
+ resp
+ );
+}
+
+std::future<DocumentService::DeleteIdentityImageResult>
+DocumentService::DeleteIdentityImage(
+ const client_library::DeleteIdentityImageForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + deleteIdentityImagePath,
+ req,
+ resp
+ );
+}
+
+std::future<DocumentService::GetDocumentResult>
+DocumentService::GetDocument(
+ const client_library::EmptyRequest* req,
+ client_library::ListDocumentsResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getDocumentPath,
+ req,
+ resp
+ );
+}
+
+std::future<DocumentService::GetDocumentByResourceIDResult>
+DocumentService::GetDocumentByResourceID(
+ const client_library::GetDocumentByResourceIDForm* req,
+ client_library::GetDocumentByResourceIDFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getDocumentByResourceIDPath,
+ req,
+ resp
+ );
+}
+
+std::future<DocumentService::GetDocumentByUUIDResult>
+DocumentService::GetDocumentByUUID(
+ const client_library::GetDocumentByUUIDForm* req,
+ client_library::GetDocumentByUUIDFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getDocumentByUUIDPath,
+ req,
+ resp
+ );
+}
+
+std::future<DocumentService::GetFileInfoResult>
+DocumentService::GetFileInfo(
+ const client_library::EmptyRequest* req,
+ client_library::GetFileInfoResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getFileInfoPath,
+ req,
+ resp
+ );
+}
+
+std::future<DocumentService::GetIdentityImageResult>
+DocumentService::GetIdentityImage(
+ const client_library::GetIdentityImageForm* req,
+ client_library::GetIdentityImageFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getIdentityImagePath,
+ req,
+ resp
+ );
+}
+
+std::future<DocumentService::ListDocumentsResult>
+DocumentService::ListDocuments(
+ const client_library::EmptyRequest* req,
+ client_library::ListDocumentsResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + listDocumentsPath,
+ req,
+ resp
+ );
+}
+
+std::future<DocumentService::PutDocumentByUUIDResult>
+DocumentService::PutDocumentByUUID(
+ const client_library::PutDocumentByUUIDForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + putDocumentByUUIDPath,
+ req,
+ resp
+ );
+}
+
+std::future<DocumentService::PutIdentityImageResult>
+DocumentService::PutIdentityImage(
+ const client_library::PutIdentityImageForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + putIdentityImagePath,
+ req,
+ resp
+ );
+}
+
+std::future<DocumentService::SignDocumentByUUIDResult>
+DocumentService::SignDocumentByUUID(
+ const client_library::SignDocumentByUUIDForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + signDocumentByUUIDPath,
+ req,
+ resp
+ );
+}
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
diff --git a/cpp/src/vereign/service/gen/document_service.hh b/cpp/src/vereign/service/gen/document_service.hh
new file mode 100644
index 0000000000000000000000000000000000000000..8d78e7d890268f8af45e988612284d4c370149c8
--- /dev/null
+++ b/cpp/src/vereign/service/gen/document_service.hh
@@ -0,0 +1,138 @@
+#ifndef __VEREIGN_SERVICE_GEN_DOCUMENT_SERVICE_HH
+#define __VEREIGN_SERVICE_GEN_DOCUMENT_SERVICE_HH
+
+#include <vereign/restapi/client_session.hh>
+#include <vereign/restapi/post_result.hh>
+#include <vereign/client_library/types.gen.pb.h>
+
+#include <future>
+
+namespace vereign {
+
+namespace restapi {
+ class ClientSession;
+}
+
+namespace service {
+namespace gen {
+
+template <class Request, class Response>
+using Result = restapi::PostResult<Request, Response>;
+
+class DocumentService {
+public:
+ static const std::string ServicePath;
+
+ explicit DocumentService(restapi::ClientSession& client_session);
+
+ DocumentService(const DocumentService&) = delete;
+ DocumentService& operator=(const DocumentService&) = delete;
+
+ using ConvertDocumentByUUIDResult = Result<
+ const client_library::ConvertDocumentByUUIDForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<ConvertDocumentByUUIDResult> ConvertDocumentByUUID(
+ const client_library::ConvertDocumentByUUIDForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using DeleteIdentityImageResult = Result<
+ const client_library::DeleteIdentityImageForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<DeleteIdentityImageResult> DeleteIdentityImage(
+ const client_library::DeleteIdentityImageForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using GetDocumentResult = Result<
+ const client_library::EmptyRequest*,
+ client_library::ListDocumentsResponse*>;
+
+ std::future<GetDocumentResult> GetDocument(
+ const client_library::EmptyRequest* req,
+ client_library::ListDocumentsResponse* resp
+ );
+
+ using GetDocumentByResourceIDResult = Result<
+ const client_library::GetDocumentByResourceIDForm*,
+ client_library::GetDocumentByResourceIDFormResponse*>;
+
+ std::future<GetDocumentByResourceIDResult> GetDocumentByResourceID(
+ const client_library::GetDocumentByResourceIDForm* req,
+ client_library::GetDocumentByResourceIDFormResponse* resp
+ );
+
+ using GetDocumentByUUIDResult = Result<
+ const client_library::GetDocumentByUUIDForm*,
+ client_library::GetDocumentByUUIDFormResponse*>;
+
+ std::future<GetDocumentByUUIDResult> GetDocumentByUUID(
+ const client_library::GetDocumentByUUIDForm* req,
+ client_library::GetDocumentByUUIDFormResponse* resp
+ );
+
+ using GetFileInfoResult = Result<
+ const client_library::EmptyRequest*,
+ client_library::GetFileInfoResponse*>;
+
+ std::future<GetFileInfoResult> GetFileInfo(
+ const client_library::EmptyRequest* req,
+ client_library::GetFileInfoResponse* resp
+ );
+
+ using GetIdentityImageResult = Result<
+ const client_library::GetIdentityImageForm*,
+ client_library::GetIdentityImageFormResponse*>;
+
+ std::future<GetIdentityImageResult> GetIdentityImage(
+ const client_library::GetIdentityImageForm* req,
+ client_library::GetIdentityImageFormResponse* resp
+ );
+
+ using ListDocumentsResult = Result<
+ const client_library::EmptyRequest*,
+ client_library::ListDocumentsResponse*>;
+
+ std::future<ListDocumentsResult> ListDocuments(
+ const client_library::EmptyRequest* req,
+ client_library::ListDocumentsResponse* resp
+ );
+
+ using PutDocumentByUUIDResult = Result<
+ const client_library::PutDocumentByUUIDForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<PutDocumentByUUIDResult> PutDocumentByUUID(
+ const client_library::PutDocumentByUUIDForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using PutIdentityImageResult = Result<
+ const client_library::PutIdentityImageForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<PutIdentityImageResult> PutIdentityImage(
+ const client_library::PutIdentityImageForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using SignDocumentByUUIDResult = Result<
+ const client_library::SignDocumentByUUIDForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<SignDocumentByUUIDResult> SignDocumentByUUID(
+ const client_library::SignDocumentByUUIDForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+private:
+ restapi::ClientSession& client_session_;
+};
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
+
+#endif // __VEREIGN_SERVICE_GEN_DOCUMENT_SERVICE_HH
diff --git a/cpp/src/vereign/service/gen/email_service.cc b/cpp/src/vereign/service/gen/email_service.cc
new file mode 100644
index 0000000000000000000000000000000000000000..bb3b681ae6080bdd682660f3ddfd667c5f96b74f
--- /dev/null
+++ b/cpp/src/vereign/service/gen/email_service.cc
@@ -0,0 +1,136 @@
+#include <vereign/service/gen/email_service.hh>
+#include <vereign/restapi/client_session.hh>
+
+namespace {
+ const std::string getEmailStatusAllPath = "getEmailStatusAll";
+ const std::string getEmailStatusListPath = "getEmailStatusList";
+ const std::string getGmailMessageIDsByGmailThreadIDPath = "getGmailMessageIDsByGmailThreadID";
+ const std::string getMessageIDsByGmailMessageIDsPath = "getMessageIDsByGmailMessageIDs";
+ const std::string initializeEmailStatusPath = "initializeEmailStatus";
+ const std::string sendEmailSmtpPath = "sendEmailSmtp";
+ const std::string sendFeedbackPath = "sendFeedback";
+ const std::string storeGmailMessageIdPath = "storeGmailMessageId";
+ const std::string updateRecipientEmailStatusPath = "updateRecipientEmailStatus";
+}
+
+namespace vereign {
+namespace service {
+namespace gen {
+
+const std::string EmailService::ServicePath = "/email/";
+
+EmailService::EmailService(restapi::ClientSession& client_session)
+ : client_session_{client_session}
+{}
+
+std::future<EmailService::GetEmailStatusAllResult>
+EmailService::GetEmailStatusAll(
+ const client_library::GetEmailStatusAllForm* req,
+ client_library::GetEmailStatusAllFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getEmailStatusAllPath,
+ req,
+ resp
+ );
+}
+
+std::future<EmailService::GetEmailStatusListResult>
+EmailService::GetEmailStatusList(
+ const client_library::GetEmailStatusListForm* req,
+ client_library::GetEmailStatusListFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getEmailStatusListPath,
+ req,
+ resp
+ );
+}
+
+std::future<EmailService::GetGmailMessageIDsByGmailThreadIDResult>
+EmailService::GetGmailMessageIDsByGmailThreadID(
+ const client_library::GetGmailMessageIDsByGmailThreadIDForm* req,
+ client_library::GetGmailMessageIDsByGmailThreadIDFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getGmailMessageIDsByGmailThreadIDPath,
+ req,
+ resp
+ );
+}
+
+std::future<EmailService::GetMessageIDsByGmailMessageIDsResult>
+EmailService::GetMessageIDsByGmailMessageIDs(
+ const client_library::GetMessageIDsByGmailMessageIDsForm* req,
+ client_library::GetMessageIDsByGmailMessageIDsFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getMessageIDsByGmailMessageIDsPath,
+ req,
+ resp
+ );
+}
+
+std::future<EmailService::InitializeEmailStatusResult>
+EmailService::InitializeEmailStatus(
+ const client_library::InitializeEmailStatusForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + initializeEmailStatusPath,
+ req,
+ resp
+ );
+}
+
+std::future<EmailService::SendEmailSmtpResult>
+EmailService::SendEmailSmtp(
+ const client_library::SendEmailSmtpForm* req,
+ client_library::SendEmailSmtpFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + sendEmailSmtpPath,
+ req,
+ resp
+ );
+}
+
+std::future<EmailService::SendFeedbackResult>
+EmailService::SendFeedback(
+ const client_library::SendFeedbackForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + sendFeedbackPath,
+ req,
+ resp
+ );
+}
+
+std::future<EmailService::StoreGmailMessageIdResult>
+EmailService::StoreGmailMessageId(
+ const client_library::StoreGmailMessageIdForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + storeGmailMessageIdPath,
+ req,
+ resp
+ );
+}
+
+std::future<EmailService::UpdateRecipientEmailStatusResult>
+EmailService::UpdateRecipientEmailStatus(
+ const client_library::UpdateRecipientEmailStatusForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + updateRecipientEmailStatusPath,
+ req,
+ resp
+ );
+}
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
diff --git a/cpp/src/vereign/service/gen/email_service.hh b/cpp/src/vereign/service/gen/email_service.hh
new file mode 100644
index 0000000000000000000000000000000000000000..9f25846caac1ead3416b9e4a014b931476d62d3c
--- /dev/null
+++ b/cpp/src/vereign/service/gen/email_service.hh
@@ -0,0 +1,120 @@
+#ifndef __VEREIGN_SERVICE_GEN_EMAIL_SERVICE_HH
+#define __VEREIGN_SERVICE_GEN_EMAIL_SERVICE_HH
+
+#include <vereign/restapi/client_session.hh>
+#include <vereign/restapi/post_result.hh>
+#include <vereign/client_library/types.gen.pb.h>
+
+#include <future>
+
+namespace vereign {
+
+namespace restapi {
+ class ClientSession;
+}
+
+namespace service {
+namespace gen {
+
+template <class Request, class Response>
+using Result = restapi::PostResult<Request, Response>;
+
+class EmailService {
+public:
+ static const std::string ServicePath;
+
+ explicit EmailService(restapi::ClientSession& client_session);
+
+ EmailService(const EmailService&) = delete;
+ EmailService& operator=(const EmailService&) = delete;
+
+ using GetEmailStatusAllResult = Result<
+ const client_library::GetEmailStatusAllForm*,
+ client_library::GetEmailStatusAllFormResponse*>;
+
+ std::future<GetEmailStatusAllResult> GetEmailStatusAll(
+ const client_library::GetEmailStatusAllForm* req,
+ client_library::GetEmailStatusAllFormResponse* resp
+ );
+
+ using GetEmailStatusListResult = Result<
+ const client_library::GetEmailStatusListForm*,
+ client_library::GetEmailStatusListFormResponse*>;
+
+ std::future<GetEmailStatusListResult> GetEmailStatusList(
+ const client_library::GetEmailStatusListForm* req,
+ client_library::GetEmailStatusListFormResponse* resp
+ );
+
+ using GetGmailMessageIDsByGmailThreadIDResult = Result<
+ const client_library::GetGmailMessageIDsByGmailThreadIDForm*,
+ client_library::GetGmailMessageIDsByGmailThreadIDFormResponse*>;
+
+ std::future<GetGmailMessageIDsByGmailThreadIDResult> GetGmailMessageIDsByGmailThreadID(
+ const client_library::GetGmailMessageIDsByGmailThreadIDForm* req,
+ client_library::GetGmailMessageIDsByGmailThreadIDFormResponse* resp
+ );
+
+ using GetMessageIDsByGmailMessageIDsResult = Result<
+ const client_library::GetMessageIDsByGmailMessageIDsForm*,
+ client_library::GetMessageIDsByGmailMessageIDsFormResponse*>;
+
+ std::future<GetMessageIDsByGmailMessageIDsResult> GetMessageIDsByGmailMessageIDs(
+ const client_library::GetMessageIDsByGmailMessageIDsForm* req,
+ client_library::GetMessageIDsByGmailMessageIDsFormResponse* resp
+ );
+
+ using InitializeEmailStatusResult = Result<
+ const client_library::InitializeEmailStatusForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<InitializeEmailStatusResult> InitializeEmailStatus(
+ const client_library::InitializeEmailStatusForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using SendEmailSmtpResult = Result<
+ const client_library::SendEmailSmtpForm*,
+ client_library::SendEmailSmtpFormResponse*>;
+
+ std::future<SendEmailSmtpResult> SendEmailSmtp(
+ const client_library::SendEmailSmtpForm* req,
+ client_library::SendEmailSmtpFormResponse* resp
+ );
+
+ using SendFeedbackResult = Result<
+ const client_library::SendFeedbackForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<SendFeedbackResult> SendFeedback(
+ const client_library::SendFeedbackForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using StoreGmailMessageIdResult = Result<
+ const client_library::StoreGmailMessageIdForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<StoreGmailMessageIdResult> StoreGmailMessageId(
+ const client_library::StoreGmailMessageIdForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using UpdateRecipientEmailStatusResult = Result<
+ const client_library::UpdateRecipientEmailStatusForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<UpdateRecipientEmailStatusResult> UpdateRecipientEmailStatus(
+ const client_library::UpdateRecipientEmailStatusForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+private:
+ restapi::ClientSession& client_session_;
+};
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
+
+#endif // __VEREIGN_SERVICE_GEN_EMAIL_SERVICE_HH
diff --git a/cpp/src/vereign/service/gen/entity_service.cc b/cpp/src/vereign/service/gen/entity_service.cc
new file mode 100644
index 0000000000000000000000000000000000000000..b5294a6bf8481b8ee809940602db2eecb1e2b886
--- /dev/null
+++ b/cpp/src/vereign/service/gen/entity_service.cc
@@ -0,0 +1,305 @@
+#include <vereign/service/gen/entity_service.hh>
+#include <vereign/restapi/client_session.hh>
+
+namespace {
+ const std::string addChildPath = "addChild";
+ const std::string addClaimPath = "addClaim";
+ const std::string addGuardedPath = "addGuarded";
+ const std::string addGuardianPath = "addGuardian";
+ const std::string addMemberPath = "addMember";
+ const std::string addMemberOfPath = "addMemberOf";
+ const std::string addParentPath = "addParent";
+ const std::string addViewerPath = "addViewer";
+ const std::string createEntityPath = "createEntity";
+ const std::string deleteClaimPath = "deleteClaim";
+ const std::string getClaimPath = "getClaim";
+ const std::string getEntityPath = "getEntity";
+ const std::string removeChildPath = "removeChild";
+ const std::string removeGuardedPath = "removeGuarded";
+ const std::string removeGuardianPath = "removeGuardian";
+ const std::string removeMemberPath = "removeMember";
+ const std::string removeMemberOfPath = "removeMemberOf";
+ const std::string removeParentPath = "removeParent";
+ const std::string removeViewerPath = "removeViewer";
+ const std::string sendClaimCodePath = "sendClaimCode";
+ const std::string updateClaimPath = "updateClaim";
+ const std::string verifyClaimCodePath = "verifyClaimCode";
+}
+
+namespace vereign {
+namespace service {
+namespace gen {
+
+const std::string EntityService::ServicePath = "/entity/";
+
+EntityService::EntityService(restapi::ClientSession& client_session)
+ : client_session_{client_session}
+{}
+
+std::future<EntityService::AddChildResult>
+EntityService::AddChild(
+ const client_library::AddChildForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + addChildPath,
+ req,
+ resp
+ );
+}
+
+std::future<EntityService::AddClaimResult>
+EntityService::AddClaim(
+ const client_library::AddClaimForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + addClaimPath,
+ req,
+ resp
+ );
+}
+
+std::future<EntityService::AddGuardedResult>
+EntityService::AddGuarded(
+ const client_library::AddGuardedForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + addGuardedPath,
+ req,
+ resp
+ );
+}
+
+std::future<EntityService::AddGuardianResult>
+EntityService::AddGuardian(
+ const client_library::AddGuardianForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + addGuardianPath,
+ req,
+ resp
+ );
+}
+
+std::future<EntityService::AddMemberResult>
+EntityService::AddMember(
+ const client_library::AddMemberForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + addMemberPath,
+ req,
+ resp
+ );
+}
+
+std::future<EntityService::AddMemberOfResult>
+EntityService::AddMemberOf(
+ const client_library::AddMemberOfForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + addMemberOfPath,
+ req,
+ resp
+ );
+}
+
+std::future<EntityService::AddParentResult>
+EntityService::AddParent(
+ const client_library::AddParentForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + addParentPath,
+ req,
+ resp
+ );
+}
+
+std::future<EntityService::AddViewerResult>
+EntityService::AddViewer(
+ const client_library::AddViewerForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + addViewerPath,
+ req,
+ resp
+ );
+}
+
+std::future<EntityService::CreateEntityResult>
+EntityService::CreateEntity(
+ const client_library::CreateEntityForm* req,
+ client_library::CreateEntityFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + createEntityPath,
+ req,
+ resp
+ );
+}
+
+std::future<EntityService::DeleteClaimResult>
+EntityService::DeleteClaim(
+ const client_library::DeleteClaimForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + deleteClaimPath,
+ req,
+ resp
+ );
+}
+
+std::future<EntityService::GetClaimResult>
+EntityService::GetClaim(
+ const client_library::GetClaimForm* req,
+ client_library::GetClaimFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getClaimPath,
+ req,
+ resp
+ );
+}
+
+std::future<EntityService::GetEntityResult>
+EntityService::GetEntity(
+ const client_library::GetEntityForm* req,
+ client_library::GetEntityFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getEntityPath,
+ req,
+ resp
+ );
+}
+
+std::future<EntityService::RemoveChildResult>
+EntityService::RemoveChild(
+ const client_library::RemoveChildForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + removeChildPath,
+ req,
+ resp
+ );
+}
+
+std::future<EntityService::RemoveGuardedResult>
+EntityService::RemoveGuarded(
+ const client_library::RemoveGuardedForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + removeGuardedPath,
+ req,
+ resp
+ );
+}
+
+std::future<EntityService::RemoveGuardianResult>
+EntityService::RemoveGuardian(
+ const client_library::RemoveGuardianForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + removeGuardianPath,
+ req,
+ resp
+ );
+}
+
+std::future<EntityService::RemoveMemberResult>
+EntityService::RemoveMember(
+ const client_library::RemoveMemberForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + removeMemberPath,
+ req,
+ resp
+ );
+}
+
+std::future<EntityService::RemoveMemberOfResult>
+EntityService::RemoveMemberOf(
+ const client_library::RemoveMemberOfForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + removeMemberOfPath,
+ req,
+ resp
+ );
+}
+
+std::future<EntityService::RemoveParentResult>
+EntityService::RemoveParent(
+ const client_library::RemoveParentForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + removeParentPath,
+ req,
+ resp
+ );
+}
+
+std::future<EntityService::RemoveViewerResult>
+EntityService::RemoveViewer(
+ const client_library::RemoveViewerForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + removeViewerPath,
+ req,
+ resp
+ );
+}
+
+std::future<EntityService::SendClaimCodeResult>
+EntityService::SendClaimCode(
+ const client_library::ClaimSendCodeForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + sendClaimCodePath,
+ req,
+ resp
+ );
+}
+
+std::future<EntityService::UpdateClaimResult>
+EntityService::UpdateClaim(
+ const client_library::AddClaimForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + updateClaimPath,
+ req,
+ resp
+ );
+}
+
+std::future<EntityService::VerifyClaimCodeResult>
+EntityService::VerifyClaimCode(
+ const client_library::ClaimVerifyCodeForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + verifyClaimCodePath,
+ req,
+ resp
+ );
+}
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
diff --git a/cpp/src/vereign/service/gen/entity_service.hh b/cpp/src/vereign/service/gen/entity_service.hh
new file mode 100644
index 0000000000000000000000000000000000000000..322ae79c62c9a2a14a01326cf919b3cebb8b9a21
--- /dev/null
+++ b/cpp/src/vereign/service/gen/entity_service.hh
@@ -0,0 +1,237 @@
+#ifndef __VEREIGN_SERVICE_GEN_ENTITY_SERVICE_HH
+#define __VEREIGN_SERVICE_GEN_ENTITY_SERVICE_HH
+
+#include <vereign/restapi/client_session.hh>
+#include <vereign/restapi/post_result.hh>
+#include <vereign/client_library/types.gen.pb.h>
+
+#include <future>
+
+namespace vereign {
+
+namespace restapi {
+ class ClientSession;
+}
+
+namespace service {
+namespace gen {
+
+template <class Request, class Response>
+using Result = restapi::PostResult<Request, Response>;
+
+class EntityService {
+public:
+ static const std::string ServicePath;
+
+ explicit EntityService(restapi::ClientSession& client_session);
+
+ EntityService(const EntityService&) = delete;
+ EntityService& operator=(const EntityService&) = delete;
+
+ using AddChildResult = Result<
+ const client_library::AddChildForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<AddChildResult> AddChild(
+ const client_library::AddChildForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using AddClaimResult = Result<
+ const client_library::AddClaimForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<AddClaimResult> AddClaim(
+ const client_library::AddClaimForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using AddGuardedResult = Result<
+ const client_library::AddGuardedForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<AddGuardedResult> AddGuarded(
+ const client_library::AddGuardedForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using AddGuardianResult = Result<
+ const client_library::AddGuardianForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<AddGuardianResult> AddGuardian(
+ const client_library::AddGuardianForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using AddMemberResult = Result<
+ const client_library::AddMemberForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<AddMemberResult> AddMember(
+ const client_library::AddMemberForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using AddMemberOfResult = Result<
+ const client_library::AddMemberOfForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<AddMemberOfResult> AddMemberOf(
+ const client_library::AddMemberOfForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using AddParentResult = Result<
+ const client_library::AddParentForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<AddParentResult> AddParent(
+ const client_library::AddParentForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using AddViewerResult = Result<
+ const client_library::AddViewerForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<AddViewerResult> AddViewer(
+ const client_library::AddViewerForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using CreateEntityResult = Result<
+ const client_library::CreateEntityForm*,
+ client_library::CreateEntityFormResponse*>;
+
+ std::future<CreateEntityResult> CreateEntity(
+ const client_library::CreateEntityForm* req,
+ client_library::CreateEntityFormResponse* resp
+ );
+
+ using DeleteClaimResult = Result<
+ const client_library::DeleteClaimForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<DeleteClaimResult> DeleteClaim(
+ const client_library::DeleteClaimForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using GetClaimResult = Result<
+ const client_library::GetClaimForm*,
+ client_library::GetClaimFormResponse*>;
+
+ std::future<GetClaimResult> GetClaim(
+ const client_library::GetClaimForm* req,
+ client_library::GetClaimFormResponse* resp
+ );
+
+ using GetEntityResult = Result<
+ const client_library::GetEntityForm*,
+ client_library::GetEntityFormResponse*>;
+
+ std::future<GetEntityResult> GetEntity(
+ const client_library::GetEntityForm* req,
+ client_library::GetEntityFormResponse* resp
+ );
+
+ using RemoveChildResult = Result<
+ const client_library::RemoveChildForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<RemoveChildResult> RemoveChild(
+ const client_library::RemoveChildForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using RemoveGuardedResult = Result<
+ const client_library::RemoveGuardedForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<RemoveGuardedResult> RemoveGuarded(
+ const client_library::RemoveGuardedForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using RemoveGuardianResult = Result<
+ const client_library::RemoveGuardianForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<RemoveGuardianResult> RemoveGuardian(
+ const client_library::RemoveGuardianForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using RemoveMemberResult = Result<
+ const client_library::RemoveMemberForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<RemoveMemberResult> RemoveMember(
+ const client_library::RemoveMemberForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using RemoveMemberOfResult = Result<
+ const client_library::RemoveMemberOfForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<RemoveMemberOfResult> RemoveMemberOf(
+ const client_library::RemoveMemberOfForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using RemoveParentResult = Result<
+ const client_library::RemoveParentForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<RemoveParentResult> RemoveParent(
+ const client_library::RemoveParentForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using RemoveViewerResult = Result<
+ const client_library::RemoveViewerForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<RemoveViewerResult> RemoveViewer(
+ const client_library::RemoveViewerForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using SendClaimCodeResult = Result<
+ const client_library::ClaimSendCodeForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<SendClaimCodeResult> SendClaimCode(
+ const client_library::ClaimSendCodeForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using UpdateClaimResult = Result<
+ const client_library::AddClaimForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<UpdateClaimResult> UpdateClaim(
+ const client_library::AddClaimForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using VerifyClaimCodeResult = Result<
+ const client_library::ClaimVerifyCodeForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<VerifyClaimCodeResult> VerifyClaimCode(
+ const client_library::ClaimVerifyCodeForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+private:
+ restapi::ClientSession& client_session_;
+};
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
+
+#endif // __VEREIGN_SERVICE_GEN_ENTITY_SERVICE_HH
diff --git a/cpp/src/vereign/service/gen/event_service.cc b/cpp/src/vereign/service/gen/event_service.cc
new file mode 100644
index 0000000000000000000000000000000000000000..3a253c2b36da0651eb5ba04f33fa4506fc24ef08
--- /dev/null
+++ b/cpp/src/vereign/service/gen/event_service.cc
@@ -0,0 +1,32 @@
+#include <vereign/service/gen/event_service.hh>
+#include <vereign/restapi/client_session.hh>
+
+namespace {
+ const std::string getEventsPath = "getEvents";
+}
+
+namespace vereign {
+namespace service {
+namespace gen {
+
+const std::string EventService::ServicePath = "/event/";
+
+EventService::EventService(restapi::ClientSession& client_session)
+ : client_session_{client_session}
+{}
+
+std::future<EventService::GetEventsResult>
+EventService::GetEvents(
+ const client_library::GetEventsForm* req,
+ client_library::GetEventsFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getEventsPath,
+ req,
+ resp
+ );
+}
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
diff --git a/cpp/src/vereign/service/gen/event_service.hh b/cpp/src/vereign/service/gen/event_service.hh
new file mode 100644
index 0000000000000000000000000000000000000000..4537c43fa58fcc6f7835b2ffb9b93ffb13ef110b
--- /dev/null
+++ b/cpp/src/vereign/service/gen/event_service.hh
@@ -0,0 +1,48 @@
+#ifndef __VEREIGN_SERVICE_GEN_EVENT_SERVICE_HH
+#define __VEREIGN_SERVICE_GEN_EVENT_SERVICE_HH
+
+#include <vereign/restapi/client_session.hh>
+#include <vereign/restapi/post_result.hh>
+#include <vereign/client_library/types.gen.pb.h>
+
+#include <future>
+
+namespace vereign {
+
+namespace restapi {
+ class ClientSession;
+}
+
+namespace service {
+namespace gen {
+
+template <class Request, class Response>
+using Result = restapi::PostResult<Request, Response>;
+
+class EventService {
+public:
+ static const std::string ServicePath;
+
+ explicit EventService(restapi::ClientSession& client_session);
+
+ EventService(const EventService&) = delete;
+ EventService& operator=(const EventService&) = delete;
+
+ using GetEventsResult = Result<
+ const client_library::GetEventsForm*,
+ client_library::GetEventsFormResponse*>;
+
+ std::future<GetEventsResult> GetEvents(
+ const client_library::GetEventsForm* req,
+ client_library::GetEventsFormResponse* resp
+ );
+
+private:
+ restapi::ClientSession& client_session_;
+};
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
+
+#endif // __VEREIGN_SERVICE_GEN_EVENT_SERVICE_HH
diff --git a/cpp/src/vereign/service/gen/ews_service.cc b/cpp/src/vereign/service/gen/ews_service.cc
new file mode 100644
index 0000000000000000000000000000000000000000..d6c0d88907ec44f6bbda75fcca9af3306764509d
--- /dev/null
+++ b/cpp/src/vereign/service/gen/ews_service.cc
@@ -0,0 +1,32 @@
+#include <vereign/service/gen/ews_service.hh>
+#include <vereign/restapi/client_session.hh>
+
+namespace {
+ const std::string proxyRequestPath = "proxyRequest";
+}
+
+namespace vereign {
+namespace service {
+namespace gen {
+
+const std::string EwsService::ServicePath = "/ews/";
+
+EwsService::EwsService(restapi::ClientSession& client_session)
+ : client_session_{client_session}
+{}
+
+std::future<EwsService::ProxyRequestResult>
+EwsService::ProxyRequest(
+ const client_library::EWSProxyRequestForm* req,
+ client_library::EWSProxyRequestFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + proxyRequestPath,
+ req,
+ resp
+ );
+}
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
diff --git a/cpp/src/vereign/service/gen/ews_service.hh b/cpp/src/vereign/service/gen/ews_service.hh
new file mode 100644
index 0000000000000000000000000000000000000000..f15a1e8597ffd4a019a4cae863d9e1dde3424ea0
--- /dev/null
+++ b/cpp/src/vereign/service/gen/ews_service.hh
@@ -0,0 +1,48 @@
+#ifndef __VEREIGN_SERVICE_GEN_EWS_SERVICE_HH
+#define __VEREIGN_SERVICE_GEN_EWS_SERVICE_HH
+
+#include <vereign/restapi/client_session.hh>
+#include <vereign/restapi/post_result.hh>
+#include <vereign/client_library/types.gen.pb.h>
+
+#include <future>
+
+namespace vereign {
+
+namespace restapi {
+ class ClientSession;
+}
+
+namespace service {
+namespace gen {
+
+template <class Request, class Response>
+using Result = restapi::PostResult<Request, Response>;
+
+class EwsService {
+public:
+ static const std::string ServicePath;
+
+ explicit EwsService(restapi::ClientSession& client_session);
+
+ EwsService(const EwsService&) = delete;
+ EwsService& operator=(const EwsService&) = delete;
+
+ using ProxyRequestResult = Result<
+ const client_library::EWSProxyRequestForm*,
+ client_library::EWSProxyRequestFormResponse*>;
+
+ std::future<ProxyRequestResult> ProxyRequest(
+ const client_library::EWSProxyRequestForm* req,
+ client_library::EWSProxyRequestFormResponse* resp
+ );
+
+private:
+ restapi::ClientSession& client_session_;
+};
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
+
+#endif // __VEREIGN_SERVICE_GEN_EWS_SERVICE_HH
diff --git a/cpp/src/vereign/service/gen/gen.hh b/cpp/src/vereign/service/gen/gen.hh
index fa5b9ab4379a684c747016d512f22bedf30d93a2..0dda26492de4dd05d64beb6208564e2d5f1bcf3b 100644
--- a/cpp/src/vereign/service/gen/gen.hh
+++ b/cpp/src/vereign/service/gen/gen.hh
@@ -1,6 +1,25 @@
#ifndef __VEREIGN_SERVICE_GEN_GEN_HH
#define __VEREIGN_SERVICE_GEN_GEN_HH
+
+#include <vereign/service/gen/action_service.hh>
+#include <vereign/service/gen/activity_service.hh>
+#include <vereign/service/gen/company_service.hh>
+#include <vereign/service/gen/contacts_service.hh>
+#include <vereign/service/gen/conversation_service.hh>
+#include <vereign/service/gen/delete_service.hh>
+#include <vereign/service/gen/document_service.hh>
+#include <vereign/service/gen/email_service.hh>
+#include <vereign/service/gen/entity_service.hh>
+#include <vereign/service/gen/event_service.hh>
+#include <vereign/service/gen/ews_service.hh>
+#include <vereign/service/gen/identity_service.hh>
+#include <vereign/service/gen/interactions_service.hh>
+#include <vereign/service/gen/orders_service.hh>
#include <vereign/service/gen/passport_service.hh>
+#include <vereign/service/gen/reporting_service.hh>
+#include <vereign/service/gen/resource_service.hh>
+#include <vereign/service/gen/sharing_service.hh>
+#include <vereign/service/gen/sign_service.hh>
-#endif
+#endif // __VEREIGN_SERVICE_GEN_GEN_HH
diff --git a/cpp/src/vereign/service/gen/identity_service.cc b/cpp/src/vereign/service/gen/identity_service.cc
new file mode 100644
index 0000000000000000000000000000000000000000..1a3e0da1837ecc6757ca6e70fdbfa13e8d6d027d
--- /dev/null
+++ b/cpp/src/vereign/service/gen/identity_service.cc
@@ -0,0 +1,227 @@
+#include <vereign/service/gen/identity_service.hh>
+#include <vereign/restapi/client_session.hh>
+
+namespace {
+ const std::string authorizeDevicePath = "authorizeDevice";
+ const std::string cancelActionPath = "cancelAction";
+ const std::string confirmActionPath = "confirmAction";
+ const std::string confirmNewCarddavPublicKeyPath = "confirmNewCarddavPublicKey";
+ const std::string confirmNewDevicePath = "confirmNewDevice";
+ const std::string generateCredentialsPath = "generateCredentials";
+ const std::string getAvatarPath = "getAvatar";
+ const std::string getIdentityProfileDataPath = "getIdentityProfileData";
+ const std::string hasUnauthorizedDevicesPath = "hasUnauthorizedDevices";
+ const std::string listDevicesPath = "listDevices";
+ const std::string pullAvatarFromGravatarPath = "pullAvatarFromGravatar";
+ const std::string register2FAPublicKeyPath = "register2FAPublicKey";
+ const std::string renameDevicePath = "renameDevice";
+ const std::string resumeDevicePath = "resumeDevice";
+ const std::string revokeDevicePath = "revokeDevice";
+ const std::string suspendDevicePath = "suspendDevice";
+}
+
+namespace vereign {
+namespace service {
+namespace gen {
+
+const std::string IdentityService::ServicePath = "/identity/";
+
+IdentityService::IdentityService(restapi::ClientSession& client_session)
+ : client_session_{client_session}
+{}
+
+std::future<IdentityService::AuthorizeDeviceResult>
+IdentityService::AuthorizeDevice(
+ const client_library::AuthorizeDeviceForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + authorizeDevicePath,
+ req,
+ resp
+ );
+}
+
+std::future<IdentityService::CancelActionResult>
+IdentityService::CancelAction(
+ const client_library::CancelActionForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + cancelActionPath,
+ req,
+ resp
+ );
+}
+
+std::future<IdentityService::ConfirmActionResult>
+IdentityService::ConfirmAction(
+ const client_library::ConfirmActionExecutionForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + confirmActionPath,
+ req,
+ resp
+ );
+}
+
+std::future<IdentityService::ConfirmNewCarddavPublicKeyResult>
+IdentityService::ConfirmNewCarddavPublicKey(
+ const client_library::ConfirmNewCarddavPublicKeyForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + confirmNewCarddavPublicKeyPath,
+ req,
+ resp
+ );
+}
+
+std::future<IdentityService::ConfirmNewDeviceResult>
+IdentityService::ConfirmNewDevice(
+ const client_library::ConfirmNewDeviceForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + confirmNewDevicePath,
+ req,
+ resp
+ );
+}
+
+std::future<IdentityService::GenerateCredentialsResult>
+IdentityService::GenerateCredentials(
+ const client_library::GenerateCredentialsForm* req,
+ client_library::GenerateCredentialsFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + generateCredentialsPath,
+ req,
+ resp
+ );
+}
+
+std::future<IdentityService::GetAvatarResult>
+IdentityService::GetAvatar(
+ const client_library::GetIdentityAvatarForm* req,
+ client_library::GetIdentityAvatarFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getAvatarPath,
+ req,
+ resp
+ );
+}
+
+std::future<IdentityService::GetIdentityProfileDataResult>
+IdentityService::GetIdentityProfileData(
+ const client_library::GetIdentityProfileDataForm* req,
+ client_library::GetIdentityProfileDataFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getIdentityProfileDataPath,
+ req,
+ resp
+ );
+}
+
+std::future<IdentityService::HasUnauthorizedDevicesResult>
+IdentityService::HasUnauthorizedDevices(
+ const client_library::EmptyRequest* req,
+ client_library::HasUnauthorizedDevicesHandlerFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + hasUnauthorizedDevicesPath,
+ req,
+ resp
+ );
+}
+
+std::future<IdentityService::ListDevicesResult>
+IdentityService::ListDevices(
+ const client_library::EmptyRequest* req,
+ client_library::ListDevicesHandlerFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + listDevicesPath,
+ req,
+ resp
+ );
+}
+
+std::future<IdentityService::PullAvatarFromGravatarResult>
+IdentityService::PullAvatarFromGravatar(
+ const client_library::PullAvatarFromGravatarForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + pullAvatarFromGravatarPath,
+ req,
+ resp
+ );
+}
+
+std::future<IdentityService::Register2FAPublicKeyResult>
+IdentityService::Register2FAPublicKey(
+ const client_library::Register2FAPublicKeyForm* req,
+ client_library::Register2FAPublicKeyFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + register2FAPublicKeyPath,
+ req,
+ resp
+ );
+}
+
+std::future<IdentityService::RenameDeviceResult>
+IdentityService::RenameDevice(
+ const client_library::RenameDeviceForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + renameDevicePath,
+ req,
+ resp
+ );
+}
+
+std::future<IdentityService::ResumeDeviceResult>
+IdentityService::ResumeDevice(
+ const client_library::ResumeDeviceForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + resumeDevicePath,
+ req,
+ resp
+ );
+}
+
+std::future<IdentityService::RevokeDeviceResult>
+IdentityService::RevokeDevice(
+ const client_library::RevokeDeviceForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + revokeDevicePath,
+ req,
+ resp
+ );
+}
+
+std::future<IdentityService::SuspendDeviceResult>
+IdentityService::SuspendDevice(
+ const client_library::SuspendDeviceForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + suspendDevicePath,
+ req,
+ resp
+ );
+}
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
diff --git a/cpp/src/vereign/service/gen/identity_service.hh b/cpp/src/vereign/service/gen/identity_service.hh
new file mode 100644
index 0000000000000000000000000000000000000000..8c5dad11e7a1ab05a4dcad775315ee785dfd61ab
--- /dev/null
+++ b/cpp/src/vereign/service/gen/identity_service.hh
@@ -0,0 +1,183 @@
+#ifndef __VEREIGN_SERVICE_GEN_IDENTITY_SERVICE_HH
+#define __VEREIGN_SERVICE_GEN_IDENTITY_SERVICE_HH
+
+#include <vereign/restapi/client_session.hh>
+#include <vereign/restapi/post_result.hh>
+#include <vereign/client_library/types.gen.pb.h>
+
+#include <future>
+
+namespace vereign {
+
+namespace restapi {
+ class ClientSession;
+}
+
+namespace service {
+namespace gen {
+
+template <class Request, class Response>
+using Result = restapi::PostResult<Request, Response>;
+
+class IdentityService {
+public:
+ static const std::string ServicePath;
+
+ explicit IdentityService(restapi::ClientSession& client_session);
+
+ IdentityService(const IdentityService&) = delete;
+ IdentityService& operator=(const IdentityService&) = delete;
+
+ using AuthorizeDeviceResult = Result<
+ const client_library::AuthorizeDeviceForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<AuthorizeDeviceResult> AuthorizeDevice(
+ const client_library::AuthorizeDeviceForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using CancelActionResult = Result<
+ const client_library::CancelActionForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<CancelActionResult> CancelAction(
+ const client_library::CancelActionForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using ConfirmActionResult = Result<
+ const client_library::ConfirmActionExecutionForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<ConfirmActionResult> ConfirmAction(
+ const client_library::ConfirmActionExecutionForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using ConfirmNewCarddavPublicKeyResult = Result<
+ const client_library::ConfirmNewCarddavPublicKeyForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<ConfirmNewCarddavPublicKeyResult> ConfirmNewCarddavPublicKey(
+ const client_library::ConfirmNewCarddavPublicKeyForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using ConfirmNewDeviceResult = Result<
+ const client_library::ConfirmNewDeviceForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<ConfirmNewDeviceResult> ConfirmNewDevice(
+ const client_library::ConfirmNewDeviceForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using GenerateCredentialsResult = Result<
+ const client_library::GenerateCredentialsForm*,
+ client_library::GenerateCredentialsFormResponse*>;
+
+ std::future<GenerateCredentialsResult> GenerateCredentials(
+ const client_library::GenerateCredentialsForm* req,
+ client_library::GenerateCredentialsFormResponse* resp
+ );
+
+ using GetAvatarResult = Result<
+ const client_library::GetIdentityAvatarForm*,
+ client_library::GetIdentityAvatarFormResponse*>;
+
+ std::future<GetAvatarResult> GetAvatar(
+ const client_library::GetIdentityAvatarForm* req,
+ client_library::GetIdentityAvatarFormResponse* resp
+ );
+
+ using GetIdentityProfileDataResult = Result<
+ const client_library::GetIdentityProfileDataForm*,
+ client_library::GetIdentityProfileDataFormResponse*>;
+
+ std::future<GetIdentityProfileDataResult> GetIdentityProfileData(
+ const client_library::GetIdentityProfileDataForm* req,
+ client_library::GetIdentityProfileDataFormResponse* resp
+ );
+
+ using HasUnauthorizedDevicesResult = Result<
+ const client_library::EmptyRequest*,
+ client_library::HasUnauthorizedDevicesHandlerFormResponse*>;
+
+ std::future<HasUnauthorizedDevicesResult> HasUnauthorizedDevices(
+ const client_library::EmptyRequest* req,
+ client_library::HasUnauthorizedDevicesHandlerFormResponse* resp
+ );
+
+ using ListDevicesResult = Result<
+ const client_library::EmptyRequest*,
+ client_library::ListDevicesHandlerFormResponse*>;
+
+ std::future<ListDevicesResult> ListDevices(
+ const client_library::EmptyRequest* req,
+ client_library::ListDevicesHandlerFormResponse* resp
+ );
+
+ using PullAvatarFromGravatarResult = Result<
+ const client_library::PullAvatarFromGravatarForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<PullAvatarFromGravatarResult> PullAvatarFromGravatar(
+ const client_library::PullAvatarFromGravatarForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using Register2FAPublicKeyResult = Result<
+ const client_library::Register2FAPublicKeyForm*,
+ client_library::Register2FAPublicKeyFormResponse*>;
+
+ std::future<Register2FAPublicKeyResult> Register2FAPublicKey(
+ const client_library::Register2FAPublicKeyForm* req,
+ client_library::Register2FAPublicKeyFormResponse* resp
+ );
+
+ using RenameDeviceResult = Result<
+ const client_library::RenameDeviceForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<RenameDeviceResult> RenameDevice(
+ const client_library::RenameDeviceForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using ResumeDeviceResult = Result<
+ const client_library::ResumeDeviceForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<ResumeDeviceResult> ResumeDevice(
+ const client_library::ResumeDeviceForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using RevokeDeviceResult = Result<
+ const client_library::RevokeDeviceForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<RevokeDeviceResult> RevokeDevice(
+ const client_library::RevokeDeviceForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using SuspendDeviceResult = Result<
+ const client_library::SuspendDeviceForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<SuspendDeviceResult> SuspendDevice(
+ const client_library::SuspendDeviceForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+private:
+ restapi::ClientSession& client_session_;
+};
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
+
+#endif // __VEREIGN_SERVICE_GEN_IDENTITY_SERVICE_HH
diff --git a/cpp/src/vereign/service/gen/interactions_service.cc b/cpp/src/vereign/service/gen/interactions_service.cc
new file mode 100644
index 0000000000000000000000000000000000000000..f7832735c20290f17d34b9683ec6c092ed8f1b80
--- /dev/null
+++ b/cpp/src/vereign/service/gen/interactions_service.cc
@@ -0,0 +1,32 @@
+#include <vereign/service/gen/interactions_service.hh>
+#include <vereign/restapi/client_session.hh>
+
+namespace {
+ const std::string searchInteractionsPath = "searchInteractions";
+}
+
+namespace vereign {
+namespace service {
+namespace gen {
+
+const std::string InteractionsService::ServicePath = "/interactions/";
+
+InteractionsService::InteractionsService(restapi::ClientSession& client_session)
+ : client_session_{client_session}
+{}
+
+std::future<InteractionsService::SearchInteractionsResult>
+InteractionsService::SearchInteractions(
+ const client_library::SearchInteractionsForm* req,
+ client_library::SearchInteractionsFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + searchInteractionsPath,
+ req,
+ resp
+ );
+}
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
diff --git a/cpp/src/vereign/service/gen/interactions_service.hh b/cpp/src/vereign/service/gen/interactions_service.hh
new file mode 100644
index 0000000000000000000000000000000000000000..105640c151922f69641f662460422d9479f6faf7
--- /dev/null
+++ b/cpp/src/vereign/service/gen/interactions_service.hh
@@ -0,0 +1,48 @@
+#ifndef __VEREIGN_SERVICE_GEN_INTERACTIONS_SERVICE_HH
+#define __VEREIGN_SERVICE_GEN_INTERACTIONS_SERVICE_HH
+
+#include <vereign/restapi/client_session.hh>
+#include <vereign/restapi/post_result.hh>
+#include <vereign/client_library/types.gen.pb.h>
+
+#include <future>
+
+namespace vereign {
+
+namespace restapi {
+ class ClientSession;
+}
+
+namespace service {
+namespace gen {
+
+template <class Request, class Response>
+using Result = restapi::PostResult<Request, Response>;
+
+class InteractionsService {
+public:
+ static const std::string ServicePath;
+
+ explicit InteractionsService(restapi::ClientSession& client_session);
+
+ InteractionsService(const InteractionsService&) = delete;
+ InteractionsService& operator=(const InteractionsService&) = delete;
+
+ using SearchInteractionsResult = Result<
+ const client_library::SearchInteractionsForm*,
+ client_library::SearchInteractionsFormResponse*>;
+
+ std::future<SearchInteractionsResult> SearchInteractions(
+ const client_library::SearchInteractionsForm* req,
+ client_library::SearchInteractionsFormResponse* resp
+ );
+
+private:
+ restapi::ClientSession& client_session_;
+};
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
+
+#endif // __VEREIGN_SERVICE_GEN_INTERACTIONS_SERVICE_HH
diff --git a/cpp/src/vereign/service/gen/orders_service.cc b/cpp/src/vereign/service/gen/orders_service.cc
new file mode 100644
index 0000000000000000000000000000000000000000..1f981a4030acb4d693235b57a9803be02519cc56
--- /dev/null
+++ b/cpp/src/vereign/service/gen/orders_service.cc
@@ -0,0 +1,84 @@
+#include <vereign/service/gen/orders_service.hh>
+#include <vereign/restapi/client_session.hh>
+
+namespace {
+ const std::string confirmCardPaymentPath = "confirmCardPayment";
+ const std::string getGeneratedInvoiceForOrderPath = "getGeneratedInvoiceForOrder";
+ const std::string getOrderPath = "getOrder";
+ const std::string initializeCardPaymentPath = "initializeCardPayment";
+ const std::string listOrdersPath = "listOrders";
+}
+
+namespace vereign {
+namespace service {
+namespace gen {
+
+const std::string OrdersService::ServicePath = "/orders/";
+
+OrdersService::OrdersService(restapi::ClientSession& client_session)
+ : client_session_{client_session}
+{}
+
+std::future<OrdersService::ConfirmCardPaymentResult>
+OrdersService::ConfirmCardPayment(
+ const client_library::ConfirmCardPaymentForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + confirmCardPaymentPath,
+ req,
+ resp
+ );
+}
+
+std::future<OrdersService::GetGeneratedInvoiceForOrderResult>
+OrdersService::GetGeneratedInvoiceForOrder(
+ const client_library::GetGeneratedInvoiceForOrderForm* req,
+ client_library::GetGeneratedInvoiceForOrderFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getGeneratedInvoiceForOrderPath,
+ req,
+ resp
+ );
+}
+
+std::future<OrdersService::GetOrderResult>
+OrdersService::GetOrder(
+ const client_library::GetOrderForm* req,
+ client_library::GetOrderFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getOrderPath,
+ req,
+ resp
+ );
+}
+
+std::future<OrdersService::InitializeCardPaymentResult>
+OrdersService::InitializeCardPayment(
+ const client_library::InitializeCardPaymentForm* req,
+ client_library::InitializeCardPaymentFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + initializeCardPaymentPath,
+ req,
+ resp
+ );
+}
+
+std::future<OrdersService::ListOrdersResult>
+OrdersService::ListOrders(
+ const client_library::ListOrdersForm* req,
+ client_library::ListOrdersFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + listOrdersPath,
+ req,
+ resp
+ );
+}
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
diff --git a/cpp/src/vereign/service/gen/orders_service.hh b/cpp/src/vereign/service/gen/orders_service.hh
new file mode 100644
index 0000000000000000000000000000000000000000..c6f4e209614ed9af2af6f418678ae7a5927ad083
--- /dev/null
+++ b/cpp/src/vereign/service/gen/orders_service.hh
@@ -0,0 +1,84 @@
+#ifndef __VEREIGN_SERVICE_GEN_ORDERS_SERVICE_HH
+#define __VEREIGN_SERVICE_GEN_ORDERS_SERVICE_HH
+
+#include <vereign/restapi/client_session.hh>
+#include <vereign/restapi/post_result.hh>
+#include <vereign/client_library/types.gen.pb.h>
+
+#include <future>
+
+namespace vereign {
+
+namespace restapi {
+ class ClientSession;
+}
+
+namespace service {
+namespace gen {
+
+template <class Request, class Response>
+using Result = restapi::PostResult<Request, Response>;
+
+class OrdersService {
+public:
+ static const std::string ServicePath;
+
+ explicit OrdersService(restapi::ClientSession& client_session);
+
+ OrdersService(const OrdersService&) = delete;
+ OrdersService& operator=(const OrdersService&) = delete;
+
+ using ConfirmCardPaymentResult = Result<
+ const client_library::ConfirmCardPaymentForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<ConfirmCardPaymentResult> ConfirmCardPayment(
+ const client_library::ConfirmCardPaymentForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using GetGeneratedInvoiceForOrderResult = Result<
+ const client_library::GetGeneratedInvoiceForOrderForm*,
+ client_library::GetGeneratedInvoiceForOrderFormResponse*>;
+
+ std::future<GetGeneratedInvoiceForOrderResult> GetGeneratedInvoiceForOrder(
+ const client_library::GetGeneratedInvoiceForOrderForm* req,
+ client_library::GetGeneratedInvoiceForOrderFormResponse* resp
+ );
+
+ using GetOrderResult = Result<
+ const client_library::GetOrderForm*,
+ client_library::GetOrderFormResponse*>;
+
+ std::future<GetOrderResult> GetOrder(
+ const client_library::GetOrderForm* req,
+ client_library::GetOrderFormResponse* resp
+ );
+
+ using InitializeCardPaymentResult = Result<
+ const client_library::InitializeCardPaymentForm*,
+ client_library::InitializeCardPaymentFormResponse*>;
+
+ std::future<InitializeCardPaymentResult> InitializeCardPayment(
+ const client_library::InitializeCardPaymentForm* req,
+ client_library::InitializeCardPaymentFormResponse* resp
+ );
+
+ using ListOrdersResult = Result<
+ const client_library::ListOrdersForm*,
+ client_library::ListOrdersFormResponse*>;
+
+ std::future<ListOrdersResult> ListOrders(
+ const client_library::ListOrdersForm* req,
+ client_library::ListOrdersFormResponse* resp
+ );
+
+private:
+ restapi::ClientSession& client_session_;
+};
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
+
+#endif // __VEREIGN_SERVICE_GEN_ORDERS_SERVICE_HH
diff --git a/cpp/src/vereign/service/gen/passport_service.cc b/cpp/src/vereign/service/gen/passport_service.cc
index 5c47d20095b18bd9dfddd76d0f15e6d451759e2f..c7ce9072744c3f31cca6f62e1ff666c5ef148961 100644
--- a/cpp/src/vereign/service/gen/passport_service.cc
+++ b/cpp/src/vereign/service/gen/passport_service.cc
@@ -2,7 +2,22 @@
#include <vereign/restapi/client_session.hh>
namespace {
+ const std::string attachFunctionPath = "attachFunction";
+ const std::string callFunctionPath = "callFunction";
+ const std::string generateDIDsPath = "generateDIDs";
+ const std::string getAvatarByPassportPath = "getAvatarByPassport";
+ const std::string getDIDsPath = "getDIDs";
+ const std::string getEmailWithHeaderByPassportPath = "getEmailWithHeaderByPassport";
+ const std::string getInteractionsPath = "getInteractions";
+ const std::string getVCardImagePath = "getVCardImage";
+ const std::string getVCardTemplatePath = "getVCardTemplate";
+ const std::string linkClaimPath = "linkClaim";
+ const std::string listFunctionsPath = "listFunctions";
const std::string listPassportsPath = "listPassports";
+ const std::string listPassportsForSharedIdentityPath = "listPassportsForSharedIdentity";
+ const std::string listSharedIdentitiesWithUserPath = "listSharedIdentitiesWithUser";
+ const std::string setVCardImagePath = "setVCardImage";
+ const std::string storeDIDsPath = "storeDIDs";
}
namespace vereign {
@@ -15,6 +30,138 @@ PassportService::PassportService(restapi::ClientSession& client_session)
: client_session_{client_session}
{}
+std::future<PassportService::AttachFunctionResult>
+PassportService::AttachFunction(
+ const client_library::AttachFunctionToPassportClaimForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + attachFunctionPath,
+ req,
+ resp
+ );
+}
+
+std::future<PassportService::CallFunctionResult>
+PassportService::CallFunction(
+ const client_library::CallFunctionForm* req,
+ client_library::CallFunctionFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + callFunctionPath,
+ req,
+ resp
+ );
+}
+
+std::future<PassportService::GenerateDIDsResult>
+PassportService::GenerateDIDs(
+ const client_library::GenerateDIDsForm* req,
+ client_library::GenerateDIDsFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + generateDIDsPath,
+ req,
+ resp
+ );
+}
+
+std::future<PassportService::GetAvatarByPassportResult>
+PassportService::GetAvatarByPassport(
+ const client_library::GetAvatarByPassportForm* req,
+ client_library::GetAvatarByPassportFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getAvatarByPassportPath,
+ req,
+ resp
+ );
+}
+
+std::future<PassportService::GetDIDsResult>
+PassportService::GetDIDs(
+ const client_library::GetDIDsForm* req,
+ client_library::GetDIDsFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getDIDsPath,
+ req,
+ resp
+ );
+}
+
+std::future<PassportService::GetEmailWithHeaderByPassportResult>
+PassportService::GetEmailWithHeaderByPassport(
+ const client_library::GetEmailWithHeaderByPassportForm* req,
+ client_library::GetEmailWithHeaderByPassportFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getEmailWithHeaderByPassportPath,
+ req,
+ resp
+ );
+}
+
+std::future<PassportService::GetInteractionsResult>
+PassportService::GetInteractions(
+ const client_library::GetInteractionsForm* req,
+ client_library::GetInteractionsFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getInteractionsPath,
+ req,
+ resp
+ );
+}
+
+std::future<PassportService::GetVCardImageResult>
+PassportService::GetVCardImage(
+ const client_library::GetVCardImageForm* req,
+ client_library::GetVCardImageFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getVCardImagePath,
+ req,
+ resp
+ );
+}
+
+std::future<PassportService::GetVCardTemplateResult>
+PassportService::GetVCardTemplate(
+ const client_library::GetVCardTemplateForm* req,
+ client_library::GetVCardTemplateFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getVCardTemplatePath,
+ req,
+ resp
+ );
+}
+
+std::future<PassportService::LinkClaimResult>
+PassportService::LinkClaim(
+ const client_library::LinkClaimToPassportForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + linkClaimPath,
+ req,
+ resp
+ );
+}
+
+std::future<PassportService::ListFunctionsResult>
+PassportService::ListFunctions(
+ const client_library::EmptyRequest* req,
+ client_library::ListFunctionsResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + listFunctionsPath,
+ req,
+ resp
+ );
+}
+
std::future<PassportService::ListPassportsResult>
PassportService::ListPassports(
const client_library::ListPassportsForm* req,
@@ -27,6 +174,53 @@ PassportService::ListPassports(
);
}
+std::future<PassportService::ListPassportsForSharedIdentityResult>
+PassportService::ListPassportsForSharedIdentity(
+ const client_library::ListPassportsForSharedIdentityForm* req,
+ client_library::ListPassportsForSharedIdentityFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + listPassportsForSharedIdentityPath,
+ req,
+ resp
+ );
+}
+
+std::future<PassportService::ListSharedIdentitiesWithUserResult>
+PassportService::ListSharedIdentitiesWithUser(
+ const client_library::ListSharedIdentitiesWithUserForm* req,
+ client_library::ListSharedIdentitiesWithUserFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + listSharedIdentitiesWithUserPath,
+ req,
+ resp
+ );
+}
+
+std::future<PassportService::SetVCardImageResult>
+PassportService::SetVCardImage(
+ const client_library::SetVCardImageForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + setVCardImagePath,
+ req,
+ resp
+ );
+}
+
+std::future<PassportService::StoreDIDsResult>
+PassportService::StoreDIDs(
+ const client_library::StoreDIDsForm* req,
+ client_library::StoreDIDsFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + storeDIDsPath,
+ req,
+ resp
+ );
+}
} // namespace gen
} // namespace service
diff --git a/cpp/src/vereign/service/gen/passport_service.hh b/cpp/src/vereign/service/gen/passport_service.hh
index e6bfad2b92a55937bb563cf79ca02932b88f35bf..d9841ab9bad016bc8518836500a47207d4ef31ea 100644
--- a/cpp/src/vereign/service/gen/passport_service.hh
+++ b/cpp/src/vereign/service/gen/passport_service.hh
@@ -3,7 +3,7 @@
#include <vereign/restapi/client_session.hh>
#include <vereign/restapi/post_result.hh>
-#include <vereign/client_library/passport_types.gen.pb.h>
+#include <vereign/client_library/types.gen.pb.h>
#include <future>
@@ -28,6 +28,105 @@ public:
PassportService(const PassportService&) = delete;
PassportService& operator=(const PassportService&) = delete;
+ using AttachFunctionResult = Result<
+ const client_library::AttachFunctionToPassportClaimForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<AttachFunctionResult> AttachFunction(
+ const client_library::AttachFunctionToPassportClaimForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using CallFunctionResult = Result<
+ const client_library::CallFunctionForm*,
+ client_library::CallFunctionFormResponse*>;
+
+ std::future<CallFunctionResult> CallFunction(
+ const client_library::CallFunctionForm* req,
+ client_library::CallFunctionFormResponse* resp
+ );
+
+ using GenerateDIDsResult = Result<
+ const client_library::GenerateDIDsForm*,
+ client_library::GenerateDIDsFormResponse*>;
+
+ std::future<GenerateDIDsResult> GenerateDIDs(
+ const client_library::GenerateDIDsForm* req,
+ client_library::GenerateDIDsFormResponse* resp
+ );
+
+ using GetAvatarByPassportResult = Result<
+ const client_library::GetAvatarByPassportForm*,
+ client_library::GetAvatarByPassportFormResponse*>;
+
+ std::future<GetAvatarByPassportResult> GetAvatarByPassport(
+ const client_library::GetAvatarByPassportForm* req,
+ client_library::GetAvatarByPassportFormResponse* resp
+ );
+
+ using GetDIDsResult = Result<
+ const client_library::GetDIDsForm*,
+ client_library::GetDIDsFormResponse*>;
+
+ std::future<GetDIDsResult> GetDIDs(
+ const client_library::GetDIDsForm* req,
+ client_library::GetDIDsFormResponse* resp
+ );
+
+ using GetEmailWithHeaderByPassportResult = Result<
+ const client_library::GetEmailWithHeaderByPassportForm*,
+ client_library::GetEmailWithHeaderByPassportFormResponse*>;
+
+ std::future<GetEmailWithHeaderByPassportResult> GetEmailWithHeaderByPassport(
+ const client_library::GetEmailWithHeaderByPassportForm* req,
+ client_library::GetEmailWithHeaderByPassportFormResponse* resp
+ );
+
+ using GetInteractionsResult = Result<
+ const client_library::GetInteractionsForm*,
+ client_library::GetInteractionsFormResponse*>;
+
+ std::future<GetInteractionsResult> GetInteractions(
+ const client_library::GetInteractionsForm* req,
+ client_library::GetInteractionsFormResponse* resp
+ );
+
+ using GetVCardImageResult = Result<
+ const client_library::GetVCardImageForm*,
+ client_library::GetVCardImageFormResponse*>;
+
+ std::future<GetVCardImageResult> GetVCardImage(
+ const client_library::GetVCardImageForm* req,
+ client_library::GetVCardImageFormResponse* resp
+ );
+
+ using GetVCardTemplateResult = Result<
+ const client_library::GetVCardTemplateForm*,
+ client_library::GetVCardTemplateFormResponse*>;
+
+ std::future<GetVCardTemplateResult> GetVCardTemplate(
+ const client_library::GetVCardTemplateForm* req,
+ client_library::GetVCardTemplateFormResponse* resp
+ );
+
+ using LinkClaimResult = Result<
+ const client_library::LinkClaimToPassportForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<LinkClaimResult> LinkClaim(
+ const client_library::LinkClaimToPassportForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using ListFunctionsResult = Result<
+ const client_library::EmptyRequest*,
+ client_library::ListFunctionsResponse*>;
+
+ std::future<ListFunctionsResult> ListFunctions(
+ const client_library::EmptyRequest* req,
+ client_library::ListFunctionsResponse* resp
+ );
+
using ListPassportsResult = Result<
const client_library::ListPassportsForm*,
client_library::ListPassportsFormResponse*>;
@@ -37,6 +136,42 @@ public:
client_library::ListPassportsFormResponse* resp
);
+ using ListPassportsForSharedIdentityResult = Result<
+ const client_library::ListPassportsForSharedIdentityForm*,
+ client_library::ListPassportsForSharedIdentityFormResponse*>;
+
+ std::future<ListPassportsForSharedIdentityResult> ListPassportsForSharedIdentity(
+ const client_library::ListPassportsForSharedIdentityForm* req,
+ client_library::ListPassportsForSharedIdentityFormResponse* resp
+ );
+
+ using ListSharedIdentitiesWithUserResult = Result<
+ const client_library::ListSharedIdentitiesWithUserForm*,
+ client_library::ListSharedIdentitiesWithUserFormResponse*>;
+
+ std::future<ListSharedIdentitiesWithUserResult> ListSharedIdentitiesWithUser(
+ const client_library::ListSharedIdentitiesWithUserForm* req,
+ client_library::ListSharedIdentitiesWithUserFormResponse* resp
+ );
+
+ using SetVCardImageResult = Result<
+ const client_library::SetVCardImageForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<SetVCardImageResult> SetVCardImage(
+ const client_library::SetVCardImageForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using StoreDIDsResult = Result<
+ const client_library::StoreDIDsForm*,
+ client_library::StoreDIDsFormResponse*>;
+
+ std::future<StoreDIDsResult> StoreDIDs(
+ const client_library::StoreDIDsForm* req,
+ client_library::StoreDIDsFormResponse* resp
+ );
+
private:
restapi::ClientSession& client_session_;
};
diff --git a/cpp/src/vereign/service/gen/reporting_service.cc b/cpp/src/vereign/service/gen/reporting_service.cc
new file mode 100644
index 0000000000000000000000000000000000000000..07d87843e9bdd5ca366543b111967c6fd9c3954f
--- /dev/null
+++ b/cpp/src/vereign/service/gen/reporting_service.cc
@@ -0,0 +1,45 @@
+#include <vereign/service/gen/reporting_service.hh>
+#include <vereign/restapi/client_session.hh>
+
+namespace {
+ const std::string getbillingdataforperiodPath = "getbillingdataforperiod";
+ const std::string getreporttotaldataPath = "getreporttotaldata";
+}
+
+namespace vereign {
+namespace service {
+namespace gen {
+
+const std::string ReportingService::ServicePath = "/reporting/";
+
+ReportingService::ReportingService(restapi::ClientSession& client_session)
+ : client_session_{client_session}
+{}
+
+std::future<ReportingService::GetbillingdataforperiodResult>
+ReportingService::Getbillingdataforperiod(
+ const client_library::GetBillingDataForPeriodForm* req,
+ client_library::GetBillingDataForPeriodFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getbillingdataforperiodPath,
+ req,
+ resp
+ );
+}
+
+std::future<ReportingService::GetreporttotaldataResult>
+ReportingService::Getreporttotaldata(
+ const client_library::GetReportTotalDataForm* req,
+ client_library::GetReportTotalDataFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + getreporttotaldataPath,
+ req,
+ resp
+ );
+}
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
diff --git a/cpp/src/vereign/service/gen/reporting_service.hh b/cpp/src/vereign/service/gen/reporting_service.hh
new file mode 100644
index 0000000000000000000000000000000000000000..3781e78ed8a3020422b619ccf36e0e891b17be79
--- /dev/null
+++ b/cpp/src/vereign/service/gen/reporting_service.hh
@@ -0,0 +1,57 @@
+#ifndef __VEREIGN_SERVICE_GEN_REPORTING_SERVICE_HH
+#define __VEREIGN_SERVICE_GEN_REPORTING_SERVICE_HH
+
+#include <vereign/restapi/client_session.hh>
+#include <vereign/restapi/post_result.hh>
+#include <vereign/client_library/types.gen.pb.h>
+
+#include <future>
+
+namespace vereign {
+
+namespace restapi {
+ class ClientSession;
+}
+
+namespace service {
+namespace gen {
+
+template <class Request, class Response>
+using Result = restapi::PostResult<Request, Response>;
+
+class ReportingService {
+public:
+ static const std::string ServicePath;
+
+ explicit ReportingService(restapi::ClientSession& client_session);
+
+ ReportingService(const ReportingService&) = delete;
+ ReportingService& operator=(const ReportingService&) = delete;
+
+ using GetbillingdataforperiodResult = Result<
+ const client_library::GetBillingDataForPeriodForm*,
+ client_library::GetBillingDataForPeriodFormResponse*>;
+
+ std::future<GetbillingdataforperiodResult> Getbillingdataforperiod(
+ const client_library::GetBillingDataForPeriodForm* req,
+ client_library::GetBillingDataForPeriodFormResponse* resp
+ );
+
+ using GetreporttotaldataResult = Result<
+ const client_library::GetReportTotalDataForm*,
+ client_library::GetReportTotalDataFormResponse*>;
+
+ std::future<GetreporttotaldataResult> Getreporttotaldata(
+ const client_library::GetReportTotalDataForm* req,
+ client_library::GetReportTotalDataFormResponse* resp
+ );
+
+private:
+ restapi::ClientSession& client_session_;
+};
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
+
+#endif // __VEREIGN_SERVICE_GEN_REPORTING_SERVICE_HH
diff --git a/cpp/src/vereign/service/gen/resource_service.cc b/cpp/src/vereign/service/gen/resource_service.cc
new file mode 100644
index 0000000000000000000000000000000000000000..317105dd543a5673d60ec660500efa5f4810d470
--- /dev/null
+++ b/cpp/src/vereign/service/gen/resource_service.cc
@@ -0,0 +1,45 @@
+#include <vereign/service/gen/resource_service.hh>
+#include <vereign/restapi/client_session.hh>
+
+namespace {
+ const std::string deleteResourceByTokenPath = "deleteResourceByToken";
+ const std::string storeResourcePath = "storeResource";
+}
+
+namespace vereign {
+namespace service {
+namespace gen {
+
+const std::string ResourceService::ServicePath = "/resource/";
+
+ResourceService::ResourceService(restapi::ClientSession& client_session)
+ : client_session_{client_session}
+{}
+
+std::future<ResourceService::DeleteResourceByTokenResult>
+ResourceService::DeleteResourceByToken(
+ const client_library::DeleteResourceForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + deleteResourceByTokenPath,
+ req,
+ resp
+ );
+}
+
+std::future<ResourceService::StoreResourceResult>
+ResourceService::StoreResource(
+ const client_library::StoreResourceForm* req,
+ client_library::StoreResourceFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + storeResourcePath,
+ req,
+ resp
+ );
+}
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
diff --git a/cpp/src/vereign/service/gen/resource_service.hh b/cpp/src/vereign/service/gen/resource_service.hh
new file mode 100644
index 0000000000000000000000000000000000000000..bed33a2a6b06cc75bea3d81c771bcae4e2186c06
--- /dev/null
+++ b/cpp/src/vereign/service/gen/resource_service.hh
@@ -0,0 +1,57 @@
+#ifndef __VEREIGN_SERVICE_GEN_RESOURCE_SERVICE_HH
+#define __VEREIGN_SERVICE_GEN_RESOURCE_SERVICE_HH
+
+#include <vereign/restapi/client_session.hh>
+#include <vereign/restapi/post_result.hh>
+#include <vereign/client_library/types.gen.pb.h>
+
+#include <future>
+
+namespace vereign {
+
+namespace restapi {
+ class ClientSession;
+}
+
+namespace service {
+namespace gen {
+
+template <class Request, class Response>
+using Result = restapi::PostResult<Request, Response>;
+
+class ResourceService {
+public:
+ static const std::string ServicePath;
+
+ explicit ResourceService(restapi::ClientSession& client_session);
+
+ ResourceService(const ResourceService&) = delete;
+ ResourceService& operator=(const ResourceService&) = delete;
+
+ using DeleteResourceByTokenResult = Result<
+ const client_library::DeleteResourceForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<DeleteResourceByTokenResult> DeleteResourceByToken(
+ const client_library::DeleteResourceForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using StoreResourceResult = Result<
+ const client_library::StoreResourceForm*,
+ client_library::StoreResourceFormResponse*>;
+
+ std::future<StoreResourceResult> StoreResource(
+ const client_library::StoreResourceForm* req,
+ client_library::StoreResourceFormResponse* resp
+ );
+
+private:
+ restapi::ClientSession& client_session_;
+};
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
+
+#endif // __VEREIGN_SERVICE_GEN_RESOURCE_SERVICE_HH
diff --git a/cpp/src/vereign/service/gen/sharing_service.cc b/cpp/src/vereign/service/gen/sharing_service.cc
new file mode 100644
index 0000000000000000000000000000000000000000..f30874b189390589bea73a887b3c1629e47391b2
--- /dev/null
+++ b/cpp/src/vereign/service/gen/sharing_service.cc
@@ -0,0 +1,97 @@
+#include <vereign/service/gen/sharing_service.hh>
+#include <vereign/restapi/client_session.hh>
+
+namespace {
+ const std::string acceptSharingRequestMovePassportPath = "acceptSharingRequestMovePassport";
+ const std::string acceptSharingRequestPersistPassportPath = "acceptSharingRequestPersistPassport";
+ const std::string listPendingSharingRequestsPath = "listPendingSharingRequests";
+ const std::string listRejectedSharingRequestsPath = "listRejectedSharingRequests";
+ const std::string rejectSharingRequestPath = "rejectSharingRequest";
+ const std::string sendShareDocumentRequestPath = "sendShareDocumentRequest";
+}
+
+namespace vereign {
+namespace service {
+namespace gen {
+
+const std::string SharingService::ServicePath = "/sharing/";
+
+SharingService::SharingService(restapi::ClientSession& client_session)
+ : client_session_{client_session}
+{}
+
+std::future<SharingService::AcceptSharingRequestMovePassportResult>
+SharingService::AcceptSharingRequestMovePassport(
+ const client_library::AcceptSharingRequestMovePassportForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + acceptSharingRequestMovePassportPath,
+ req,
+ resp
+ );
+}
+
+std::future<SharingService::AcceptSharingRequestPersistPassportResult>
+SharingService::AcceptSharingRequestPersistPassport(
+ const client_library::AcceptSharingRequestPersistPassportForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + acceptSharingRequestPersistPassportPath,
+ req,
+ resp
+ );
+}
+
+std::future<SharingService::ListPendingSharingRequestsResult>
+SharingService::ListPendingSharingRequests(
+ const client_library::ListPendingSharingRequestsForm* req,
+ client_library::ListPendingSharingRequestsFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + listPendingSharingRequestsPath,
+ req,
+ resp
+ );
+}
+
+std::future<SharingService::ListRejectedSharingRequestsResult>
+SharingService::ListRejectedSharingRequests(
+ const client_library::ListRejectedSharingRequestsForm* req,
+ client_library::ListRejectedSharingRequestsFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + listRejectedSharingRequestsPath,
+ req,
+ resp
+ );
+}
+
+std::future<SharingService::RejectSharingRequestResult>
+SharingService::RejectSharingRequest(
+ const client_library::RejectSharingRequestForm* req,
+ client_library::EmptyResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + rejectSharingRequestPath,
+ req,
+ resp
+ );
+}
+
+std::future<SharingService::SendShareDocumentRequestResult>
+SharingService::SendShareDocumentRequest(
+ const client_library::SendShareDocumentRequestForm* req,
+ client_library::SendShareDocumentRequestFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + sendShareDocumentRequestPath,
+ req,
+ resp
+ );
+}
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
diff --git a/cpp/src/vereign/service/gen/sharing_service.hh b/cpp/src/vereign/service/gen/sharing_service.hh
new file mode 100644
index 0000000000000000000000000000000000000000..0edb2914e76b474f50584b02355e583e2a8caa10
--- /dev/null
+++ b/cpp/src/vereign/service/gen/sharing_service.hh
@@ -0,0 +1,93 @@
+#ifndef __VEREIGN_SERVICE_GEN_SHARING_SERVICE_HH
+#define __VEREIGN_SERVICE_GEN_SHARING_SERVICE_HH
+
+#include <vereign/restapi/client_session.hh>
+#include <vereign/restapi/post_result.hh>
+#include <vereign/client_library/types.gen.pb.h>
+
+#include <future>
+
+namespace vereign {
+
+namespace restapi {
+ class ClientSession;
+}
+
+namespace service {
+namespace gen {
+
+template <class Request, class Response>
+using Result = restapi::PostResult<Request, Response>;
+
+class SharingService {
+public:
+ static const std::string ServicePath;
+
+ explicit SharingService(restapi::ClientSession& client_session);
+
+ SharingService(const SharingService&) = delete;
+ SharingService& operator=(const SharingService&) = delete;
+
+ using AcceptSharingRequestMovePassportResult = Result<
+ const client_library::AcceptSharingRequestMovePassportForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<AcceptSharingRequestMovePassportResult> AcceptSharingRequestMovePassport(
+ const client_library::AcceptSharingRequestMovePassportForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using AcceptSharingRequestPersistPassportResult = Result<
+ const client_library::AcceptSharingRequestPersistPassportForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<AcceptSharingRequestPersistPassportResult> AcceptSharingRequestPersistPassport(
+ const client_library::AcceptSharingRequestPersistPassportForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using ListPendingSharingRequestsResult = Result<
+ const client_library::ListPendingSharingRequestsForm*,
+ client_library::ListPendingSharingRequestsFormResponse*>;
+
+ std::future<ListPendingSharingRequestsResult> ListPendingSharingRequests(
+ const client_library::ListPendingSharingRequestsForm* req,
+ client_library::ListPendingSharingRequestsFormResponse* resp
+ );
+
+ using ListRejectedSharingRequestsResult = Result<
+ const client_library::ListRejectedSharingRequestsForm*,
+ client_library::ListRejectedSharingRequestsFormResponse*>;
+
+ std::future<ListRejectedSharingRequestsResult> ListRejectedSharingRequests(
+ const client_library::ListRejectedSharingRequestsForm* req,
+ client_library::ListRejectedSharingRequestsFormResponse* resp
+ );
+
+ using RejectSharingRequestResult = Result<
+ const client_library::RejectSharingRequestForm*,
+ client_library::EmptyResponse*>;
+
+ std::future<RejectSharingRequestResult> RejectSharingRequest(
+ const client_library::RejectSharingRequestForm* req,
+ client_library::EmptyResponse* resp
+ );
+
+ using SendShareDocumentRequestResult = Result<
+ const client_library::SendShareDocumentRequestForm*,
+ client_library::SendShareDocumentRequestFormResponse*>;
+
+ std::future<SendShareDocumentRequestResult> SendShareDocumentRequest(
+ const client_library::SendShareDocumentRequestForm* req,
+ client_library::SendShareDocumentRequestFormResponse* resp
+ );
+
+private:
+ restapi::ClientSession& client_session_;
+};
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
+
+#endif // __VEREIGN_SERVICE_GEN_SHARING_SERVICE_HH
diff --git a/cpp/src/vereign/service/gen/sign_service.cc b/cpp/src/vereign/service/gen/sign_service.cc
new file mode 100644
index 0000000000000000000000000000000000000000..cb6a099da6d61fb98f250c0f1d31beba0199683f
--- /dev/null
+++ b/cpp/src/vereign/service/gen/sign_service.cc
@@ -0,0 +1,97 @@
+#include <vereign/service/gen/sign_service.hh>
+#include <vereign/restapi/client_session.hh>
+
+namespace {
+ const std::string generateCmsForChainPath = "generateCmsForChain";
+ const std::string generateCmsForPassportPath = "generateCmsForPassport";
+ const std::string resignEmailPath = "resignEmail";
+ const std::string retrieveRootCertificatePath = "retrieveRootCertificate";
+ const std::string signVCardForChainPath = "signVCardForChain";
+ const std::string validateVMimePath = "validateVMime";
+}
+
+namespace vereign {
+namespace service {
+namespace gen {
+
+const std::string SignService::ServicePath = "/sign/";
+
+SignService::SignService(restapi::ClientSession& client_session)
+ : client_session_{client_session}
+{}
+
+std::future<SignService::GenerateCmsForChainResult>
+SignService::GenerateCmsForChain(
+ const client_library::GenerateCmsForChainForm* req,
+ client_library::GenerateCmsForChainFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + generateCmsForChainPath,
+ req,
+ resp
+ );
+}
+
+std::future<SignService::GenerateCmsForPassportResult>
+SignService::GenerateCmsForPassport(
+ const client_library::GenerateCmsForPassportForm* req,
+ client_library::GenerateCmsForPassportFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + generateCmsForPassportPath,
+ req,
+ resp
+ );
+}
+
+std::future<SignService::ResignEmailResult>
+SignService::ResignEmail(
+ const client_library::ResignSMIMEForm* req,
+ client_library::ResignSMIMEFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + resignEmailPath,
+ req,
+ resp
+ );
+}
+
+std::future<SignService::RetrieveRootCertificateResult>
+SignService::RetrieveRootCertificate(
+ const client_library::RetrieveRootCertificateForm* req,
+ client_library::RetrieveRootCertificateFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + retrieveRootCertificatePath,
+ req,
+ resp
+ );
+}
+
+std::future<SignService::SignVCardForChainResult>
+SignService::SignVCardForChain(
+ const client_library::SignVCardForChainForm* req,
+ client_library::SignVCardForChainFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + signVCardForChainPath,
+ req,
+ resp
+ );
+}
+
+std::future<SignService::ValidateVMimeResult>
+SignService::ValidateVMime(
+ const client_library::ValidateVMimeForm* req,
+ client_library::ValidateVMimeFormResponse* resp
+) {
+ return client_session_.Post(
+ ServicePath + validateVMimePath,
+ req,
+ resp
+ );
+}
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
diff --git a/cpp/src/vereign/service/gen/sign_service.hh b/cpp/src/vereign/service/gen/sign_service.hh
new file mode 100644
index 0000000000000000000000000000000000000000..bb0f81ac5cc985fad54d4e3959ee2844965f7c96
--- /dev/null
+++ b/cpp/src/vereign/service/gen/sign_service.hh
@@ -0,0 +1,93 @@
+#ifndef __VEREIGN_SERVICE_GEN_SIGN_SERVICE_HH
+#define __VEREIGN_SERVICE_GEN_SIGN_SERVICE_HH
+
+#include <vereign/restapi/client_session.hh>
+#include <vereign/restapi/post_result.hh>
+#include <vereign/client_library/types.gen.pb.h>
+
+#include <future>
+
+namespace vereign {
+
+namespace restapi {
+ class ClientSession;
+}
+
+namespace service {
+namespace gen {
+
+template <class Request, class Response>
+using Result = restapi::PostResult<Request, Response>;
+
+class SignService {
+public:
+ static const std::string ServicePath;
+
+ explicit SignService(restapi::ClientSession& client_session);
+
+ SignService(const SignService&) = delete;
+ SignService& operator=(const SignService&) = delete;
+
+ using GenerateCmsForChainResult = Result<
+ const client_library::GenerateCmsForChainForm*,
+ client_library::GenerateCmsForChainFormResponse*>;
+
+ std::future<GenerateCmsForChainResult> GenerateCmsForChain(
+ const client_library::GenerateCmsForChainForm* req,
+ client_library::GenerateCmsForChainFormResponse* resp
+ );
+
+ using GenerateCmsForPassportResult = Result<
+ const client_library::GenerateCmsForPassportForm*,
+ client_library::GenerateCmsForPassportFormResponse*>;
+
+ std::future<GenerateCmsForPassportResult> GenerateCmsForPassport(
+ const client_library::GenerateCmsForPassportForm* req,
+ client_library::GenerateCmsForPassportFormResponse* resp
+ );
+
+ using ResignEmailResult = Result<
+ const client_library::ResignSMIMEForm*,
+ client_library::ResignSMIMEFormResponse*>;
+
+ std::future<ResignEmailResult> ResignEmail(
+ const client_library::ResignSMIMEForm* req,
+ client_library::ResignSMIMEFormResponse* resp
+ );
+
+ using RetrieveRootCertificateResult = Result<
+ const client_library::RetrieveRootCertificateForm*,
+ client_library::RetrieveRootCertificateFormResponse*>;
+
+ std::future<RetrieveRootCertificateResult> RetrieveRootCertificate(
+ const client_library::RetrieveRootCertificateForm* req,
+ client_library::RetrieveRootCertificateFormResponse* resp
+ );
+
+ using SignVCardForChainResult = Result<
+ const client_library::SignVCardForChainForm*,
+ client_library::SignVCardForChainFormResponse*>;
+
+ std::future<SignVCardForChainResult> SignVCardForChain(
+ const client_library::SignVCardForChainForm* req,
+ client_library::SignVCardForChainFormResponse* resp
+ );
+
+ using ValidateVMimeResult = Result<
+ const client_library::ValidateVMimeForm*,
+ client_library::ValidateVMimeFormResponse*>;
+
+ std::future<ValidateVMimeResult> ValidateVMime(
+ const client_library::ValidateVMimeForm* req,
+ client_library::ValidateVMimeFormResponse* resp
+ );
+
+private:
+ restapi::ClientSession& client_session_;
+};
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
+
+#endif // __VEREIGN_SERVICE_GEN_SIGN_SERVICE_HH
diff --git a/cpp/src/vereign/service/passport_service.hh b/cpp/src/vereign/service/passport_service.hh
index 1df27e0627fa8b70c15252e414fd5c1f0c77b2c9..f59b4b27290676e1c3ae9c5cd2b1a7714cce31b0 100644
--- a/cpp/src/vereign/service/passport_service.hh
+++ b/cpp/src/vereign/service/passport_service.hh
@@ -3,7 +3,7 @@
#include <vereign/restapi/client_session.hh>
#include <vereign/restapi/post_result.hh>
-#include <vereign/client_library/passport_types.gen.pb.h>
+#include <vereign/client_library/types.gen.pb.h>
#include <vereign/service/gen/passport_service.hh>
#include <future>
diff --git a/cpp/templates/vereign/grpc/gen/++service++_api.hh.tmpl b/cpp/templates/vereign/grpc/gen/++service++_api.hh.tmpl
new file mode 100644
index 0000000000000000000000000000000000000000..28e01d5856d10afdb8c09a84a2ba027e3cfcf07c
--- /dev/null
+++ b/cpp/templates/vereign/grpc/gen/++service++_api.hh.tmpl
@@ -0,0 +1,60 @@
+#ifndef __VEREIGN_GRPC_GEN_{{ upper .Name }}_API_HH
+#define __VEREIGN_GRPC_GEN_{{ upper .Name }}_API_HH
+
+#include <vereign/client_library/{{ .Name }}_api.gen.grpc.pb.h>
+
+namespace vereign {
+namespace grpc {
+namespace gen {
+
+{{- $class := (print (title .Name) "API") }}
+
+template <class VereignService>
+class {{ $class }} : public client_library::{{ $class }}::Service {
+public:
+ static constexpr const char* Name = "{{ .Name }}";
+
+ using VereignServiceType = VereignService;
+ using VereignServicePtr = std::unique_ptr<VereignService>;
+
+ {{ $class }}(VereignServicePtr&& service)
+ : service_{std::move(service)}
+ {}
+
+ {{ $class }}(const {{ $class }}&) = delete;
+ {{ $class }}& operator=(const {{ $class }}&) = delete;
+
+{{- range .Apis }}
+
+ ::grpc::Status {{ title .Name }}(
+ ::grpc::ServerContext*,
+ const client_library::{{ .RequestMessage }}* request,
+ client_library::{{ .ResponseMessage }}* response
+ ) override {
+ auto result_future = service_->{{ title .Name }}(request, response);
+
+ try {
+ result_future.get();
+ } catch (const std::exception& e) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error(e.what());
+ } catch (...) {
+ response->set_code("500");
+ response->set_status("Internal Service Error");
+ response->set_error("Internal Service Error");
+ }
+
+ return ::grpc::Status::OK;
+ }
+{{- end }}
+
+protected:
+ VereignServicePtr service_;
+};
+
+} // gen
+} // namespace grpc
+} // namespace vereign
+
+#endif // __VEREIGN_GRPC_GEN_{{ upper .Name }}_API_HH
diff --git a/cpp/templates/vereign/grpc/gen/gen.cc.tmpl b/cpp/templates/vereign/grpc/gen/gen.cc.tmpl
new file mode 100644
index 0000000000000000000000000000000000000000..47604c78d088720203ca6c6096770c578f4b7967
--- /dev/null
+++ b/cpp/templates/vereign/grpc/gen/gen.cc.tmpl
@@ -0,0 +1,21 @@
+#include <vereign/grpc/gen/gen.hh>
+
+#include <vereign/service/gen/gen.hh>
+#include <vereign/grpc/service_registry.hh>
+
+namespace vereign {
+namespace grpc {
+namespace gen {
+
+void RegisterAll(
+ restapi::ClientSession& client_session,
+ vereign::grpc::ServiceRegistry& service_registry
+) {
+{{- range .Services }}
+ service_registry.RegisterIfNotExist<{{ title .Name }}API<service::gen::{{ title .Name }}Service>>(client_session);
+{{- end }}
+}
+
+}
+}
+}
diff --git a/cpp/templates/vereign/grpc/gen/gen.hh.tmpl b/cpp/templates/vereign/grpc/gen/gen.hh.tmpl
new file mode 100644
index 0000000000000000000000000000000000000000..eee804a79b0b7b9cebc88361ccbeccc3239c82b1
--- /dev/null
+++ b/cpp/templates/vereign/grpc/gen/gen.hh.tmpl
@@ -0,0 +1,25 @@
+#ifndef __VEREIGN_GRPC_GEN_GEN_HH
+#define __VEREIGN_GRPC_GEN_GEN_HH
+
+{{ range .Services }}
+#include <vereign/grpc/gen/{{ .Name }}_api.hh>
+{{- end }}
+
+namespace vereign {
+namespace restapi {
+class ClientSession;
+}
+
+namespace grpc {
+
+class ServiceRegistry;
+
+namespace gen {
+
+void RegisterAll(restapi::ClientSession& client_session, grpc::ServiceRegistry& service_registry);
+
+} // namespace gen
+} // namespace grpc
+} // namespace vereign
+
+#endif // __VEREIGN_GRPC_GEN_GEN_HH
diff --git a/cpp/templates/vereign/service/gen/++service++_service.cc.tmpl b/cpp/templates/vereign/service/gen/++service++_service.cc.tmpl
new file mode 100644
index 0000000000000000000000000000000000000000..93c489c83aedff604a74d860d42ea46936ef5d22
--- /dev/null
+++ b/cpp/templates/vereign/service/gen/++service++_service.cc.tmpl
@@ -0,0 +1,39 @@
+#include <vereign/service/gen/{{ .Name }}_service.hh>
+#include <vereign/restapi/client_session.hh>
+
+namespace {
+{{- range .Apis }}
+ const std::string {{ .Name }}Path = "{{ .Name }}";
+{{- end }}
+}
+
+namespace vereign {
+namespace service {
+namespace gen {
+
+{{- $class := (print (title .Name) "Service") }}
+
+const std::string {{ $class }}::ServicePath = "/{{ .Name }}/";
+
+{{ $class }}::{{ $class }}(restapi::ClientSession& client_session)
+ : client_session_{client_session}
+{}
+
+{{- range .Apis }}
+
+std::future<{{ $class }}::{{ title .Name }}Result>
+{{ $class }}::{{ title .Name }}(
+ const client_library::{{ .RequestMessage }}* req,
+ client_library::{{ .ResponseMessage }}* resp
+) {
+ return client_session_.Post(
+ ServicePath + {{ .Name }}Path,
+ req,
+ resp
+ );
+}
+{{- end }}
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
diff --git a/cpp/templates/vereign/service/gen/++service++_service.hh.tmpl b/cpp/templates/vereign/service/gen/++service++_service.hh.tmpl
new file mode 100644
index 0000000000000000000000000000000000000000..698f1f33f1ed5441734ae977a7a3344e7f4e26b5
--- /dev/null
+++ b/cpp/templates/vereign/service/gen/++service++_service.hh.tmpl
@@ -0,0 +1,53 @@
+#ifndef __VEREIGN_SERVICE_GEN_{{ upper .Name }}_SERVICE_HH
+#define __VEREIGN_SERVICE_GEN_{{ upper .Name }}_SERVICE_HH
+
+#include <vereign/restapi/client_session.hh>
+#include <vereign/restapi/post_result.hh>
+#include <vereign/client_library/types.gen.pb.h>
+
+#include <future>
+
+namespace vereign {
+
+namespace restapi {
+ class ClientSession;
+}
+
+namespace service {
+namespace gen {
+
+template <class Request, class Response>
+using Result = restapi::PostResult<Request, Response>;
+
+{{- $class := (print (title .Name) "Service") }}
+
+class {{ $class }} {
+public:
+ static const std::string ServicePath;
+
+ explicit {{ $class }}(restapi::ClientSession& client_session);
+
+ {{ $class }}(const {{ $class }}&) = delete;
+ {{ $class }}& operator=(const {{ $class }}&) = delete;
+
+{{- range .Apis }}
+
+ using {{ title .Name }}Result = Result<
+ const client_library::{{ .RequestMessage }}*,
+ client_library::{{ .ResponseMessage }}*>;
+
+ std::future<{{ title .Name }}Result> {{ title .Name }}(
+ const client_library::{{ .RequestMessage }}* req,
+ client_library::{{ .ResponseMessage }}* resp
+ );
+{{- end }}
+
+private:
+ restapi::ClientSession& client_session_;
+};
+
+} // namespace gen
+} // namespace service
+} // namespace vereign
+
+#endif // __VEREIGN_SERVICE_GEN_{{ upper .Name }}_SERVICE_HH
diff --git a/cpp/templates/vereign/service/gen/gen.hh.tmpl b/cpp/templates/vereign/service/gen/gen.hh.tmpl
new file mode 100644
index 0000000000000000000000000000000000000000..9f6d6a8ca96d80b9f2ba9cbf26c790a4ac383e38
--- /dev/null
+++ b/cpp/templates/vereign/service/gen/gen.hh.tmpl
@@ -0,0 +1,8 @@
+#ifndef __VEREIGN_SERVICE_GEN_GEN_HH
+#define __VEREIGN_SERVICE_GEN_GEN_HH
+
+{{ range .Services }}
+#include <vereign/service/gen/{{ .Name }}_service.hh>
+{{- end }}
+
+#endif // __VEREIGN_SERVICE_GEN_GEN_HH
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/CMakeLists.txt b/cpp/tests/protobuf/CMakeLists.txt
index 27d205c3a5f8d59c94410513b711a58c2cdb37a6..a23b8ac172bb5a4ec1eee0e84fbaed4bc70623b1 100644
--- a/cpp/tests/protobuf/CMakeLists.txt
+++ b/cpp/tests/protobuf/CMakeLists.txt
@@ -30,14 +30,6 @@ target_link_libraries(protobuf_tests ${LIBS}
PRIVATE protobuf::libprotobuf
)
-#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_test(
NAME protobuf_tests
COMMAND protobuf_tests
diff --git a/cpp/tests/protobuf/json_test.cc b/cpp/tests/protobuf/json_test.cc
index 9ec89317d3ff13ff734bbedac09a4b6aa06ac31d..9fbc9988807257b0e8b1cbafdab696a4ed2f28ab 100644
--- a/cpp/tests/protobuf/json_test.cc
+++ b/cpp/tests/protobuf/json_test.cc
@@ -1,22 +1,23 @@
-#include "catch.hpp"
+#include <catch2/catch.hpp>
#include <google/protobuf/util/json_util.h>
#include <testpb/messages.pb.h>
TEST_CASE("simple struct", "[protobuf]") {
auto json = R"(
{
- "int_value": 42,
+ "int_value": 9223372036854775807,
"string_value": "foo bar",
"int_arr": [4, 2],
"string_arr": ["foo", "bar", "baz"],
"int_map": {
- "foo": 4,
- "bar": 2,
+ "42": 4,
+ "72": 2,
},
"string_map": {
"foo": "foo_value",
"bar": "bar_value"
- }
+ },
+ "double_value": 42
}
)";
@@ -28,7 +29,7 @@ TEST_CASE("simple struct", "[protobuf]") {
CHECK(status.error_message() == "");
REQUIRE(status.ok());
CHECK(msg.string_value() == "foo bar");
- CHECK(msg.int_value() == 42);
+ CHECK(msg.int_value() == 9223372036854775807);
CHECK(msg.int_arr().size() == 2);
CHECK(msg.int_arr().Get(0) == 4);
CHECK(msg.int_arr().Get(1) == 2);
@@ -43,12 +44,55 @@ 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");
CHECK(msg.string_map().at("bar") == "bar_value");
+ 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"(
+{
+ arr: [
+ {
+ str_arr: ["foo", "bar"]
+ }
+ ]
+}
+)";
+
+ testproto::TwoDimensionalArray msg;
+
+ google::protobuf::util::JsonParseOptions options;
+ auto status = google::protobuf::util::JsonStringToMessage(json, &msg, options);
+
+ CHECK(status.error_message() == "");
+ REQUIRE(status.ok());
+ REQUIRE(msg.arr().size() == 1);
+ REQUIRE(msg.arr().at(0).str_arr().size() == 2);
+ REQUIRE(msg.arr().at(0).str_arr().at(0) == "foo");
+ REQUIRE(msg.arr().at(0).str_arr().at(1) == "bar");
}
TEST_CASE("invalid json", "[protobuf]") {
@@ -97,6 +141,42 @@ TEST_CASE("null/missing integer value", "[protobuf]") {
REQUIRE(msg.int_value() == 0);
}
+TEST_CASE("json marshal double", "[protobuf]") {
+ testproto::SimpleStruct msg;
+ msg.set_double_value(42);
+
+ std::string json;
+ google::protobuf::util::JsonOptions options;
+ options.add_whitespace = true;
+ options.preserve_proto_field_names = true;
+ options.always_print_enums_as_ints = true;
+ auto status = google::protobuf::util::MessageToJsonString(msg, &json, options);
+ auto expected = R"({
+ "double_value": 42
+}
+)";
+
+ REQUIRE(json == expected);
+}
+
+TEST_CASE("json marshal uint64", "[protobuf]") {
+ testproto::SimpleStruct msg;
+ msg.set_uint64_value(42);
+
+ std::string json;
+ google::protobuf::util::JsonOptions options;
+ options.add_whitespace = true;
+ options.preserve_proto_field_names = true;
+ options.always_print_enums_as_ints = true;
+ auto status = google::protobuf::util::MessageToJsonString(msg, &json, options);
+ auto expected = R"({
+ "uint64_value": "42"
+}
+)";
+
+ REQUIRE(json == expected);
+}
+
TEST_CASE("json marshal naming", "[protobuf]") {
testproto::JsonNaming msg;
msg.set_foo_value(1);
@@ -240,18 +320,19 @@ TEST_CASE("oneof marshal", "[protobuf]") {
CHECK(json == expected);
}
- SECTION("marshal test") {
- testproto::OneofValue msg;
- msg.mutable_struct_value()->set_int_value(42);
- google::protobuf::util::JsonPrintOptions options;
- options.preserve_proto_field_names = true;
- std::string json;
- auto status = google::protobuf::util::MessageToJsonString(msg, &json, options);
+}
- auto expected = R"({"struct_value":{"int_value":"42"}})";
+TEST_CASE("empty messages with OmitEmpty", "[protobuf]") {
+ testproto::MessageType msg;
+ msg.add_foo_arr();
- CHECK(status.error_message() == "");
- REQUIRE(status.ok());
- CHECK(json == expected);
- }
+ google::protobuf::util::JsonPrintOptions options;
+ options.preserve_proto_field_names = true;
+ options.always_print_primitive_fields = false;
+ 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 70f4b46a0e566a6a7d8d1c1d263d595836fed604..1b036cbfc30330bcb4e972ea4fea56d8c5b2b3af 100644
--- a/cpp/tests/protobuf/proto/messages.proto
+++ b/cpp/tests/protobuf/proto/messages.proto
@@ -7,8 +7,24 @@ 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 {
@@ -25,3 +41,14 @@ message OneofValue {
}
}
+message StringArray {
+ repeated string str_arr = 1;
+}
+
+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 28f1084d3a0416d5c1115e00614a0437eea56010..6d9de6ebdab26d1ce4eb4c989fca1f698e3f6df5 100644
--- a/cpp/tests/protobuf/testpb/messages.pb.cc
+++ b/cpp/tests/protobuf/testpb/messages.pb.cc
@@ -14,9 +14,12 @@
#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;
+extern PROTOBUF_INTERNAL_EXPORT_messages_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_StringArray_messages_2eproto;
namespace testproto {
class SimpleStruct_IntMapEntry_DoNotUseDefaultTypeInternal {
public:
@@ -30,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;
@@ -40,7 +55,62 @@ class OneofValueDefaultTypeInternal {
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_value_;
const ::testproto::SimpleStruct* struct_value_;
} _OneofValue_default_instance_;
+class StringArrayDefaultTypeInternal {
+ public:
+ ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<StringArray> _instance;
+} _StringArray_default_instance_;
+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;
@@ -55,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;
@@ -112,7 +197,36 @@ static void InitDefaultsscc_info_SimpleStruct_StringMapEntry_DoNotUse_messages_2
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_SimpleStruct_StringMapEntry_DoNotUse_messages_2eproto =
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_SimpleStruct_StringMapEntry_DoNotUse_messages_2eproto}, {}};
-static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_messages_2eproto[5];
+static void InitDefaultsscc_info_StringArray_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::testproto::_StringArray_default_instance_;
+ new (ptr) ::testproto::StringArray();
+ ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+ }
+ ::testproto::StringArray::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_StringArray_messages_2eproto =
+ {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_StringArray_messages_2eproto}, {}};
+
+static void InitDefaultsscc_info_TwoDimensionalArray_messages_2eproto() {
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ {
+ void* ptr = &::testproto::_TwoDimensionalArray_default_instance_;
+ new (ptr) ::testproto::TwoDimensionalArray();
+ ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+ }
+ ::testproto::TwoDimensionalArray::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_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[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;
@@ -146,6 +260,28 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_messages_2eproto::offsets[] PR
PROTOBUF_FIELD_OFFSET(::testproto::SimpleStruct, string_arr_),
PROTOBUF_FIELD_OFFSET(::testproto::SimpleStruct, int_map_),
PROTOBUF_FIELD_OFFSET(::testproto::SimpleStruct, string_map_),
+ 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_
@@ -163,55 +299,99 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_messages_2eproto::offsets[] PR
offsetof(::testproto::OneofValueDefaultTypeInternal, string_value_),
offsetof(::testproto::OneofValueDefaultTypeInternal, struct_value_),
PROTOBUF_FIELD_OFFSET(::testproto::OneofValue, data_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::testproto::StringArray, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::testproto::StringArray, str_arr_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::testproto::TwoDimensionalArray, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~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)},
- { 29, -1, sizeof(::testproto::JsonNaming)},
- { 38, -1, sizeof(::testproto::OneofValue)},
+ { 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) =
- "\n\016messages.proto\022\ttestproto\"\257\002\n\014SimpleSt"
+ "\n\016messages.proto\022\ttestproto\"\333\002\n\014SimpleSt"
"ruct\022\021\n\tint_value\030\001 \001(\003\022\024\n\014string_value\030"
"\002 \001(\t\022\017\n\007int_arr\030\003 \003(\003\022\022\n\nstring_arr\030\004 \003"
"(\t\0224\n\007int_map\030\005 \003(\0132#.testproto.SimpleSt"
"ruct.IntMapEntry\022:\n\nstring_map\030\006 \003(\0132&.t"
- "estproto.SimpleStruct.StringMapEntry\032-\n\013"
- "IntMapEntry\022\013\n\003key\030\001 \001(\t\022\r\n\005value\030\002 \001(\005:"
- "\0028\001\0320\n\016StringMapEntry\022\013\n\003key\030\001 \001(\t\022\r\n\005va"
- "lue\030\002 \001(\t:\0028\001\"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\tquX_Value\030\004 \001(\002\"]\n\nOneofValue\022\026\n\014s"
- "tring_value\030\001 \001(\tH\000\022/\n\014struct_value\030\002 \001("
- "\0132\027.testproto.SimpleStructH\000B\006\n\004datab\006pr"
+ "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(\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\"\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[5] = {
+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,
&scc_info_SimpleStruct_StringMapEntry_DoNotUse_messages_2eproto.base,
+ &scc_info_StringArray_messages_2eproto.base,
+ &scc_info_TwoDimensionalArray_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", 524,
- &descriptor_table_messages_2eproto_once, descriptor_table_messages_2eproto_sccs, descriptor_table_messages_2eproto_deps, 5, 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, 5, 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.
@@ -277,14 +457,18 @@ SimpleStruct::SimpleStruct(const SimpleStruct& from)
if (!from._internal_string_value().empty()) {
string_value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.string_value_);
}
- int_value_ = from.int_value_;
+ ::memcpy(&int_value_, &from.int_value_,
+ static_cast<size_t>(reinterpret_cast<char*>(&uint64_value_) -
+ reinterpret_cast<char*>(&int_value_)) + sizeof(uint64_value_));
// @@protoc_insertion_point(copy_constructor:testproto.SimpleStruct)
}
void SimpleStruct::SharedCtor() {
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SimpleStruct_messages_2eproto.base);
string_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- int_value_ = PROTOBUF_LONGLONG(0);
+ ::memset(&int_value_, 0, static_cast<size_t>(
+ reinterpret_cast<char*>(&uint64_value_) -
+ reinterpret_cast<char*>(&int_value_)) + sizeof(uint64_value_));
}
SimpleStruct::~SimpleStruct() {
@@ -316,7 +500,9 @@ void SimpleStruct::Clear() {
int_map_.Clear();
string_map_.Clear();
string_value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- int_value_ = PROTOBUF_LONGLONG(0);
+ ::memset(&int_value_, 0, static_cast<size_t>(
+ reinterpret_cast<char*>(&uint64_value_) -
+ reinterpret_cast<char*>(&int_value_)) + sizeof(uint64_value_));
_internal_metadata_.Clear();
}
@@ -367,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;
@@ -391,6 +577,20 @@ const char* SimpleStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I
} while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr));
} else goto handle_unusual;
continue;
+ // double double_value = 7;
+ case 7:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 57)) {
+ double_value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
+ ptr += sizeof(double);
+ } else goto handle_unusual;
+ continue;
+ // uint64 uint64_value = 8;
+ case 8:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) {
+ uint64_value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
@@ -452,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));
}
}
}
@@ -538,6 +728,18 @@ 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);
+ }
+
+ // 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);
@@ -577,10 +779,10 @@ size_t SimpleStruct::ByteSizeLong() const {
string_arr_.Get(i));
}
- // map<string, int32> int_map = 5;
+ // map<int32, 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
+ 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);
@@ -609,6 +811,18 @@ size_t SimpleStruct::ByteSizeLong() const {
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_);
@@ -651,6 +865,12 @@ void SimpleStruct::MergeFrom(const SimpleStruct& from) {
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) {
@@ -681,6 +901,8 @@ void SimpleStruct::InternalSwap(SimpleStruct* other) {
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 {
@@ -690,95 +912,75 @@ void SimpleStruct::InternalSwap(SimpleStruct* other) {
// ===================================================================
-void JsonNaming::InitAsDefaultInstance() {
+void Bar::InitAsDefaultInstance() {
}
-class JsonNaming::_Internal {
+class Bar::_Internal {
public:
};
-JsonNaming::JsonNaming()
+Bar::Bar()
: ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
SharedCtor();
- // @@protoc_insertion_point(constructor:testproto.JsonNaming)
+ // @@protoc_insertion_point(constructor:testproto.Bar)
}
-JsonNaming::JsonNaming(const JsonNaming& from)
+Bar::Bar(const Bar& 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:testproto.JsonNaming)
+ 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 JsonNaming::SharedCtor() {
- ::memset(&foo_value_, 0, static_cast<size_t>(
- reinterpret_cast<char*>(&qux_value_) -
- reinterpret_cast<char*>(&foo_value_)) + sizeof(qux_value_));
+void Bar::SharedCtor() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Bar_messages_2eproto.base);
+ value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
-JsonNaming::~JsonNaming() {
- // @@protoc_insertion_point(destructor:testproto.JsonNaming)
+Bar::~Bar() {
+ // @@protoc_insertion_point(destructor:testproto.Bar)
SharedDtor();
}
-void JsonNaming::SharedDtor() {
+void Bar::SharedDtor() {
+ value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
-void JsonNaming::SetCachedSize(int size) const {
+void Bar::SetCachedSize(int size) const {
_cached_size_.Set(size);
}
-const JsonNaming& JsonNaming::default_instance() {
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_JsonNaming_messages_2eproto.base);
+const Bar& Bar::default_instance() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Bar_messages_2eproto.base);
return *internal_default_instance();
}
-void JsonNaming::Clear() {
-// @@protoc_insertion_point(message_clear_start:testproto.JsonNaming)
+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;
- ::memset(&foo_value_, 0, static_cast<size_t>(
- reinterpret_cast<char*>(&qux_value_) -
- reinterpret_cast<char*>(&foo_value_)) + sizeof(qux_value_));
+ value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
_internal_metadata_.Clear();
}
-const char* JsonNaming::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+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) {
- // float foo_value = 1;
- case 1:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
- foo_value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
- ptr += sizeof(float);
- } else goto handle_unusual;
- continue;
- // float barValue = 2;
+ // string value = 2;
case 2:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
- barvalue_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
- ptr += sizeof(float);
- } else goto handle_unusual;
- continue;
- // float BazValue = 3;
- case 3:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) {
- bazvalue_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
- ptr += sizeof(float);
- } else goto handle_unusual;
- continue;
- // float quX_Value = 4;
- case 4:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37)) {
- qux_value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
- ptr += sizeof(float);
+ 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: {
@@ -801,70 +1003,43 @@ failure:
#undef CHK_
}
-::PROTOBUF_NAMESPACE_ID::uint8* JsonNaming::_InternalSerialize(
+::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.JsonNaming)
+ // @@protoc_insertion_point(serialize_to_array_start:testproto.Bar)
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
(void) cached_has_bits;
- // float foo_value = 1;
- if (!(this->foo_value() <= 0 && this->foo_value() >= 0)) {
- target = stream->EnsureSpace(target);
- target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_foo_value(), target);
- }
-
- // float barValue = 2;
- if (!(this->barvalue() <= 0 && this->barvalue() >= 0)) {
- target = stream->EnsureSpace(target);
- target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_barvalue(), target);
- }
-
- // float BazValue = 3;
- if (!(this->bazvalue() <= 0 && this->bazvalue() >= 0)) {
- target = stream->EnsureSpace(target);
- target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_bazvalue(), target);
- }
-
- // float quX_Value = 4;
- if (!(this->qux_value() <= 0 && this->qux_value() >= 0)) {
- target = stream->EnsureSpace(target);
- target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->_internal_qux_value(), target);
+ // 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.JsonNaming)
+ // @@protoc_insertion_point(serialize_to_array_end:testproto.Bar)
return target;
}
-size_t JsonNaming::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:testproto.JsonNaming)
+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;
- // float foo_value = 1;
- if (!(this->foo_value() <= 0 && this->foo_value() >= 0)) {
- total_size += 1 + 4;
- }
-
- // float barValue = 2;
- if (!(this->barvalue() <= 0 && this->barvalue() >= 0)) {
- total_size += 1 + 4;
- }
-
- // float BazValue = 3;
- if (!(this->bazvalue() <= 0 && this->bazvalue() >= 0)) {
- total_size += 1 + 4;
- }
-
- // float quX_Value = 4;
- if (!(this->qux_value() <= 0 && this->qux_value() >= 0)) {
- total_size += 1 + 4;
+ // 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())) {
@@ -876,205 +1051,1543 @@ size_t JsonNaming::ByteSizeLong() const {
return total_size;
}
-void JsonNaming::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:testproto.JsonNaming)
+void Bar::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:testproto.Bar)
GOOGLE_DCHECK_NE(&from, this);
- const JsonNaming* source =
- ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<JsonNaming>(
+ const Bar* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Bar>(
&from);
if (source == nullptr) {
- // @@protoc_insertion_point(generalized_merge_from_cast_fail:testproto.JsonNaming)
+ // @@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.JsonNaming)
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:testproto.Bar)
MergeFrom(*source);
}
}
-void JsonNaming::MergeFrom(const JsonNaming& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:testproto.JsonNaming)
+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.foo_value() <= 0 && from.foo_value() >= 0)) {
- _internal_set_foo_value(from._internal_foo_value());
- }
- if (!(from.barvalue() <= 0 && from.barvalue() >= 0)) {
- _internal_set_barvalue(from._internal_barvalue());
- }
- if (!(from.bazvalue() <= 0 && from.bazvalue() >= 0)) {
- _internal_set_bazvalue(from._internal_bazvalue());
- }
- if (!(from.qux_value() <= 0 && from.qux_value() >= 0)) {
- _internal_set_qux_value(from._internal_qux_value());
+ if (from.value().size() > 0) {
+
+ value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.value_);
}
}
-void JsonNaming::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:testproto.JsonNaming)
+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 JsonNaming::CopyFrom(const JsonNaming& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:testproto.JsonNaming)
+void Bar::CopyFrom(const Bar& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:testproto.Bar)
if (&from == this) return;
Clear();
MergeFrom(from);
}
-bool JsonNaming::IsInitialized() const {
+bool Bar::IsInitialized() const {
return true;
}
-void JsonNaming::InternalSwap(JsonNaming* other) {
+void Bar::InternalSwap(Bar* 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_);
+ value_.Swap(&other->value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ GetArenaNoVirtual());
}
-::PROTOBUF_NAMESPACE_ID::Metadata JsonNaming::GetMetadata() const {
+::PROTOBUF_NAMESPACE_ID::Metadata Bar::GetMetadata() const {
return GetMetadataStatic();
}
// ===================================================================
-void OneofValue::InitAsDefaultInstance() {
- ::testproto::_OneofValue_default_instance_.string_value_.UnsafeSetDefault(
- &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- ::testproto::_OneofValue_default_instance_.struct_value_ = const_cast< ::testproto::SimpleStruct*>(
- ::testproto::SimpleStruct::internal_default_instance());
+void Foo::InitAsDefaultInstance() {
+ ::testproto::_Foo_default_instance_._instance.get_mutable()->bar_ = const_cast< ::testproto::Bar*>(
+ ::testproto::Bar::internal_default_instance());
}
-class OneofValue::_Internal {
+class Foo::_Internal {
public:
- static const ::testproto::SimpleStruct& struct_value(const OneofValue* msg);
+ static const ::testproto::Bar& bar(const Foo* msg);
};
-const ::testproto::SimpleStruct&
-OneofValue::_Internal::struct_value(const OneofValue* msg) {
- return *msg->data_.struct_value_;
+const ::testproto::Bar&
+Foo::_Internal::bar(const Foo* msg) {
+ return *msg->bar_;
}
-void OneofValue::set_allocated_struct_value(::testproto::SimpleStruct* struct_value) {
- ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
- clear_data();
+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);
+ }
+
+ // 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::
+ 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.MessageType)
+ return target;
+}
+
+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 .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);
+ }
+
+ // .testproto.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:testproto.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:testproto.MessageType)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:testproto.MessageType)
+ MergeFrom(*source);
+ }
+}
+
+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;
+
+ foo_arr_.MergeFrom(from.foo_arr_);
+ if (from.has_foo()) {
+ _internal_mutable_foo()->::testproto::Foo::MergeFrom(from._internal_foo());
+ }
+}
+
+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 MessageType::CopyFrom(const MessageType& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:testproto.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();
+}
+
+
+// ===================================================================
+
+void JsonNaming::InitAsDefaultInstance() {
+}
+class JsonNaming::_Internal {
+ public:
+};
+
+JsonNaming::JsonNaming()
+ : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+ SharedCtor();
+ // @@protoc_insertion_point(constructor:testproto.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:testproto.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:testproto.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:testproto.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) {
+ // float foo_value = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
+ foo_value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else goto handle_unusual;
+ continue;
+ // float barValue = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
+ barvalue_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else goto handle_unusual;
+ continue;
+ // float BazValue = 3;
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) {
+ bazvalue_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else goto handle_unusual;
+ continue;
+ // float quX_Value = 4;
+ case 4:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37)) {
+ qux_value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } 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:testproto.JsonNaming)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // float foo_value = 1;
+ if (!(this->foo_value() <= 0 && this->foo_value() >= 0)) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_foo_value(), target);
+ }
+
+ // float barValue = 2;
+ if (!(this->barvalue() <= 0 && this->barvalue() >= 0)) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_barvalue(), target);
+ }
+
+ // float BazValue = 3;
+ if (!(this->bazvalue() <= 0 && this->bazvalue() >= 0)) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_bazvalue(), target);
+ }
+
+ // float quX_Value = 4;
+ if (!(this->qux_value() <= 0 && this->qux_value() >= 0)) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(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:testproto.JsonNaming)
+ return target;
+}
+
+size_t JsonNaming::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:testproto.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;
+
+ // float foo_value = 1;
+ if (!(this->foo_value() <= 0 && this->foo_value() >= 0)) {
+ total_size += 1 + 4;
+ }
+
+ // float barValue = 2;
+ if (!(this->barvalue() <= 0 && this->barvalue() >= 0)) {
+ total_size += 1 + 4;
+ }
+
+ // float BazValue = 3;
+ if (!(this->bazvalue() <= 0 && this->bazvalue() >= 0)) {
+ total_size += 1 + 4;
+ }
+
+ // float quX_Value = 4;
+ if (!(this->qux_value() <= 0 && this->qux_value() >= 0)) {
+ total_size += 1 + 4;
+ }
+
+ 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:testproto.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:testproto.JsonNaming)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:testproto.JsonNaming)
+ MergeFrom(*source);
+ }
+}
+
+void JsonNaming::MergeFrom(const JsonNaming& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:testproto.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 && from.foo_value() >= 0)) {
+ _internal_set_foo_value(from._internal_foo_value());
+ }
+ if (!(from.barvalue() <= 0 && from.barvalue() >= 0)) {
+ _internal_set_barvalue(from._internal_barvalue());
+ }
+ if (!(from.bazvalue() <= 0 && from.bazvalue() >= 0)) {
+ _internal_set_bazvalue(from._internal_bazvalue());
+ }
+ if (!(from.qux_value() <= 0 && 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:testproto.JsonNaming)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void JsonNaming::CopyFrom(const JsonNaming& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:testproto.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() {
+ ::testproto::_OneofValue_default_instance_.string_value_.UnsafeSetDefault(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ ::testproto::_OneofValue_default_instance_.struct_value_ = const_cast< ::testproto::SimpleStruct*>(
+ ::testproto::SimpleStruct::internal_default_instance());
+}
+class OneofValue::_Internal {
+ public:
+ static const ::testproto::SimpleStruct& struct_value(const OneofValue* msg);
+};
+
+const ::testproto::SimpleStruct&
+OneofValue::_Internal::struct_value(const OneofValue* msg) {
+ return *msg->data_.struct_value_;
+}
+void OneofValue::set_allocated_struct_value(::testproto::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;
+ set_has_struct_value();
+ data_.struct_value_ = struct_value;
+ }
+ // @@protoc_insertion_point(field_set_allocated:testproto.OneofValue.struct_value)
+}
+OneofValue::OneofValue()
+ : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+ SharedCtor();
+ // @@protoc_insertion_point(constructor:testproto.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()->::testproto::SimpleStruct::MergeFrom(from._internal_struct_value());
+ break;
+ }
+ case DATA_NOT_SET: {
+ break;
+ }
+ }
+ // @@protoc_insertion_point(copy_constructor:testproto.OneofValue)
+}
+
+void OneofValue::SharedCtor() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_OneofValue_messages_2eproto.base);
+ clear_has_data();
+}
+
+OneofValue::~OneofValue() {
+ // @@protoc_insertion_point(destructor:testproto.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:testproto.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:testproto.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, "testproto.OneofValue.string_value"));
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // .testproto.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:testproto.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,
+ "testproto.OneofValue.string_value");
+ target = stream->WriteStringMaybeAliased(
+ 1, this->_internal_string_value(), target);
+ }
+
+ // .testproto.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:testproto.OneofValue)
+ return target;
+}
+
+size_t OneofValue::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:testproto.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;
+ }
+ // .testproto.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:testproto.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:testproto.OneofValue)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:testproto.OneofValue)
+ MergeFrom(*source);
+ }
+}
+
+void OneofValue::MergeFrom(const OneofValue& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:testproto.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()->::testproto::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:testproto.OneofValue)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void OneofValue::CopyFrom(const OneofValue& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:testproto.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 StringArray::InitAsDefaultInstance() {
+}
+class StringArray::_Internal {
+ public:
+};
+
+StringArray::StringArray()
+ : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+ SharedCtor();
+ // @@protoc_insertion_point(constructor:testproto.StringArray)
+}
+StringArray::StringArray(const StringArray& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message(),
+ _internal_metadata_(nullptr),
+ str_arr_(from.str_arr_) {
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ // @@protoc_insertion_point(copy_constructor:testproto.StringArray)
+}
+
+void StringArray::SharedCtor() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_StringArray_messages_2eproto.base);
+}
+
+StringArray::~StringArray() {
+ // @@protoc_insertion_point(destructor:testproto.StringArray)
+ SharedDtor();
+}
+
+void StringArray::SharedDtor() {
+}
+
+void StringArray::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+const StringArray& StringArray::default_instance() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_StringArray_messages_2eproto.base);
+ return *internal_default_instance();
+}
+
+
+void StringArray::Clear() {
+// @@protoc_insertion_point(message_clear_start:testproto.StringArray)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ str_arr_.Clear();
+ _internal_metadata_.Clear();
+}
+
+const char* StringArray::_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 string str_arr = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ auto str = _internal_add_str_arr();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "testproto.StringArray.str_arr"));
+ 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* StringArray::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:testproto.StringArray)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // repeated string str_arr = 1;
+ for (int i = 0, n = this->_internal_str_arr_size(); i < n; i++) {
+ const auto& s = this->_internal_str_arr(i);
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ s.data(), static_cast<int>(s.length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "testproto.StringArray.str_arr");
+ target = stream->WriteString(1, 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:testproto.StringArray)
+ return target;
+}
+
+size_t StringArray::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:testproto.StringArray)
+ 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 string str_arr = 1;
+ total_size += 1 *
+ ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(str_arr_.size());
+ for (int i = 0, n = str_arr_.size(); i < n; i++) {
+ total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ str_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 StringArray::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:testproto.StringArray)
+ GOOGLE_DCHECK_NE(&from, this);
+ const StringArray* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<StringArray>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:testproto.StringArray)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:testproto.StringArray)
+ MergeFrom(*source);
+ }
+}
+
+void StringArray::MergeFrom(const StringArray& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:testproto.StringArray)
+ GOOGLE_DCHECK_NE(&from, this);
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ str_arr_.MergeFrom(from.str_arr_);
+}
+
+void StringArray::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:testproto.StringArray)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void StringArray::CopyFrom(const StringArray& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:testproto.StringArray)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool StringArray::IsInitialized() const {
+ return true;
+}
+
+void StringArray::InternalSwap(StringArray* other) {
+ using std::swap;
+ _internal_metadata_.Swap(&other->_internal_metadata_);
+ str_arr_.InternalSwap(&other->str_arr_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata StringArray::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void TwoDimensionalArray::InitAsDefaultInstance() {
+}
+class TwoDimensionalArray::_Internal {
+ public:
+};
+
+TwoDimensionalArray::TwoDimensionalArray()
+ : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+ SharedCtor();
+ // @@protoc_insertion_point(constructor:testproto.TwoDimensionalArray)
+}
+TwoDimensionalArray::TwoDimensionalArray(const TwoDimensionalArray& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message(),
+ _internal_metadata_(nullptr),
+ arr_(from.arr_) {
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ // @@protoc_insertion_point(copy_constructor:testproto.TwoDimensionalArray)
+}
+
+void TwoDimensionalArray::SharedCtor() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TwoDimensionalArray_messages_2eproto.base);
+}
+
+TwoDimensionalArray::~TwoDimensionalArray() {
+ // @@protoc_insertion_point(destructor:testproto.TwoDimensionalArray)
+ SharedDtor();
+}
+
+void TwoDimensionalArray::SharedDtor() {
+}
+
+void TwoDimensionalArray::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+const TwoDimensionalArray& TwoDimensionalArray::default_instance() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TwoDimensionalArray_messages_2eproto.base);
+ return *internal_default_instance();
+}
+
+
+void TwoDimensionalArray::Clear() {
+// @@protoc_insertion_point(message_clear_start:testproto.TwoDimensionalArray)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ arr_.Clear();
+ _internal_metadata_.Clear();
+}
+
+const char* TwoDimensionalArray::_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 .testproto.StringArray arr = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ ptr = ctx->ParseMessage(_internal_add_arr(), 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* TwoDimensionalArray::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:testproto.TwoDimensionalArray)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // repeated .testproto.StringArray arr = 1;
+ for (unsigned int i = 0,
+ n = static_cast<unsigned int>(this->_internal_arr_size()); i < n; i++) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(1, this->_internal_arr(i), target, stream);
}
- // @@protoc_insertion_point(field_set_allocated:testproto.OneofValue.struct_value)
+
+ 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.TwoDimensionalArray)
+ return target;
}
-OneofValue::OneofValue()
+
+size_t TwoDimensionalArray::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:testproto.TwoDimensionalArray)
+ 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 .testproto.StringArray arr = 1;
+ total_size += 1UL * this->_internal_arr_size();
+ for (const auto& msg : this->arr_) {
+ total_size +=
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+ }
+
+ 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 TwoDimensionalArray::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:testproto.TwoDimensionalArray)
+ GOOGLE_DCHECK_NE(&from, this);
+ const TwoDimensionalArray* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<TwoDimensionalArray>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:testproto.TwoDimensionalArray)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:testproto.TwoDimensionalArray)
+ MergeFrom(*source);
+ }
+}
+
+void TwoDimensionalArray::MergeFrom(const TwoDimensionalArray& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:testproto.TwoDimensionalArray)
+ GOOGLE_DCHECK_NE(&from, this);
+ _internal_metadata_.MergeFrom(from._internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ arr_.MergeFrom(from.arr_);
+}
+
+void TwoDimensionalArray::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:testproto.TwoDimensionalArray)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void TwoDimensionalArray::CopyFrom(const TwoDimensionalArray& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:testproto.TwoDimensionalArray)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool TwoDimensionalArray::IsInitialized() const {
+ return true;
+}
+
+void TwoDimensionalArray::InternalSwap(TwoDimensionalArray* other) {
+ using std::swap;
+ _internal_metadata_.Swap(&other->_internal_metadata_);
+ arr_.InternalSwap(&other->arr_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata TwoDimensionalArray::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:testproto.OneofValue)
+ // @@protoc_insertion_point(constructor:testproto.BytesType)
}
-OneofValue::OneofValue(const OneofValue& from)
+BytesType::BytesType(const BytesType& 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()->::testproto::SimpleStruct::MergeFrom(from._internal_struct_value());
- break;
- }
- case DATA_NOT_SET: {
- break;
- }
+ 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.OneofValue)
+ // @@protoc_insertion_point(copy_constructor:testproto.BytesType)
}
-void OneofValue::SharedCtor() {
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_OneofValue_messages_2eproto.base);
- clear_has_data();
+void BytesType::SharedCtor() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_BytesType_messages_2eproto.base);
+ bytes_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
-OneofValue::~OneofValue() {
- // @@protoc_insertion_point(destructor:testproto.OneofValue)
+BytesType::~BytesType() {
+ // @@protoc_insertion_point(destructor:testproto.BytesType)
SharedDtor();
}
-void OneofValue::SharedDtor() {
- if (has_data()) {
- clear_data();
- }
+void BytesType::SharedDtor() {
+ bytes_value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
-void OneofValue::SetCachedSize(int size) const {
+void BytesType::SetCachedSize(int size) const {
_cached_size_.Set(size);
}
-const OneofValue& OneofValue::default_instance() {
- ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_OneofValue_messages_2eproto.base);
+const BytesType& BytesType::default_instance() {
+ ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_BytesType_messages_2eproto.base);
return *internal_default_instance();
}
-void OneofValue::clear_data() {
-// @@protoc_insertion_point(one_of_clear_start:testproto.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:testproto.OneofValue)
+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;
- clear_data();
+ bytes_value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
_internal_metadata_.Clear();
}
-const char* OneofValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+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) {
- // string string_value = 1;
+ // bytes bytes_value = 1;
case 1:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
- auto str = _internal_mutable_string_value();
+ auto str = _internal_mutable_bytes_value();
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
- CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "testproto.OneofValue.string_value"));
- CHK_(ptr);
- } else goto handle_unusual;
- continue;
- // .testproto.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;
@@ -1098,65 +2611,41 @@ failure:
#undef CHK_
}
-::PROTOBUF_NAMESPACE_ID::uint8* OneofValue::_InternalSerialize(
+::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.OneofValue)
+ // @@protoc_insertion_point(serialize_to_array_start:testproto.BytesType)
::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,
- "testproto.OneofValue.string_value");
- target = stream->WriteStringMaybeAliased(
- 1, this->_internal_string_value(), target);
- }
-
- // .testproto.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);
+ // 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.OneofValue)
+ // @@protoc_insertion_point(serialize_to_array_end:testproto.BytesType)
return target;
}
-size_t OneofValue::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:testproto.OneofValue)
+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;
- switch (data_case()) {
- // string string_value = 1;
- case kStringValue: {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
- this->_internal_string_value());
- break;
- }
- // .testproto.SimpleStruct struct_value = 2;
- case kStructValue: {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
- *data_.struct_value_);
- break;
- }
- case DATA_NOT_SET: {
- break;
- }
+ // 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_);
@@ -1166,69 +2655,60 @@ size_t OneofValue::ByteSizeLong() const {
return total_size;
}
-void OneofValue::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:testproto.OneofValue)
+void BytesType::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:testproto.BytesType)
GOOGLE_DCHECK_NE(&from, this);
- const OneofValue* source =
- ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<OneofValue>(
+ const BytesType* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<BytesType>(
&from);
if (source == nullptr) {
- // @@protoc_insertion_point(generalized_merge_from_cast_fail:testproto.OneofValue)
+ // @@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.OneofValue)
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:testproto.BytesType)
MergeFrom(*source);
}
}
-void OneofValue::MergeFrom(const OneofValue& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:testproto.OneofValue)
+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;
- switch (from.data_case()) {
- case kStringValue: {
- _internal_set_string_value(from._internal_string_value());
- break;
- }
- case kStructValue: {
- _internal_mutable_struct_value()->::testproto::SimpleStruct::MergeFrom(from._internal_struct_value());
- break;
- }
- case DATA_NOT_SET: {
- break;
- }
+ if (from.bytes_value().size() > 0) {
+
+ bytes_value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.bytes_value_);
}
}
-void OneofValue::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:testproto.OneofValue)
+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 OneofValue::CopyFrom(const OneofValue& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:testproto.OneofValue)
+void BytesType::CopyFrom(const BytesType& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:testproto.BytesType)
if (&from == this) return;
Clear();
MergeFrom(from);
}
-bool OneofValue::IsInitialized() const {
+bool BytesType::IsInitialized() const {
return true;
}
-void OneofValue::InternalSwap(OneofValue* other) {
+void BytesType::InternalSwap(BytesType* other) {
using std::swap;
_internal_metadata_.Swap(&other->_internal_metadata_);
- swap(data_, other->data_);
- swap(_oneof_case_[0], other->_oneof_case_[0]);
+ bytes_value_.Swap(&other->bytes_value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ GetArenaNoVirtual());
}
-::PROTOBUF_NAMESPACE_ID::Metadata OneofValue::GetMetadata() const {
+::PROTOBUF_NAMESPACE_ID::Metadata BytesType::GetMetadata() const {
return GetMetadataStatic();
}
@@ -1245,12 +2725,30 @@ 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);
}
template<> PROTOBUF_NOINLINE ::testproto::OneofValue* Arena::CreateMaybeMessage< ::testproto::OneofValue >(Arena* arena) {
return Arena::CreateInternal< ::testproto::OneofValue >(arena);
}
+template<> PROTOBUF_NOINLINE ::testproto::StringArray* Arena::CreateMaybeMessage< ::testproto::StringArray >(Arena* arena) {
+ return Arena::CreateInternal< ::testproto::StringArray >(arena);
+}
+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 f5fae933eec66cd81264600d8e729c1243c10a86..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[5]
+ 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_;
@@ -73,36 +85,46 @@ extern SimpleStruct_IntMapEntry_DoNotUseDefaultTypeInternal _SimpleStruct_IntMap
class SimpleStruct_StringMapEntry_DoNotUse;
class SimpleStruct_StringMapEntry_DoNotUseDefaultTypeInternal;
extern SimpleStruct_StringMapEntry_DoNotUseDefaultTypeInternal _SimpleStruct_StringMapEntry_DoNotUse_default_instance_;
+class StringArray;
+class StringArrayDefaultTypeInternal;
+extern StringArrayDefaultTypeInternal _StringArray_default_instance_;
+class TwoDimensionalArray;
+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*);
template<> ::testproto::SimpleStruct_StringMapEntry_DoNotUse* Arena::CreateMaybeMessage<::testproto::SimpleStruct_StringMapEntry_DoNotUse>(Arena*);
+template<> ::testproto::StringArray* Arena::CreateMaybeMessage<::testproto::StringArray>(Arena*);
+template<> ::testproto::TwoDimensionalArray* Arena::CreateMaybeMessage<::testproto::TwoDimensionalArray>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
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;
@@ -264,6 +286,8 @@ class SimpleStruct :
kStringMapFieldNumber = 6,
kStringValueFieldNumber = 2,
kIntValueFieldNumber = 1,
+ kDoubleValueFieldNumber = 7,
+ kUint64ValueFieldNumber = 8,
};
// repeated int64 int_arr = 3;
int int_arr_size() const;
@@ -311,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;
@@ -370,6 +394,24 @@ class SimpleStruct :
void _internal_set_int_value(::PROTOBUF_NAMESPACE_ID::int64 value);
public:
+ // double double_value = 7;
+ 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:
+
+ // uint64 uint64_value = 8;
+ 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:
+
// @@protoc_insertion_point(class_scope:testproto.SimpleStruct)
private:
class _Internal;
@@ -380,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<
@@ -392,28 +434,30 @@ class SimpleStruct :
0 > string_map_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_value_;
::PROTOBUF_NAMESPACE_ID::int64 int_value_;
+ double double_value_;
+ ::PROTOBUF_NAMESPACE_ID::uint64 uint64_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:testproto.JsonNaming) */ {
+class Bar :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:testproto.Bar) */ {
public:
- JsonNaming();
- virtual ~JsonNaming();
+ Bar();
+ virtual ~Bar();
- JsonNaming(const JsonNaming& from);
- JsonNaming(JsonNaming&& from) noexcept
- : JsonNaming() {
+ Bar(const Bar& from);
+ Bar(Bar&& from) noexcept
+ : Bar() {
*this = ::std::move(from);
}
- inline JsonNaming& operator=(const JsonNaming& from) {
+ inline Bar& operator=(const Bar& from) {
CopyFrom(from);
return *this;
}
- inline JsonNaming& operator=(JsonNaming&& from) noexcept {
+ inline Bar& operator=(Bar&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
@@ -431,37 +475,37 @@ class JsonNaming :
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
- static const JsonNaming& default_instance();
+ static const Bar& 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 inline const Bar* internal_default_instance() {
+ return reinterpret_cast<const Bar*>(
+ &_Bar_default_instance_);
}
static constexpr int kIndexInFileMessages =
3;
- friend void swap(JsonNaming& a, JsonNaming& b) {
+ friend void swap(Bar& a, Bar& b) {
a.Swap(&b);
}
- inline void Swap(JsonNaming* other) {
+ inline void Swap(Bar* other) {
if (other == this) return;
InternalSwap(other);
}
// implements Message ----------------------------------------------
- inline JsonNaming* New() const final {
- return CreateMaybeMessage<JsonNaming>(nullptr);
+ inline Bar* New() const final {
+ return CreateMaybeMessage<Bar>(nullptr);
}
- JsonNaming* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
- return CreateMaybeMessage<JsonNaming>(arena);
+ 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 JsonNaming& from);
- void MergeFrom(const JsonNaming& from);
+ void CopyFrom(const Bar& from);
+ void MergeFrom(const Bar& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
@@ -475,10 +519,10 @@ class JsonNaming :
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
- void InternalSwap(JsonNaming* other);
+ void InternalSwap(Bar* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
- return "testproto.JsonNaming";
+ return "testproto.Bar";
}
private:
inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
@@ -503,78 +547,204 @@ class JsonNaming :
// accessors -------------------------------------------------------
enum : int {
- kFooValueFieldNumber = 1,
- kBarValueFieldNumber = 2,
- kBazValueFieldNumber = 3,
- kQuXValueFieldNumber = 4,
+ kValueFieldNumber = 2,
};
- // float foo_value = 1;
- void clear_foo_value();
- float foo_value() const;
- void set_foo_value(float value);
+ // 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:
- float _internal_foo_value() const;
- void _internal_set_foo_value(float value);
+ const std::string& _internal_value() const;
+ void _internal_set_value(const std::string& value);
+ std::string* _internal_mutable_value();
public:
- // float barValue = 2;
- void clear_barvalue();
- float barvalue() const;
- void set_barvalue(float value);
+ // @@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:
- float _internal_barvalue() const;
- void _internal_set_barvalue(float value);
+ 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:
- // float BazValue = 3;
- void clear_bazvalue();
- float bazvalue() const;
- void set_bazvalue(float value);
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
- float _internal_bazvalue() const;
- void _internal_set_bazvalue(float value);
+ 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:
- // float quX_Value = 4;
- void clear_qux_value();
- float qux_value() const;
- void set_qux_value(float value);
+ // 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:
- float _internal_qux_value() const;
- void _internal_set_qux_value(float value);
+ 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.JsonNaming)
+ // .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_;
- float foo_value_;
- float barvalue_;
- float bazvalue_;
- float qux_value_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
+ ::testproto::Bar* bar_;
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:testproto.OneofValue) */ {
+class MessageType :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:testproto.MessageType) */ {
public:
- OneofValue();
- virtual ~OneofValue();
+ MessageType();
+ virtual ~MessageType();
- OneofValue(const OneofValue& from);
- OneofValue(OneofValue&& from) noexcept
- : OneofValue() {
+ MessageType(const MessageType& from);
+ MessageType(MessageType&& from) noexcept
+ : MessageType() {
*this = ::std::move(from);
}
- inline OneofValue& operator=(const OneofValue& from) {
+ inline MessageType& operator=(const MessageType& from) {
CopyFrom(from);
return *this;
}
- inline OneofValue& operator=(OneofValue&& from) noexcept {
+ inline MessageType& operator=(MessageType&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
@@ -592,43 +762,37 @@ class OneofValue :
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 const MessageType& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
- static inline const OneofValue* internal_default_instance() {
- return reinterpret_cast<const OneofValue*>(
- &_OneofValue_default_instance_);
+ static inline const MessageType* internal_default_instance() {
+ return reinterpret_cast<const MessageType*>(
+ &_MessageType_default_instance_);
}
static constexpr int kIndexInFileMessages =
- 4;
+ 5;
- friend void swap(OneofValue& a, OneofValue& b) {
+ friend void swap(MessageType& a, MessageType& b) {
a.Swap(&b);
}
- inline void Swap(OneofValue* other) {
+ inline void Swap(MessageType* other) {
if (other == this) return;
InternalSwap(other);
}
// implements Message ----------------------------------------------
- inline OneofValue* New() const final {
- return CreateMaybeMessage<OneofValue>(nullptr);
+ inline MessageType* New() const final {
+ return CreateMaybeMessage<MessageType>(nullptr);
}
- OneofValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
- return CreateMaybeMessage<OneofValue>(arena);
+ 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 OneofValue& from);
- void MergeFrom(const OneofValue& from);
+ void CopyFrom(const MessageType& from);
+ void MergeFrom(const MessageType& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
@@ -642,10 +806,778 @@ class OneofValue :
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
- void InternalSwap(OneofValue* other);
+ void InternalSwap(MessageType* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
- return "testproto.OneofValue";
+ 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:
+ 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 =
+ 6;
+
+ 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 "testproto.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,
+ };
+ // float foo_value = 1;
+ void clear_foo_value();
+ float foo_value() const;
+ void set_foo_value(float value);
+ private:
+ float _internal_foo_value() const;
+ void _internal_set_foo_value(float value);
+ public:
+
+ // float barValue = 2;
+ void clear_barvalue();
+ float barvalue() const;
+ void set_barvalue(float value);
+ private:
+ float _internal_barvalue() const;
+ void _internal_set_barvalue(float value);
+ public:
+
+ // float BazValue = 3;
+ void clear_bazvalue();
+ float bazvalue() const;
+ void set_bazvalue(float value);
+ private:
+ float _internal_bazvalue() const;
+ void _internal_set_bazvalue(float value);
+ public:
+
+ // float quX_Value = 4;
+ void clear_qux_value();
+ float qux_value() const;
+ void set_qux_value(float value);
+ private:
+ float _internal_qux_value() const;
+ void _internal_set_qux_value(float value);
+ public:
+
+ // @@protoc_insertion_point(class_scope:testproto.JsonNaming)
+ private:
+ class _Internal;
+
+ ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+ float foo_value_;
+ float barvalue_;
+ float bazvalue_;
+ float 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:testproto.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 =
+ 7;
+
+ 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 "testproto.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:
+
+ // .testproto.SimpleStruct struct_value = 2;
+ bool has_struct_value() const;
+ private:
+ bool _internal_has_struct_value() const;
+ public:
+ void clear_struct_value();
+ const ::testproto::SimpleStruct& struct_value() const;
+ ::testproto::SimpleStruct* release_struct_value();
+ ::testproto::SimpleStruct* mutable_struct_value();
+ void set_allocated_struct_value(::testproto::SimpleStruct* struct_value);
+ private:
+ const ::testproto::SimpleStruct& _internal_struct_value() const;
+ ::testproto::SimpleStruct* _internal_mutable_struct_value();
+ public:
+
+ void clear_data();
+ DataCase data_case() const;
+ // @@protoc_insertion_point(class_scope:testproto.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_;
+ ::testproto::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 StringArray :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:testproto.StringArray) */ {
+ public:
+ StringArray();
+ virtual ~StringArray();
+
+ StringArray(const StringArray& from);
+ StringArray(StringArray&& from) noexcept
+ : StringArray() {
+ *this = ::std::move(from);
+ }
+
+ inline StringArray& operator=(const StringArray& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline StringArray& operator=(StringArray&& 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 StringArray& default_instance();
+
+ static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
+ static inline const StringArray* internal_default_instance() {
+ return reinterpret_cast<const StringArray*>(
+ &_StringArray_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 8;
+
+ friend void swap(StringArray& a, StringArray& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(StringArray* other) {
+ if (other == this) return;
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline StringArray* New() const final {
+ return CreateMaybeMessage<StringArray>(nullptr);
+ }
+
+ StringArray* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<StringArray>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const StringArray& from);
+ void MergeFrom(const StringArray& 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(StringArray* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "testproto.StringArray";
+ }
+ 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 {
+ kStrArrFieldNumber = 1,
+ };
+ // repeated string str_arr = 1;
+ int str_arr_size() const;
+ private:
+ int _internal_str_arr_size() const;
+ public:
+ void clear_str_arr();
+ const std::string& str_arr(int index) const;
+ std::string* mutable_str_arr(int index);
+ void set_str_arr(int index, const std::string& value);
+ void set_str_arr(int index, std::string&& value);
+ void set_str_arr(int index, const char* value);
+ void set_str_arr(int index, const char* value, size_t size);
+ std::string* add_str_arr();
+ void add_str_arr(const std::string& value);
+ void add_str_arr(std::string&& value);
+ void add_str_arr(const char* value);
+ void add_str_arr(const char* value, size_t size);
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& str_arr() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_str_arr();
+ private:
+ const std::string& _internal_str_arr(int index) const;
+ std::string* _internal_add_str_arr();
+ public:
+
+ // @@protoc_insertion_point(class_scope:testproto.StringArray)
+ private:
+ class _Internal;
+
+ ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> str_arr_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class TwoDimensionalArray :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:testproto.TwoDimensionalArray) */ {
+ public:
+ TwoDimensionalArray();
+ virtual ~TwoDimensionalArray();
+
+ TwoDimensionalArray(const TwoDimensionalArray& from);
+ TwoDimensionalArray(TwoDimensionalArray&& from) noexcept
+ : TwoDimensionalArray() {
+ *this = ::std::move(from);
+ }
+
+ inline TwoDimensionalArray& operator=(const TwoDimensionalArray& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline TwoDimensionalArray& operator=(TwoDimensionalArray&& 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 TwoDimensionalArray& default_instance();
+
+ static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
+ static inline const TwoDimensionalArray* internal_default_instance() {
+ return reinterpret_cast<const TwoDimensionalArray*>(
+ &_TwoDimensionalArray_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 9;
+
+ friend void swap(TwoDimensionalArray& a, TwoDimensionalArray& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(TwoDimensionalArray* other) {
+ if (other == this) return;
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline TwoDimensionalArray* New() const final {
+ return CreateMaybeMessage<TwoDimensionalArray>(nullptr);
+ }
+
+ TwoDimensionalArray* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<TwoDimensionalArray>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const TwoDimensionalArray& from);
+ void MergeFrom(const TwoDimensionalArray& 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(TwoDimensionalArray* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "testproto.TwoDimensionalArray";
+ }
+ 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 {
+ kArrFieldNumber = 1,
+ };
+ // repeated .testproto.StringArray arr = 1;
+ int arr_size() const;
+ private:
+ int _internal_arr_size() const;
+ public:
+ void clear_arr();
+ ::testproto::StringArray* mutable_arr(int index);
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::testproto::StringArray >*
+ mutable_arr();
+ private:
+ const ::testproto::StringArray& _internal_arr(int index) const;
+ ::testproto::StringArray* _internal_add_arr();
+ public:
+ const ::testproto::StringArray& arr(int index) const;
+ ::testproto::StringArray* add_arr();
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::testproto::StringArray >&
+ arr() const;
+
+ // @@protoc_insertion_point(class_scope:testproto.TwoDimensionalArray)
+ private:
+ class _Internal;
+
+ ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::testproto::StringArray > arr_;
+ 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 {
@@ -670,63 +1602,31 @@ class OneofValue :
// accessors -------------------------------------------------------
enum : int {
- kStringValueFieldNumber = 1,
- kStructValueFieldNumber = 2,
+ kBytesValueFieldNumber = 1,
};
- // 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:
-
- // .testproto.SimpleStruct struct_value = 2;
- bool has_struct_value() const;
- private:
- bool _internal_has_struct_value() const;
- public:
- void clear_struct_value();
- const ::testproto::SimpleStruct& struct_value() const;
- ::testproto::SimpleStruct* release_struct_value();
- ::testproto::SimpleStruct* mutable_struct_value();
- void set_allocated_struct_value(::testproto::SimpleStruct* struct_value);
+ // 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 ::testproto::SimpleStruct& _internal_struct_value() const;
- ::testproto::SimpleStruct* _internal_mutable_struct_value();
+ const std::string& _internal_bytes_value() const;
+ void _internal_set_bytes_value(const std::string& value);
+ std::string* _internal_mutable_bytes_value();
public:
- void clear_data();
- DataCase data_case() const;
- // @@protoc_insertion_point(class_scope:testproto.OneofValue)
+ // @@protoc_insertion_point(class_scope:testproto.BytesType)
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_;
- ::testproto::SimpleStruct* struct_value_;
- } data_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bytes_value_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
- ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
-
friend struct ::TableStruct_messages_2eproto;
};
// ===================================================================
@@ -945,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();
}
@@ -955,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();
@@ -1003,6 +1903,337 @@ SimpleStruct::mutable_string_map() {
return _internal_mutable_string_map();
}
+// double double_value = 7;
+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:testproto.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:testproto.SimpleStruct.double_value)
+}
+
+// uint64 uint64_value = 8;
+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:testproto.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:testproto.SimpleStruct.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
@@ -1248,6 +2479,191 @@ inline void OneofValue::clear_has_data() {
inline OneofValue::DataCase OneofValue::data_case() const {
return OneofValue::DataCase(_oneof_case_[0]);
}
+// -------------------------------------------------------------------
+
+// StringArray
+
+// repeated string str_arr = 1;
+inline int StringArray::_internal_str_arr_size() const {
+ return str_arr_.size();
+}
+inline int StringArray::str_arr_size() const {
+ return _internal_str_arr_size();
+}
+inline void StringArray::clear_str_arr() {
+ str_arr_.Clear();
+}
+inline std::string* StringArray::add_str_arr() {
+ // @@protoc_insertion_point(field_add_mutable:testproto.StringArray.str_arr)
+ return _internal_add_str_arr();
+}
+inline const std::string& StringArray::_internal_str_arr(int index) const {
+ return str_arr_.Get(index);
+}
+inline const std::string& StringArray::str_arr(int index) const {
+ // @@protoc_insertion_point(field_get:testproto.StringArray.str_arr)
+ return _internal_str_arr(index);
+}
+inline std::string* StringArray::mutable_str_arr(int index) {
+ // @@protoc_insertion_point(field_mutable:testproto.StringArray.str_arr)
+ return str_arr_.Mutable(index);
+}
+inline void StringArray::set_str_arr(int index, const std::string& value) {
+ // @@protoc_insertion_point(field_set:testproto.StringArray.str_arr)
+ str_arr_.Mutable(index)->assign(value);
+}
+inline void StringArray::set_str_arr(int index, std::string&& value) {
+ // @@protoc_insertion_point(field_set:testproto.StringArray.str_arr)
+ str_arr_.Mutable(index)->assign(std::move(value));
+}
+inline void StringArray::set_str_arr(int index, const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+ str_arr_.Mutable(index)->assign(value);
+ // @@protoc_insertion_point(field_set_char:testproto.StringArray.str_arr)
+}
+inline void StringArray::set_str_arr(int index, const char* value, size_t size) {
+ str_arr_.Mutable(index)->assign(
+ reinterpret_cast<const char*>(value), size);
+ // @@protoc_insertion_point(field_set_pointer:testproto.StringArray.str_arr)
+}
+inline std::string* StringArray::_internal_add_str_arr() {
+ return str_arr_.Add();
+}
+inline void StringArray::add_str_arr(const std::string& value) {
+ str_arr_.Add()->assign(value);
+ // @@protoc_insertion_point(field_add:testproto.StringArray.str_arr)
+}
+inline void StringArray::add_str_arr(std::string&& value) {
+ str_arr_.Add(std::move(value));
+ // @@protoc_insertion_point(field_add:testproto.StringArray.str_arr)
+}
+inline void StringArray::add_str_arr(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+ str_arr_.Add()->assign(value);
+ // @@protoc_insertion_point(field_add_char:testproto.StringArray.str_arr)
+}
+inline void StringArray::add_str_arr(const char* value, size_t size) {
+ str_arr_.Add()->assign(reinterpret_cast<const char*>(value), size);
+ // @@protoc_insertion_point(field_add_pointer:testproto.StringArray.str_arr)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+StringArray::str_arr() const {
+ // @@protoc_insertion_point(field_list:testproto.StringArray.str_arr)
+ return str_arr_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+StringArray::mutable_str_arr() {
+ // @@protoc_insertion_point(field_mutable_list:testproto.StringArray.str_arr)
+ return &str_arr_;
+}
+
+// -------------------------------------------------------------------
+
+// TwoDimensionalArray
+
+// repeated .testproto.StringArray arr = 1;
+inline int TwoDimensionalArray::_internal_arr_size() const {
+ return arr_.size();
+}
+inline int TwoDimensionalArray::arr_size() const {
+ return _internal_arr_size();
+}
+inline void TwoDimensionalArray::clear_arr() {
+ arr_.Clear();
+}
+inline ::testproto::StringArray* TwoDimensionalArray::mutable_arr(int index) {
+ // @@protoc_insertion_point(field_mutable:testproto.TwoDimensionalArray.arr)
+ return arr_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::testproto::StringArray >*
+TwoDimensionalArray::mutable_arr() {
+ // @@protoc_insertion_point(field_mutable_list:testproto.TwoDimensionalArray.arr)
+ return &arr_;
+}
+inline const ::testproto::StringArray& TwoDimensionalArray::_internal_arr(int index) const {
+ return arr_.Get(index);
+}
+inline const ::testproto::StringArray& TwoDimensionalArray::arr(int index) const {
+ // @@protoc_insertion_point(field_get:testproto.TwoDimensionalArray.arr)
+ return _internal_arr(index);
+}
+inline ::testproto::StringArray* TwoDimensionalArray::_internal_add_arr() {
+ return arr_.Add();
+}
+inline ::testproto::StringArray* TwoDimensionalArray::add_arr() {
+ // @@protoc_insertion_point(field_add:testproto.TwoDimensionalArray.arr)
+ return _internal_add_arr();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::testproto::StringArray >&
+TwoDimensionalArray::arr() const {
+ // @@protoc_insertion_point(field_list:testproto.TwoDimensionalArray.arr)
+ 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__
@@ -1259,6 +2675,18 @@ inline OneofValue::DataCase OneofValue::data_case() 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 d170416a7692f131b0df3d4a24f47ae63b2be14c..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,20 +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
)
-#add_custom_command(
-# TARGET protobuf_tests
-# COMMENT "Run protobuf tests"
-# POST_BUILD
-# WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
-# COMMAND ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/protobuf_tests
-#)
+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 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 a779043f8e32e108613b6be18277e264f7df69c5..61e2ea3874131d4aaff740fea19b6364c26b7273 100644
--- a/cpp/tests/vereign/grpc/server_test.cc
+++ b/cpp/tests/vereign/grpc/server_test.cc
@@ -4,11 +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");
@@ -57,6 +58,22 @@ TEST_CASE("Server", "[vereign/grpc/server][.integration]") {
CHECK(passport.uuid().size() == 36);
}
+ 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);
+ CHECK(status.error_message() == "");
+ CHECK(getInterResp.error() == "");
+ CHECK(getInterResp.status() == "OK");
+ CHECK(getInterResp.code() == "200");
+ for (auto& interaction : getInterResp.data()) {
+ CHECK(interaction.subject().size() > 0);
+ CHECK(interaction.passport().size() == 36);
+ }
+
+ // std::cout << vereign::test::ProtobufToJson(getDIDsResp) << std::endl;
+
grpc_shutdown();
google::protobuf::ShutdownProtobufLibrary();
}
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 eefbb73831473f88251685eb3474a682659bf2ee..36a824999a5c725e0d5443d91c91369fac619c51 100644
--- a/cpp/tests/vereign/restapi/client_session_test.cc
+++ b/cpp/tests/vereign/restapi/client_session_test.cc
@@ -1,11 +1,11 @@
#include <vereign/restapi/client.hh>
#include <vereign/restapi/client_session.hh>
#include <vereign/core/scope_guard.hh>
-#include <vereign/client_library/passport_types.gen.pb.h>
+#include <vereign/client_library/types.gen.pb.h>
#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 637838acc904ff10e8724aec956fb8d2abc8e45a..ec0375b559d44d09d6452604b38af0660932da7e 100644
--- a/cpp/tests/vereign/service/gen/passport_service_test.cc
+++ b/cpp/tests/vereign/service/gen/passport_service_test.cc
@@ -1,10 +1,10 @@
#include <vereign/service/gen/passport_service.hh>
#include <vereign/core/scope_guard.hh>
-#include <vereign/client_library/passport_types.gen.pb.h>
+#include <vereign/client_library/types.gen.pb.h>
#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};