From 9ef26464ec86d447e29bd16258ac78aeb5dd4daf Mon Sep 17 00:00:00 2001 From: Alfred Fuller Date: Fri, 28 Jul 2023 12:58:05 -0700 Subject: [PATCH] Add grpc c++ client conformance tests (#512) The minimal footprint to get a grpc-based binary that can run the conformance tests. To test run: - run a test server, for example `go run cmd/serverconnect/main.go --insecure --h1port=8080 --h2port=8081` - run the conformance tests `PORT=8081 bazel run //cc:grpc_client_test` Will require follow up PRs to fully integrate into crosstest docker images and CI. Also note that the grpc client does not properly convert 404's into UNIMPLEMENTED, instead returning UNKNOWN. --- .bazelrc | 25 + .gitignore | 1 + Makefile | 5 +- WORKSPACE.bazel | 19 + buf.gen.yaml | 4 + cc/.clang-format | 115 + cc/.clang-tidy | 56 + cc/BUILD.bazel | 38 + .../conformance/messages.grpc.pb.cc | 41 + .../connectrpc/conformance/messages.grpc.pb.h | 46 + cc/gen/connectrpc/conformance/messages.pb.cc | 6948 ++++++++++++++++ cc/gen/connectrpc/conformance/messages.pb.h | 7176 +++++++++++++++++ cc/gen/connectrpc/conformance/test.grpc.pb.cc | 944 +++ cc/gen/connectrpc/conformance/test.grpc.pb.h | 3497 ++++++++ cc/gen/connectrpc/conformance/test.pb.cc | 160 + cc/gen/connectrpc/conformance/test.pb.h | 102 + cc/gen/server/v1/server.grpc.pb.cc | 41 + cc/gen/server/v1/server.grpc.pb.h | 46 + cc/gen/server/v1/server.pb.cc | 938 +++ cc/gen/server/v1/server.pb.h | 982 +++ cc/grpc_client_test.cc | 559 ++ 21 files changed, 21741 insertions(+), 2 deletions(-) create mode 100644 .bazelrc create mode 100644 WORKSPACE.bazel create mode 100644 cc/.clang-format create mode 100644 cc/.clang-tidy create mode 100644 cc/BUILD.bazel create mode 100644 cc/gen/connectrpc/conformance/messages.grpc.pb.cc create mode 100644 cc/gen/connectrpc/conformance/messages.grpc.pb.h create mode 100644 cc/gen/connectrpc/conformance/messages.pb.cc create mode 100644 cc/gen/connectrpc/conformance/messages.pb.h create mode 100644 cc/gen/connectrpc/conformance/test.grpc.pb.cc create mode 100644 cc/gen/connectrpc/conformance/test.grpc.pb.h create mode 100644 cc/gen/connectrpc/conformance/test.pb.cc create mode 100644 cc/gen/connectrpc/conformance/test.pb.h create mode 100644 cc/gen/server/v1/server.grpc.pb.cc create mode 100644 cc/gen/server/v1/server.grpc.pb.h create mode 100644 cc/gen/server/v1/server.pb.cc create mode 100644 cc/gen/server/v1/server.pb.h create mode 100644 cc/grpc_client_test.cc diff --git a/.bazelrc b/.bazelrc new file mode 100644 index 00000000..d472694c --- /dev/null +++ b/.bazelrc @@ -0,0 +1,25 @@ +build --cxxopt=-std=c++17 --host_cxxopt=-std=c++17 +build --cxxopt=-fsized-deallocation + +# Enable matchers in googletest +build --define absl=1 + +build:asan --linkopt -ldl +build:asan --linkopt -fsanitize=address +build:asan --copt -fsanitize=address +build:asan --copt -DADDRESS_SANITIZER=1 +build:asan --copt -D__SANITIZE_ADDRESS__ +build:asan --test_env=ASAN_OPTIONS=handle_abort=1:allow_addr2line=true:check_initialization_order=true:strict_init_order=true:detect_odr_violation=1 +build:asan --test_env=ASAN_SYMBOLIZER_PATH +build:asan --copt -O1 +build:asan --copt -fno-optimize-sibling-calls +build:asan --linkopt=-fuse-ld=lld + +build:macos --features=-supports_dynamic_linker + +build:clang --action_env=CC=clang --host_action_env=CC=clang +build:clang --action_env=CXX=clang++ --host_action_env=CXX=clang++ + +try-import %workspace%/clang.bazelrc +try-import %workspace%/user.bazelrc +try-import %workspace%/local_tsan.bazelrc diff --git a/.gitignore b/.gitignore index bdb26766..049adfae 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,5 @@ /.tmp/ +/bazel-* *.pprof *.svg cover.out diff --git a/Makefile b/Makefile index b7bcc57c..924f112b 100644 --- a/Makefile +++ b/Makefile @@ -53,6 +53,7 @@ lintfix: $(BIN)/golangci-lint $(BIN)/buf ## Automatically fix some lint errors .PHONY: generate generate: $(BIN)/buf $(BIN)/protoc-gen-go $(BIN)/protoc-gen-connect-go $(BIN)/protoc-gen-go-grpc $(BIN)/license-header ## Regenerate code and licenses + rm -rf cc/gen rm -rf internal/gen rm -rf web/gen PATH=$(abspath $(BIN)) $(BIN)/buf generate @@ -131,12 +132,12 @@ dockercomposeclean: $(BIN)/buf: Makefile @mkdir -p $(@D) - GOBIN=$(abspath $(@D)) $(GO) install github.com/bufbuild/buf/cmd/buf@v1.11.0 + GOBIN=$(abspath $(@D)) $(GO) install github.com/bufbuild/buf/cmd/buf@v1.24.0 $(BIN)/license-header: Makefile @mkdir -p $(@D) GOBIN=$(abspath $(@D)) $(GO) install \ - github.com/bufbuild/buf/private/pkg/licenseheader/cmd/license-header@v1.11.0 + github.com/bufbuild/buf/private/pkg/licenseheader/cmd/license-header@v1.24.0 $(BIN)/golangci-lint: Makefile @mkdir -p $(@D) diff --git a/WORKSPACE.bazel b/WORKSPACE.bazel new file mode 100644 index 00000000..06deddb0 --- /dev/null +++ b/WORKSPACE.bazel @@ -0,0 +1,19 @@ +workspace(name = "com_github_bufbuild_protovalidate") + +load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive") + +http_archive( + name = "com_github_grpc_grpc", + strip_prefix = "grpc-1.56.2", + urls = [ + "https://github.com/grpc/grpc/archive/v1.56.2.tar.gz", + ], +) + +load("@com_github_grpc_grpc//bazel:grpc_deps.bzl", "grpc_deps") + +grpc_deps() + +load("@com_github_grpc_grpc//bazel:grpc_extra_deps.bzl", "grpc_extra_deps") + +grpc_extra_deps() diff --git a/buf.gen.yaml b/buf.gen.yaml index b9876051..f9e1b95f 100644 --- a/buf.gen.yaml +++ b/buf.gen.yaml @@ -27,3 +27,7 @@ plugins: opt: - import_style=typescript - mode=grpcweb + - plugin: buf.build/grpc/cpp:v1.56.2 + out: cc/gen + - plugin: buf.build/protocolbuffers/cpp + out: cc/gen diff --git a/cc/.clang-format b/cc/.clang-format new file mode 100644 index 00000000..4e8f69d4 --- /dev/null +++ b/cc/.clang-format @@ -0,0 +1,115 @@ +--- +AccessModifierOffset: -1 +AlignAfterOpenBracket: AlwaysBreak +AlignConsecutiveMacros: false +AlignConsecutiveAssignments: false +AlignConsecutiveBitFields: false +AlignConsecutiveDeclarations: false +AlignEscapedNewlines: Left +AlignOperands: DontAlign +AlignTrailingComments: false +AllowAllArgumentsOnNextLine: true +AllowAllConstructorInitializersOnNextLine: true +AllowAllParametersOfDeclarationOnNextLine: true +AllowShortEnumsOnASingleLine: true +AllowShortBlocksOnASingleLine: Never +AllowShortCaseLabelsOnASingleLine: false +AllowShortFunctionsOnASingleLine: Inline +AllowShortLambdasOnASingleLine: All +AllowShortIfStatementsOnASingleLine: AllIfsAndElse +AllowShortLoopsOnASingleLine: false +AlwaysBreakAfterReturnType: None +AlwaysBreakBeforeMultilineStrings: true +AlwaysBreakTemplateDeclarations: Yes +BinPackArguments: false +BinPackParameters: false +BreakBeforeBinaryOperators: None +BreakBeforeBraces: Attach +BreakInheritanceList: BeforeColon +BreakBeforeTernaryOperators: true +BreakConstructorInitializers: BeforeColon +BreakAfterJavaFieldAnnotations: false +BreakStringLiterals: false +ColumnLimit: 100 +CommentPragmas: '^ IWYU pragma:' +CompactNamespaces: false +ConstructorInitializerAllOnOneLineOrOnePerLine: true +ConstructorInitializerIndentWidth: 4 +ContinuationIndentWidth: 4 +Cpp11BracedListStyle: true +DeriveLineEnding: true +DerivePointerAlignment: false +DisableFormat: false +FixNamespaceComments: true +ForEachMacros: + - FOR_EACH + - FOR_EACH_R + - FOR_EACH_RANGE +IncludeBlocks: Regroup +IncludeCategories: + - Regex: '^<(sodium|Python)\.h>$' + Priority: 3 + - Regex: '^<((arpa|net|netinet|sys|linux)\/)?[-_[:alnum:]]+\.h>$' + Priority: 1 + - Regex: '^<[\/-_[:alnum:]]+>$' + Priority: 2 + - Regex: '^<.*>$' + Priority: 4 + - Regex: '.*' + Priority: 5 +IncludeIsMainRegex: '((Test|Tests|_test|Bench|Benchmark|Performance)[0-9]*)?$' +IndentCaseLabels: true +IndentCaseBlocks: false +IndentGotoLabels: true +IndentPPDirectives: None +IndentExternBlock: AfterExternBlock +IndentWidth: 2 +IndentWrappedFunctionNames: false +InsertTrailingCommas: None +JavaScriptQuotes: Leave +JavaScriptWrapImports: true +KeepEmptyLinesAtTheStartOfBlocks: false +MacroBlockBegin: '' +MacroBlockEnd: '' +MaxEmptyLinesToKeep: 1 +NamespaceIndentation: None +ObjCBinPackProtocolList: Auto +ObjCBlockIndentWidth: 2 +ObjCBreakBeforeNestedBlockParam: true +ObjCSpaceAfterProperty: false +ObjCSpaceBeforeProtocolList: false +PenaltyBreakAssignment: 2 +PenaltyBreakBeforeFirstCallParameter: 1 +PenaltyBreakComment: 300 +PenaltyBreakFirstLessLess: 120 +PenaltyBreakString: 1000 +PenaltyBreakTemplateDeclaration: 10 +PenaltyExcessCharacter: 1000000 +PenaltyReturnTypeOnItsOwnLine: 200 +PointerAlignment: Left +ReflowComments: true +SortIncludes: true +SortUsingDeclarations: true +SpaceAfterCStyleCast: false +SpaceAfterLogicalNot: false +SpaceAfterTemplateKeyword: true +SpaceBeforeAssignmentOperators: true +SpaceBeforeCpp11BracedList: false +SpaceBeforeCtorInitializerColon: true +SpaceBeforeInheritanceColon: true +SpaceBeforeParens: ControlStatements +SpaceBeforeRangeBasedForLoopColon: true +SpaceInEmptyBlock: false +SpaceInEmptyParentheses: false +SpacesBeforeTrailingComments: 1 +SpacesInAngles: false +SpacesInConditionalStatement: false +SpacesInContainerLiterals: true +SpacesInCStyleCastParentheses: false +SpacesInParentheses: false +SpacesInSquareBrackets: false +SpaceBeforeSquareBrackets: false +Standard: Latest +TabWidth: 8 +UseCRLF: false +UseTab: Never diff --git a/cc/.clang-tidy b/cc/.clang-tidy new file mode 100644 index 00000000..53d8461f --- /dev/null +++ b/cc/.clang-tidy @@ -0,0 +1,56 @@ +Checks: '-clang-analyzer-core.NonNullParamChecker, + -clang-analyzer-optin.cplusplus.UninitializedObject, + abseil-*, + bugprone-* + clang-analyzer-core.DivideZero, + misc-unused-using-decls, + modernize-*, + -modernize-use-trailing-return-type, + performance-*, + readability-*, + -readability-identifier-length, + -readability-else-after-return' + +CheckOptions: + - key: bugprone-assert-side-effect.AssertMacros + value: 'ASSERT' + + - key: bugprone-dangling-handle.HandleClasses + value: 'std::basic_string_view;std::experimental::basic_string_view;absl::string_view' + + - key: modernize-use-auto.MinTypeNameLength + value: '10' + + - key: readability-identifier-naming.ClassCase + value: 'CamelCase' + + - key: readability-identifier-naming.EnumCase + value: 'CamelCase' + + - key: readability-identifier-naming.EnumConstantCase + value: 'CamelCase' + + # Ignore GoogleTest function macros. + - key: readability-identifier-naming.FunctionIgnoredRegexp + value: '(TEST|TEST_F|TEST_P|INSTANTIATE_TEST_SUITE_P|MOCK_METHOD|TYPED_TEST)' + + - key: readability-identifier-naming.ParameterCase + value: 'camelBack' + + - key: readability-identifier-naming.PrivateMemberCase + value: 'camelBack' + + - key: readability-identifier-naming.PrivateMemberSuffix + value: '_' + + - key: readability-identifier-naming.StructCase + value: 'aNy_CasE' + + - key: readability-identifier-naming.TypeAliasCase + value: 'aNy_CasE' + + - key: readability-identifier-naming.UnionCase + value: 'CamelCase' + + - key: readability-identifier-naming.FunctionCase + value: 'aNy_CasE' diff --git a/cc/BUILD.bazel b/cc/BUILD.bazel new file mode 100644 index 00000000..a6e3f083 --- /dev/null +++ b/cc/BUILD.bazel @@ -0,0 +1,38 @@ +# Copyright 2022 Buf Technologies, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +package(default_visibility = ["//cc:__subpackages__"]) + +cc_test( + name = "grpc_client_test", + srcs = ["grpc_client_test.cc"], + env = {"PORT": "8081"}, + deps = [ + "//cc:gen-connectrpc-conformance", + "@com_github_grpc_grpc//:grpc++", + "@com_google_googleapis//google/rpc:status_cc_proto", + "@com_google_googletest//:gtest_main", + ], +) + +cc_library( + name = "gen-connectrpc-conformance", + srcs = glob(["gen/connectrpc/conformance/*.cc"]), + hdrs = glob(["gen/connectrpc/conformance/*.h"]), + includes = ["gen"], + deps = [ + "@com_github_grpc_grpc//:grpc++", + "@com_google_protobuf//:protobuf", + ], +) diff --git a/cc/gen/connectrpc/conformance/messages.grpc.pb.cc b/cc/gen/connectrpc/conformance/messages.grpc.pb.cc new file mode 100644 index 00000000..7cb7b7e1 --- /dev/null +++ b/cc/gen/connectrpc/conformance/messages.grpc.pb.cc @@ -0,0 +1,41 @@ +// Copyright 2022 Buf Technologies, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Generated by the gRPC C++ plugin. +// If you make any local change, they will be lost. +// source: connectrpc/conformance/messages.proto + +#include "connectrpc/conformance/messages.pb.h" +#include "connectrpc/conformance/messages.grpc.pb.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +namespace connectrpc { +namespace conformance { + +} // namespace connectrpc +} // namespace conformance + diff --git a/cc/gen/connectrpc/conformance/messages.grpc.pb.h b/cc/gen/connectrpc/conformance/messages.grpc.pb.h new file mode 100644 index 00000000..bbedb17f --- /dev/null +++ b/cc/gen/connectrpc/conformance/messages.grpc.pb.h @@ -0,0 +1,46 @@ +// Copyright 2022 Buf Technologies, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef GRPC_connectrpc_2fconformance_2fmessages_2eproto__INCLUDED +#define GRPC_connectrpc_2fconformance_2fmessages_2eproto__INCLUDED + +#include "connectrpc/conformance/messages.pb.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace connectrpc { +namespace conformance { + +} // namespace conformance +} // namespace connectrpc + + +#endif // GRPC_connectrpc_2fconformance_2fmessages_2eproto__INCLUDED diff --git a/cc/gen/connectrpc/conformance/messages.pb.cc b/cc/gen/connectrpc/conformance/messages.pb.cc new file mode 100644 index 00000000..e002af36 --- /dev/null +++ b/cc/gen/connectrpc/conformance/messages.pb.cc @@ -0,0 +1,6948 @@ +// Copyright 2022 Buf Technologies, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: connectrpc/conformance/messages.proto + +#include "connectrpc/conformance/messages.pb.h" + +#include +#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) + +// Must be included last. +#include "google/protobuf/port_def.inc" +PROTOBUF_PRAGMA_INIT_SEG +namespace _pb = ::PROTOBUF_NAMESPACE_ID; +namespace _pbi = ::PROTOBUF_NAMESPACE_ID::internal; +namespace connectrpc { +namespace conformance { +template +PROTOBUF_CONSTEXPR Payload::Payload( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.body_)*/ { + &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} + } + + , /*decltype(_impl_.type_)*/ 0 + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct PayloadDefaultTypeInternal { + PROTOBUF_CONSTEXPR PayloadDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~PayloadDefaultTypeInternal() {} + union { + Payload _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PayloadDefaultTypeInternal _Payload_default_instance_; +template +PROTOBUF_CONSTEXPR EchoStatus::EchoStatus( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.message_)*/ { + &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} + } + + , /*decltype(_impl_.code_)*/ 0 + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct EchoStatusDefaultTypeInternal { + PROTOBUF_CONSTEXPR EchoStatusDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~EchoStatusDefaultTypeInternal() {} + union { + EchoStatus _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EchoStatusDefaultTypeInternal _EchoStatus_default_instance_; +template +PROTOBUF_CONSTEXPR SimpleRequest::SimpleRequest( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.payload_)*/nullptr + , /*decltype(_impl_.response_compressed_)*/nullptr + , /*decltype(_impl_.response_status_)*/nullptr + , /*decltype(_impl_.expect_compressed_)*/nullptr + , /*decltype(_impl_.response_type_)*/ 0 + + , /*decltype(_impl_.response_size_)*/ 0 + + , /*decltype(_impl_.fill_username_)*/ false + + , /*decltype(_impl_.fill_oauth_scope_)*/ false + + , /*decltype(_impl_.fill_server_id_)*/ false + + , /*decltype(_impl_.fill_grpclb_route_type_)*/ false +} {} +struct SimpleRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR SimpleRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~SimpleRequestDefaultTypeInternal() {} + union { + SimpleRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SimpleRequestDefaultTypeInternal _SimpleRequest_default_instance_; +template +PROTOBUF_CONSTEXPR SimpleResponse::SimpleResponse( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.username_)*/ { + &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} + } + + , /*decltype(_impl_.oauth_scope_)*/ { + &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} + } + + , /*decltype(_impl_.server_id_)*/ { + &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} + } + + , /*decltype(_impl_.hostname_)*/ { + &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} + } + + , /*decltype(_impl_.payload_)*/nullptr + , /*decltype(_impl_.grpclb_route_type_)*/ 0 +} {} +struct SimpleResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR SimpleResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~SimpleResponseDefaultTypeInternal() {} + union { + SimpleResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SimpleResponseDefaultTypeInternal _SimpleResponse_default_instance_; +template +PROTOBUF_CONSTEXPR StreamingInputCallRequest::StreamingInputCallRequest( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.payload_)*/nullptr + , /*decltype(_impl_.expect_compressed_)*/nullptr} {} +struct StreamingInputCallRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR StreamingInputCallRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~StreamingInputCallRequestDefaultTypeInternal() {} + union { + StreamingInputCallRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StreamingInputCallRequestDefaultTypeInternal _StreamingInputCallRequest_default_instance_; +template +PROTOBUF_CONSTEXPR StreamingInputCallResponse::StreamingInputCallResponse( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.aggregated_payload_size_)*/ 0 + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct StreamingInputCallResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR StreamingInputCallResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~StreamingInputCallResponseDefaultTypeInternal() {} + union { + StreamingInputCallResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StreamingInputCallResponseDefaultTypeInternal _StreamingInputCallResponse_default_instance_; +template +PROTOBUF_CONSTEXPR ResponseParameters::ResponseParameters( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.compressed_)*/nullptr + , /*decltype(_impl_.size_)*/ 0 + + , /*decltype(_impl_.interval_us_)*/ 0 +} {} +struct ResponseParametersDefaultTypeInternal { + PROTOBUF_CONSTEXPR ResponseParametersDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ResponseParametersDefaultTypeInternal() {} + union { + ResponseParameters _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ResponseParametersDefaultTypeInternal _ResponseParameters_default_instance_; +template +PROTOBUF_CONSTEXPR StreamingOutputCallRequest::StreamingOutputCallRequest( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.response_parameters_)*/{} + , /*decltype(_impl_.payload_)*/nullptr + , /*decltype(_impl_.response_status_)*/nullptr + , /*decltype(_impl_.response_type_)*/ 0 +} {} +struct StreamingOutputCallRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR StreamingOutputCallRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~StreamingOutputCallRequestDefaultTypeInternal() {} + union { + StreamingOutputCallRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StreamingOutputCallRequestDefaultTypeInternal _StreamingOutputCallRequest_default_instance_; +template +PROTOBUF_CONSTEXPR StreamingOutputCallResponse::StreamingOutputCallResponse( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.payload_)*/nullptr} {} +struct StreamingOutputCallResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR StreamingOutputCallResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~StreamingOutputCallResponseDefaultTypeInternal() {} + union { + StreamingOutputCallResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StreamingOutputCallResponseDefaultTypeInternal _StreamingOutputCallResponse_default_instance_; +template +PROTOBUF_CONSTEXPR ReconnectParams::ReconnectParams( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.max_reconnect_backoff_ms_)*/ 0 + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct ReconnectParamsDefaultTypeInternal { + PROTOBUF_CONSTEXPR ReconnectParamsDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ReconnectParamsDefaultTypeInternal() {} + union { + ReconnectParams _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ReconnectParamsDefaultTypeInternal _ReconnectParams_default_instance_; +template +PROTOBUF_CONSTEXPR ReconnectInfo::ReconnectInfo( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.backoff_ms_)*/ {} + ,/* _impl_._backoff_ms_cached_byte_size_ = */ { 0 } + + , /*decltype(_impl_.passed_)*/ false + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct ReconnectInfoDefaultTypeInternal { + PROTOBUF_CONSTEXPR ReconnectInfoDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ReconnectInfoDefaultTypeInternal() {} + union { + ReconnectInfo _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ReconnectInfoDefaultTypeInternal _ReconnectInfo_default_instance_; +template +PROTOBUF_CONSTEXPR LoadBalancerStatsRequest::LoadBalancerStatsRequest( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.num_rpcs_)*/ 0 + + , /*decltype(_impl_.timeout_sec_)*/ 0 + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct LoadBalancerStatsRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR LoadBalancerStatsRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~LoadBalancerStatsRequestDefaultTypeInternal() {} + union { + LoadBalancerStatsRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LoadBalancerStatsRequestDefaultTypeInternal _LoadBalancerStatsRequest_default_instance_; +template +PROTOBUF_CONSTEXPR LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse::LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse( + ::_pbi::ConstantInitialized) {} +struct LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUseDefaultTypeInternal { + PROTOBUF_CONSTEXPR LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUseDefaultTypeInternal() {} + union { + LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUseDefaultTypeInternal _LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse_default_instance_; +template +PROTOBUF_CONSTEXPR LoadBalancerStatsResponse_RpcsByPeer::LoadBalancerStatsResponse_RpcsByPeer( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.rpcs_by_peer_)*/{} + , /*decltype(_impl_._cached_size_)*/{}} {} +struct LoadBalancerStatsResponse_RpcsByPeerDefaultTypeInternal { + PROTOBUF_CONSTEXPR LoadBalancerStatsResponse_RpcsByPeerDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~LoadBalancerStatsResponse_RpcsByPeerDefaultTypeInternal() {} + union { + LoadBalancerStatsResponse_RpcsByPeer _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LoadBalancerStatsResponse_RpcsByPeerDefaultTypeInternal _LoadBalancerStatsResponse_RpcsByPeer_default_instance_; +template +PROTOBUF_CONSTEXPR LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse::LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse( + ::_pbi::ConstantInitialized) {} +struct LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUseDefaultTypeInternal { + PROTOBUF_CONSTEXPR LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUseDefaultTypeInternal() {} + union { + LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUseDefaultTypeInternal _LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse_default_instance_; +template +PROTOBUF_CONSTEXPR LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse::LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse( + ::_pbi::ConstantInitialized) {} +struct LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUseDefaultTypeInternal { + PROTOBUF_CONSTEXPR LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUseDefaultTypeInternal() {} + union { + LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUseDefaultTypeInternal _LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse_default_instance_; +template +PROTOBUF_CONSTEXPR LoadBalancerStatsResponse::LoadBalancerStatsResponse( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.rpcs_by_peer_)*/{} + , /*decltype(_impl_.rpcs_by_method_)*/{} + , /*decltype(_impl_.num_failures_)*/ 0 + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct LoadBalancerStatsResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR LoadBalancerStatsResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~LoadBalancerStatsResponseDefaultTypeInternal() {} + union { + LoadBalancerStatsResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LoadBalancerStatsResponseDefaultTypeInternal _LoadBalancerStatsResponse_default_instance_; +template +PROTOBUF_CONSTEXPR LoadBalancerAccumulatedStatsRequest::LoadBalancerAccumulatedStatsRequest( + ::_pbi::ConstantInitialized) {} +struct LoadBalancerAccumulatedStatsRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR LoadBalancerAccumulatedStatsRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~LoadBalancerAccumulatedStatsRequestDefaultTypeInternal() {} + union { + LoadBalancerAccumulatedStatsRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LoadBalancerAccumulatedStatsRequestDefaultTypeInternal _LoadBalancerAccumulatedStatsRequest_default_instance_; +template +PROTOBUF_CONSTEXPR LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse::LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse( + ::_pbi::ConstantInitialized) {} +struct LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUseDefaultTypeInternal { + PROTOBUF_CONSTEXPR LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUseDefaultTypeInternal() {} + union { + LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUseDefaultTypeInternal _LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse_default_instance_; +template +PROTOBUF_CONSTEXPR LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse::LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse( + ::_pbi::ConstantInitialized) {} +struct LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUseDefaultTypeInternal { + PROTOBUF_CONSTEXPR LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUseDefaultTypeInternal() {} + union { + LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUseDefaultTypeInternal _LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse_default_instance_; +template +PROTOBUF_CONSTEXPR LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse::LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse( + ::_pbi::ConstantInitialized) {} +struct LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUseDefaultTypeInternal { + PROTOBUF_CONSTEXPR LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUseDefaultTypeInternal() {} + union { + LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUseDefaultTypeInternal _LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse_default_instance_; +template +PROTOBUF_CONSTEXPR LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse::LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse( + ::_pbi::ConstantInitialized) {} +struct LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUseDefaultTypeInternal { + PROTOBUF_CONSTEXPR LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUseDefaultTypeInternal() {} + union { + LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUseDefaultTypeInternal _LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse_default_instance_; +template +PROTOBUF_CONSTEXPR LoadBalancerAccumulatedStatsResponse_MethodStats::LoadBalancerAccumulatedStatsResponse_MethodStats( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.result_)*/{} + , /*decltype(_impl_.rpcs_started_)*/ 0 + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct LoadBalancerAccumulatedStatsResponse_MethodStatsDefaultTypeInternal { + PROTOBUF_CONSTEXPR LoadBalancerAccumulatedStatsResponse_MethodStatsDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~LoadBalancerAccumulatedStatsResponse_MethodStatsDefaultTypeInternal() {} + union { + LoadBalancerAccumulatedStatsResponse_MethodStats _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LoadBalancerAccumulatedStatsResponse_MethodStatsDefaultTypeInternal _LoadBalancerAccumulatedStatsResponse_MethodStats_default_instance_; +template +PROTOBUF_CONSTEXPR LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse::LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse( + ::_pbi::ConstantInitialized) {} +struct LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUseDefaultTypeInternal { + PROTOBUF_CONSTEXPR LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUseDefaultTypeInternal() {} + union { + LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUseDefaultTypeInternal _LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse_default_instance_; +template +PROTOBUF_CONSTEXPR LoadBalancerAccumulatedStatsResponse::LoadBalancerAccumulatedStatsResponse( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.num_rpcs_started_by_method_)*/{} + , /*decltype(_impl_.num_rpcs_succeeded_by_method_)*/{} + , /*decltype(_impl_.num_rpcs_failed_by_method_)*/{} + , /*decltype(_impl_.stats_per_method_)*/{} + , /*decltype(_impl_._cached_size_)*/{}} {} +struct LoadBalancerAccumulatedStatsResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR LoadBalancerAccumulatedStatsResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~LoadBalancerAccumulatedStatsResponseDefaultTypeInternal() {} + union { + LoadBalancerAccumulatedStatsResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LoadBalancerAccumulatedStatsResponseDefaultTypeInternal _LoadBalancerAccumulatedStatsResponse_default_instance_; +template +PROTOBUF_CONSTEXPR ClientConfigureRequest_Metadata::ClientConfigureRequest_Metadata( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.key_)*/ { + &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} + } + + , /*decltype(_impl_.value_)*/ { + &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} + } + + , /*decltype(_impl_.type_)*/ 0 + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct ClientConfigureRequest_MetadataDefaultTypeInternal { + PROTOBUF_CONSTEXPR ClientConfigureRequest_MetadataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ClientConfigureRequest_MetadataDefaultTypeInternal() {} + union { + ClientConfigureRequest_Metadata _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientConfigureRequest_MetadataDefaultTypeInternal _ClientConfigureRequest_Metadata_default_instance_; +template +PROTOBUF_CONSTEXPR ClientConfigureRequest::ClientConfigureRequest( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.types_)*/ {} + , /*decltype(_impl_._types_cached_byte_size_)*/ { 0 } + + , /*decltype(_impl_.metadata_)*/{} + , /*decltype(_impl_.timeout_sec_)*/ 0 + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct ClientConfigureRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR ClientConfigureRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ClientConfigureRequestDefaultTypeInternal() {} + union { + ClientConfigureRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientConfigureRequestDefaultTypeInternal _ClientConfigureRequest_default_instance_; +template +PROTOBUF_CONSTEXPR ClientConfigureResponse::ClientConfigureResponse( + ::_pbi::ConstantInitialized) {} +struct ClientConfigureResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR ClientConfigureResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ClientConfigureResponseDefaultTypeInternal() {} + union { + ClientConfigureResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientConfigureResponseDefaultTypeInternal _ClientConfigureResponse_default_instance_; +template +PROTOBUF_CONSTEXPR ErrorDetail::ErrorDetail( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.reason_)*/ { + &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} + } + + , /*decltype(_impl_.domain_)*/ { + &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} + } + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct ErrorDetailDefaultTypeInternal { + PROTOBUF_CONSTEXPR ErrorDetailDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ErrorDetailDefaultTypeInternal() {} + union { + ErrorDetail _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ErrorDetailDefaultTypeInternal _ErrorDetail_default_instance_; +template +PROTOBUF_CONSTEXPR ErrorStatus::ErrorStatus( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.details_)*/{} + , /*decltype(_impl_.message_)*/ { + &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} + } + + , /*decltype(_impl_.code_)*/ 0 + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct ErrorStatusDefaultTypeInternal { + PROTOBUF_CONSTEXPR ErrorStatusDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ErrorStatusDefaultTypeInternal() {} + union { + ErrorStatus _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ErrorStatusDefaultTypeInternal _ErrorStatus_default_instance_; +} // namespace conformance +} // namespace connectrpc +static ::_pb::Metadata file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto[30]; +static const ::_pb::EnumDescriptor* file_level_enum_descriptors_connectrpc_2fconformance_2fmessages_2eproto[3]; +static constexpr const ::_pb::ServiceDescriptor** + file_level_service_descriptors_connectrpc_2fconformance_2fmessages_2eproto = nullptr; +const ::uint32_t TableStruct_connectrpc_2fconformance_2fmessages_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( + protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::Payload, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::Payload, _impl_.type_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::Payload, _impl_.body_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::EchoStatus, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::EchoStatus, _impl_.code_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::EchoStatus, _impl_.message_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::SimpleRequest, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::SimpleRequest, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::SimpleRequest, _impl_.response_type_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::SimpleRequest, _impl_.response_size_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::SimpleRequest, _impl_.payload_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::SimpleRequest, _impl_.fill_username_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::SimpleRequest, _impl_.fill_oauth_scope_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::SimpleRequest, _impl_.response_compressed_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::SimpleRequest, _impl_.response_status_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::SimpleRequest, _impl_.expect_compressed_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::SimpleRequest, _impl_.fill_server_id_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::SimpleRequest, _impl_.fill_grpclb_route_type_), + ~0u, + ~0u, + 0, + ~0u, + ~0u, + 1, + 2, + 3, + ~0u, + ~0u, + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::SimpleResponse, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::SimpleResponse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::SimpleResponse, _impl_.payload_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::SimpleResponse, _impl_.username_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::SimpleResponse, _impl_.oauth_scope_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::SimpleResponse, _impl_.server_id_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::SimpleResponse, _impl_.grpclb_route_type_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::SimpleResponse, _impl_.hostname_), + 0, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::StreamingInputCallRequest, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::StreamingInputCallRequest, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::StreamingInputCallRequest, _impl_.payload_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::StreamingInputCallRequest, _impl_.expect_compressed_), + 0, + 1, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::StreamingInputCallResponse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::StreamingInputCallResponse, _impl_.aggregated_payload_size_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::ResponseParameters, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::ResponseParameters, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::ResponseParameters, _impl_.size_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::ResponseParameters, _impl_.interval_us_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::ResponseParameters, _impl_.compressed_), + ~0u, + ~0u, + 0, + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::StreamingOutputCallRequest, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::StreamingOutputCallRequest, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::StreamingOutputCallRequest, _impl_.response_type_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::StreamingOutputCallRequest, _impl_.response_parameters_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::StreamingOutputCallRequest, _impl_.payload_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::StreamingOutputCallRequest, _impl_.response_status_), + ~0u, + ~0u, + 0, + 1, + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::StreamingOutputCallResponse, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::StreamingOutputCallResponse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::StreamingOutputCallResponse, _impl_.payload_), + 0, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::ReconnectParams, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::ReconnectParams, _impl_.max_reconnect_backoff_ms_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::ReconnectInfo, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::ReconnectInfo, _impl_.passed_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::ReconnectInfo, _impl_.backoff_ms_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerStatsRequest, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerStatsRequest, _impl_.num_rpcs_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerStatsRequest, _impl_.timeout_sec_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse, _has_bits_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse, key_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse, value_), + 0, + 1, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeer, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeer, _impl_.rpcs_by_peer_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse, _has_bits_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse, key_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse, value_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse, _has_bits_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse, key_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse, value_), + 0, + 1, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerStatsResponse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerStatsResponse, _impl_.rpcs_by_peer_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerStatsResponse, _impl_.num_failures_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerStatsResponse, _impl_.rpcs_by_method_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse, _has_bits_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse, key_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse, value_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse, _has_bits_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse, key_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse, value_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse, _has_bits_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse, key_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse, value_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse, _has_bits_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse, key_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse, value_), + 0, + 1, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_MethodStats, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_MethodStats, _impl_.rpcs_started_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_MethodStats, _impl_.result_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse, _has_bits_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse, key_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse, value_), + 0, + 1, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse, _impl_.num_rpcs_started_by_method_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse, _impl_.num_rpcs_succeeded_by_method_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse, _impl_.num_rpcs_failed_by_method_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse, _impl_.stats_per_method_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::ClientConfigureRequest_Metadata, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::ClientConfigureRequest_Metadata, _impl_.type_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::ClientConfigureRequest_Metadata, _impl_.key_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::ClientConfigureRequest_Metadata, _impl_.value_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::ClientConfigureRequest, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::ClientConfigureRequest, _impl_.types_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::ClientConfigureRequest, _impl_.metadata_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::ClientConfigureRequest, _impl_.timeout_sec_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::ClientConfigureResponse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::ErrorDetail, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::ErrorDetail, _impl_.reason_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::ErrorDetail, _impl_.domain_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::ErrorStatus, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::ErrorStatus, _impl_.code_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::ErrorStatus, _impl_.message_), + PROTOBUF_FIELD_OFFSET(::connectrpc::conformance::ErrorStatus, _impl_.details_), +}; + +static const ::_pbi::MigrationSchema + schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + { 0, -1, -1, sizeof(::connectrpc::conformance::Payload)}, + { 10, -1, -1, sizeof(::connectrpc::conformance::EchoStatus)}, + { 20, 38, -1, sizeof(::connectrpc::conformance::SimpleRequest)}, + { 48, 62, -1, sizeof(::connectrpc::conformance::SimpleResponse)}, + { 68, 78, -1, sizeof(::connectrpc::conformance::StreamingInputCallRequest)}, + { 80, -1, -1, sizeof(::connectrpc::conformance::StreamingInputCallResponse)}, + { 89, 100, -1, sizeof(::connectrpc::conformance::ResponseParameters)}, + { 103, 115, -1, sizeof(::connectrpc::conformance::StreamingOutputCallRequest)}, + { 119, 128, -1, sizeof(::connectrpc::conformance::StreamingOutputCallResponse)}, + { 129, -1, -1, sizeof(::connectrpc::conformance::ReconnectParams)}, + { 138, -1, -1, sizeof(::connectrpc::conformance::ReconnectInfo)}, + { 148, -1, -1, sizeof(::connectrpc::conformance::LoadBalancerStatsRequest)}, + { 158, 168, -1, sizeof(::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse)}, + { 170, -1, -1, sizeof(::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeer)}, + { 179, 189, -1, sizeof(::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse)}, + { 191, 201, -1, sizeof(::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse)}, + { 203, -1, -1, sizeof(::connectrpc::conformance::LoadBalancerStatsResponse)}, + { 214, -1, -1, sizeof(::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest)}, + { 222, 232, -1, sizeof(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse)}, + { 234, 244, -1, sizeof(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse)}, + { 246, 256, -1, sizeof(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse)}, + { 258, 268, -1, sizeof(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse)}, + { 270, -1, -1, sizeof(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_MethodStats)}, + { 280, 290, -1, sizeof(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse)}, + { 292, -1, -1, sizeof(::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse)}, + { 304, -1, -1, sizeof(::connectrpc::conformance::ClientConfigureRequest_Metadata)}, + { 315, -1, -1, sizeof(::connectrpc::conformance::ClientConfigureRequest)}, + { 326, -1, -1, sizeof(::connectrpc::conformance::ClientConfigureResponse)}, + { 334, -1, -1, sizeof(::connectrpc::conformance::ErrorDetail)}, + { 344, -1, -1, sizeof(::connectrpc::conformance::ErrorStatus)}, +}; + +static const ::_pb::Message* const file_default_instances[] = { + &::connectrpc::conformance::_Payload_default_instance_._instance, + &::connectrpc::conformance::_EchoStatus_default_instance_._instance, + &::connectrpc::conformance::_SimpleRequest_default_instance_._instance, + &::connectrpc::conformance::_SimpleResponse_default_instance_._instance, + &::connectrpc::conformance::_StreamingInputCallRequest_default_instance_._instance, + &::connectrpc::conformance::_StreamingInputCallResponse_default_instance_._instance, + &::connectrpc::conformance::_ResponseParameters_default_instance_._instance, + &::connectrpc::conformance::_StreamingOutputCallRequest_default_instance_._instance, + &::connectrpc::conformance::_StreamingOutputCallResponse_default_instance_._instance, + &::connectrpc::conformance::_ReconnectParams_default_instance_._instance, + &::connectrpc::conformance::_ReconnectInfo_default_instance_._instance, + &::connectrpc::conformance::_LoadBalancerStatsRequest_default_instance_._instance, + &::connectrpc::conformance::_LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse_default_instance_._instance, + &::connectrpc::conformance::_LoadBalancerStatsResponse_RpcsByPeer_default_instance_._instance, + &::connectrpc::conformance::_LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse_default_instance_._instance, + &::connectrpc::conformance::_LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse_default_instance_._instance, + &::connectrpc::conformance::_LoadBalancerStatsResponse_default_instance_._instance, + &::connectrpc::conformance::_LoadBalancerAccumulatedStatsRequest_default_instance_._instance, + &::connectrpc::conformance::_LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse_default_instance_._instance, + &::connectrpc::conformance::_LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse_default_instance_._instance, + &::connectrpc::conformance::_LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse_default_instance_._instance, + &::connectrpc::conformance::_LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse_default_instance_._instance, + &::connectrpc::conformance::_LoadBalancerAccumulatedStatsResponse_MethodStats_default_instance_._instance, + &::connectrpc::conformance::_LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse_default_instance_._instance, + &::connectrpc::conformance::_LoadBalancerAccumulatedStatsResponse_default_instance_._instance, + &::connectrpc::conformance::_ClientConfigureRequest_Metadata_default_instance_._instance, + &::connectrpc::conformance::_ClientConfigureRequest_default_instance_._instance, + &::connectrpc::conformance::_ClientConfigureResponse_default_instance_._instance, + &::connectrpc::conformance::_ErrorDetail_default_instance_._instance, + &::connectrpc::conformance::_ErrorStatus_default_instance_._instance, +}; +const char descriptor_table_protodef_connectrpc_2fconformance_2fmessages_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + "\n%connectrpc/conformance/messages.proto\022" + "\026connectrpc.conformance\032\031google/protobuf" + "/any.proto\032\036google/protobuf/wrappers.pro" + "to\"V\n\007Payload\0227\n\004type\030\001 \001(\0162#.connectrpc" + ".conformance.PayloadTypeR\004type\022\022\n\004body\030\002" + " \001(\014R\004body\":\n\nEchoStatus\022\022\n\004code\030\001 \001(\005R\004" + "code\022\030\n\007message\030\002 \001(\tR\007message\"\306\004\n\rSimpl" + "eRequest\022H\n\rresponse_type\030\001 \001(\0162#.connec" + "trpc.conformance.PayloadTypeR\014responseTy" + "pe\022#\n\rresponse_size\030\002 \001(\005R\014responseSize\022" + "9\n\007payload\030\003 \001(\0132\037.connectrpc.conformanc" + "e.PayloadR\007payload\022#\n\rfill_username\030\004 \001(" + "\010R\014fillUsername\022(\n\020fill_oauth_scope\030\005 \001(" + "\010R\016fillOauthScope\022K\n\023response_compressed" + "\030\006 \001(\0132\032.google.protobuf.BoolValueR\022resp" + "onseCompressed\022K\n\017response_status\030\007 \001(\0132" + "\".connectrpc.conformance.EchoStatusR\016res" + "ponseStatus\022G\n\021expect_compressed\030\010 \001(\0132\032" + ".google.protobuf.BoolValueR\020expectCompre" + "ssed\022$\n\016fill_server_id\030\t \001(\010R\014fillServer" + "Id\0223\n\026fill_grpclb_route_type\030\n \001(\010R\023fill" + "GrpclbRouteType\"\226\002\n\016SimpleResponse\0229\n\007pa" + "yload\030\001 \001(\0132\037.connectrpc.conformance.Pay" + "loadR\007payload\022\032\n\010username\030\002 \001(\tR\010usernam" + "e\022\037\n\013oauth_scope\030\003 \001(\tR\noauthScope\022\033\n\tse" + "rver_id\030\004 \001(\tR\010serverId\022S\n\021grpclb_route_" + "type\030\005 \001(\0162\'.connectrpc.conformance.Grpc" + "lbRouteTypeR\017grpclbRouteType\022\032\n\010hostname" + "\030\006 \001(\tR\010hostname\"\237\001\n\031StreamingInputCallR" + "equest\0229\n\007payload\030\001 \001(\0132\037.connectrpc.con" + "formance.PayloadR\007payload\022G\n\021expect_comp" + "ressed\030\002 \001(\0132\032.google.protobuf.BoolValue" + "R\020expectCompressed\"T\n\032StreamingInputCall" + "Response\0226\n\027aggregated_payload_size\030\001 \001(" + "\005R\025aggregatedPayloadSize\"\205\001\n\022ResponsePar" + "ameters\022\022\n\004size\030\001 \001(\005R\004size\022\037\n\013interval_" + "us\030\002 \001(\005R\nintervalUs\022:\n\ncompressed\030\003 \001(\013" + "2\032.google.protobuf.BoolValueR\ncompressed" + "\"\313\002\n\032StreamingOutputCallRequest\022H\n\rrespo" + "nse_type\030\001 \001(\0162#.connectrpc.conformance." + "PayloadTypeR\014responseType\022[\n\023response_pa" + "rameters\030\002 \003(\0132*.connectrpc.conformance." + "ResponseParametersR\022responseParameters\0229" + "\n\007payload\030\003 \001(\0132\037.connectrpc.conformance" + ".PayloadR\007payload\022K\n\017response_status\030\007 \001" + "(\0132\".connectrpc.conformance.EchoStatusR\016" + "responseStatus\"X\n\033StreamingOutputCallRes" + "ponse\0229\n\007payload\030\001 \001(\0132\037.connectrpc.conf" + "ormance.PayloadR\007payload\"J\n\017ReconnectPar" + "ams\0227\n\030max_reconnect_backoff_ms\030\001 \001(\005R\025m" + "axReconnectBackoffMs\"F\n\rReconnectInfo\022\026\n" + "\006passed\030\001 \001(\010R\006passed\022\035\n\nbackoff_ms\030\002 \003(" + "\005R\tbackoffMs\"V\n\030LoadBalancerStatsRequest" + "\022\031\n\010num_rpcs\030\001 \001(\005R\007numRpcs\022\037\n\013timeout_s" + "ec\030\002 \001(\005R\ntimeoutSec\"\212\005\n\031LoadBalancerSta" + "tsResponse\022c\n\014rpcs_by_peer\030\001 \003(\0132A.conne" + "ctrpc.conformance.LoadBalancerStatsRespo" + "nse.RpcsByPeerEntryR\nrpcsByPeer\022!\n\014num_f" + "ailures\030\002 \001(\005R\013numFailures\022i\n\016rpcs_by_me" + "thod\030\003 \003(\0132C.connectrpc.conformance.Load" + "BalancerStatsResponse.RpcsByMethodEntryR" + "\014rpcsByMethod\032\273\001\n\nRpcsByPeer\022n\n\014rpcs_by_" + "peer\030\001 \003(\0132L.connectrpc.conformance.Load" + "BalancerStatsResponse.RpcsByPeer.RpcsByP" + "eerEntryR\nrpcsByPeer\032=\n\017RpcsByPeerEntry\022" + "\020\n\003key\030\001 \001(\tR\003key\022\024\n\005value\030\002 \001(\005R\005value:" + "\0028\001\032=\n\017RpcsByPeerEntry\022\020\n\003key\030\001 \001(\tR\003key" + "\022\024\n\005value\030\002 \001(\005R\005value:\0028\001\032}\n\021RpcsByMeth" + "odEntry\022\020\n\003key\030\001 \001(\tR\003key\022R\n\005value\030\002 \001(\013" + "2<.connectrpc.conformance.LoadBalancerSt" + "atsResponse.RpcsByPeerR\005value:\0028\001\"%\n#Loa" + "dBalancerAccumulatedStatsRequest\"\302\t\n$Loa" + "dBalancerAccumulatedStatsResponse\022\230\001\n\032nu" + "m_rpcs_started_by_method\030\001 \003(\0132X.connect" + "rpc.conformance.LoadBalancerAccumulatedS" + "tatsResponse.NumRpcsStartedByMethodEntry" + "B\002\030\001R\026numRpcsStartedByMethod\022\236\001\n\034num_rpc" + "s_succeeded_by_method\030\002 \003(\0132Z.connectrpc" + ".conformance.LoadBalancerAccumulatedStat" + "sResponse.NumRpcsSucceededByMethodEntryB" + "\002\030\001R\030numRpcsSucceededByMethod\022\225\001\n\031num_rp" + "cs_failed_by_method\030\003 \003(\0132W.connectrpc.c" + "onformance.LoadBalancerAccumulatedStatsR" + "esponse.NumRpcsFailedByMethodEntryB\002\030\001R\025" + "numRpcsFailedByMethod\022z\n\020stats_per_metho" + "d\030\004 \003(\0132P.connectrpc.conformance.LoadBal" + "ancerAccumulatedStatsResponse.StatsPerMe" + "thodEntryR\016statsPerMethod\032I\n\033NumRpcsStar" + "tedByMethodEntry\022\020\n\003key\030\001 \001(\tR\003key\022\024\n\005va" + "lue\030\002 \001(\005R\005value:\0028\001\032K\n\035NumRpcsSucceeded" + "ByMethodEntry\022\020\n\003key\030\001 \001(\tR\003key\022\024\n\005value" + "\030\002 \001(\005R\005value:\0028\001\032H\n\032NumRpcsFailedByMeth" + "odEntry\022\020\n\003key\030\001 \001(\tR\003key\022\024\n\005value\030\002 \001(\005" + "R\005value:\0028\001\032\331\001\n\013MethodStats\022!\n\014rpcs_star" + "ted\030\001 \001(\005R\013rpcsStarted\022l\n\006result\030\002 \003(\0132T" + ".connectrpc.conformance.LoadBalancerAccu" + "mulatedStatsResponse.MethodStats.ResultE" + "ntryR\006result\0329\n\013ResultEntry\022\020\n\003key\030\001 \001(\005" + "R\003key\022\024\n\005value\030\002 \001(\005R\005value:\0028\001\032\213\001\n\023Stat" + "sPerMethodEntry\022\020\n\003key\030\001 \001(\tR\003key\022^\n\005val" + "ue\030\002 \001(\0132H.connectrpc.conformance.LoadBa" + "lancerAccumulatedStatsResponse.MethodSta" + "tsR\005value:\0028\001\"\207\003\n\026ClientConfigureRequest" + "\022L\n\005types\030\001 \003(\01626.connectrpc.conformance" + ".ClientConfigureRequest.RpcTypeR\005types\022S" + "\n\010metadata\030\002 \003(\01327.connectrpc.conformanc" + "e.ClientConfigureRequest.MetadataR\010metad" + "ata\022\037\n\013timeout_sec\030\003 \001(\005R\ntimeoutSec\032~\n\010" + "Metadata\022J\n\004type\030\001 \001(\01626.connectrpc.conf" + "ormance.ClientConfigureRequest.RpcTypeR\004" + "type\022\020\n\003key\030\002 \001(\tR\003key\022\024\n\005value\030\003 \001(\tR\005v" + "alue\")\n\007RpcType\022\016\n\nEMPTY_CALL\020\000\022\016\n\nUNARY" + "_CALL\020\001\"\031\n\027ClientConfigureResponse\"=\n\013Er" + "rorDetail\022\026\n\006reason\030\001 \001(\tR\006reason\022\026\n\006dom" + "ain\030\002 \001(\tR\006domain\"k\n\013ErrorStatus\022\022\n\004code" + "\030\001 \001(\005R\004code\022\030\n\007message\030\002 \001(\tR\007message\022." + "\n\007details\030\003 \003(\0132\024.google.protobuf.AnyR\007d" + "etails*\037\n\013PayloadType\022\020\n\014COMPRESSABLE\020\000*" + "o\n\017GrpclbRouteType\022\035\n\031GRPCLB_ROUTE_TYPE_" + "UNKNOWN\020\000\022\036\n\032GRPCLB_ROUTE_TYPE_FALLBACK\020" + "\001\022\035\n\031GRPCLB_ROUTE_TYPE_BACKEND\020\002B\370\001\n\032com" + ".connectrpc.conformanceB\rMessagesProtoP\001" + "ZRgithub.com/bufbuild/connect-crosstest/" + "internal/gen/proto/go/connectrpc/conform" + "ance\242\002\003CCX\252\002\026Connectrpc.Conformance\312\002\026Co" + "nnectrpc\\Conformance\342\002\"Connectrpc\\Confor" + "mance\\GPBMetadata\352\002\027Connectrpc::Conforma" + "nceb\006proto3" +}; +static const ::_pbi::DescriptorTable* const descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_deps[2] = + { + &::descriptor_table_google_2fprotobuf_2fany_2eproto, + &::descriptor_table_google_2fprotobuf_2fwrappers_2eproto, +}; +static ::absl::once_flag descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once; +const ::_pbi::DescriptorTable descriptor_table_connectrpc_2fconformance_2fmessages_2eproto = { + false, + false, + 5091, + descriptor_table_protodef_connectrpc_2fconformance_2fmessages_2eproto, + "connectrpc/conformance/messages.proto", + &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once, + descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_deps, + 2, + 30, + schemas, + file_default_instances, + TableStruct_connectrpc_2fconformance_2fmessages_2eproto::offsets, + file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto, + file_level_enum_descriptors_connectrpc_2fconformance_2fmessages_2eproto, + file_level_service_descriptors_connectrpc_2fconformance_2fmessages_2eproto, +}; + +// This function exists to be marked as weak. +// It can significantly speed up compilation by breaking up LLVM's SCC +// in the .pb.cc translation units. Large translation units see a +// reduction of more than 35% of walltime for optimized builds. Without +// the weak attribute all the messages in the file, including all the +// vtables and everything they use become part of the same SCC through +// a cycle like: +// GetMetadata -> descriptor table -> default instances -> +// vtables -> GetMetadata +// By adding a weak function here we break the connection from the +// individual vtables back into the descriptor table. +PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_getter() { + return &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto; +} +// Force running AddDescriptors() at dynamic initialization time. +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 +static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_connectrpc_2fconformance_2fmessages_2eproto(&descriptor_table_connectrpc_2fconformance_2fmessages_2eproto); +namespace connectrpc { +namespace conformance { +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientConfigureRequest_RpcType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_connectrpc_2fconformance_2fmessages_2eproto); + return file_level_enum_descriptors_connectrpc_2fconformance_2fmessages_2eproto[0]; +} +bool ClientConfigureRequest_RpcType_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} +#if (__cplusplus < 201703) && \ + (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) + +constexpr ClientConfigureRequest_RpcType ClientConfigureRequest::EMPTY_CALL; +constexpr ClientConfigureRequest_RpcType ClientConfigureRequest::UNARY_CALL; +constexpr ClientConfigureRequest_RpcType ClientConfigureRequest::RpcType_MIN; +constexpr ClientConfigureRequest_RpcType ClientConfigureRequest::RpcType_MAX; +constexpr int ClientConfigureRequest::RpcType_ARRAYSIZE; + +#endif // (__cplusplus < 201703) && + // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PayloadType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_connectrpc_2fconformance_2fmessages_2eproto); + return file_level_enum_descriptors_connectrpc_2fconformance_2fmessages_2eproto[1]; +} +bool PayloadType_IsValid(int value) { + switch (value) { + case 0: + return true; + default: + return false; + } +} +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* GrpclbRouteType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_connectrpc_2fconformance_2fmessages_2eproto); + return file_level_enum_descriptors_connectrpc_2fconformance_2fmessages_2eproto[2]; +} +bool GrpclbRouteType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} +// =================================================================== + +class Payload::_Internal { + public: +}; + +Payload::Payload(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:connectrpc.conformance.Payload) +} +Payload::Payload(const Payload& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Payload* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.body_) {} + + , decltype(_impl_.type_) {} + + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.body_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.body_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_body().empty()) { + _this->_impl_.body_.Set(from._internal_body(), _this->GetArenaForAllocation()); + } + _this->_impl_.type_ = from._impl_.type_; + // @@protoc_insertion_point(copy_constructor:connectrpc.conformance.Payload) +} + +inline void Payload::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.body_) {} + + , decltype(_impl_.type_) { 0 } + + , /*decltype(_impl_._cached_size_)*/{} + }; + _impl_.body_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.body_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Payload::~Payload() { + // @@protoc_insertion_point(destructor:connectrpc.conformance.Payload) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Payload::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.body_.Destroy(); +} + +void Payload::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Payload::Clear() { +// @@protoc_insertion_point(message_clear_start:connectrpc.conformance.Payload) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.body_.ClearToEmpty(); + _impl_.type_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Payload::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .connectrpc.conformance.PayloadType type = 1 [json_name = "type"]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) { + ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + _internal_set_type(static_cast<::connectrpc::conformance::PayloadType>(val)); + } else { + goto handle_unusual; + } + continue; + // bytes body = 2 [json_name = "body"]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { + auto str = _internal_mutable_body(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* Payload::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:connectrpc.conformance.Payload) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // .connectrpc.conformance.PayloadType type = 1 [json_name = "type"]; + if (this->_internal_type() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this->_internal_type(), target); + } + + // bytes body = 2 [json_name = "body"]; + if (!this->_internal_body().empty()) { + const std::string& _s = this->_internal_body(); + target = stream->WriteBytesMaybeAliased(2, _s, target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:connectrpc.conformance.Payload) + return target; +} + +::size_t Payload::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:connectrpc.conformance.Payload) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // bytes body = 2 [json_name = "body"]; + if (!this->_internal_body().empty()) { + total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_body()); + } + + // .connectrpc.conformance.PayloadType type = 1 [json_name = "type"]; + if (this->_internal_type() != 0) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_type()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Payload::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Payload::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Payload::GetClassData() const { return &_class_data_; } + + +void Payload::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:connectrpc.conformance.Payload) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_body().empty()) { + _this->_internal_set_body(from._internal_body()); + } + if (from._internal_type() != 0) { + _this->_internal_set_type(from._internal_type()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Payload::CopyFrom(const Payload& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:connectrpc.conformance.Payload) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Payload::IsInitialized() const { + return true; +} + +void Payload::InternalSwap(Payload* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.body_, lhs_arena, + &other->_impl_.body_, rhs_arena); + swap(_impl_.type_, other->_impl_.type_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Payload::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_getter, &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once, + file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto[0]); +} +// =================================================================== + +class EchoStatus::_Internal { + public: +}; + +EchoStatus::EchoStatus(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:connectrpc.conformance.EchoStatus) +} +EchoStatus::EchoStatus(const EchoStatus& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + EchoStatus* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.message_) {} + + , decltype(_impl_.code_) {} + + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.message_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.message_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_message().empty()) { + _this->_impl_.message_.Set(from._internal_message(), _this->GetArenaForAllocation()); + } + _this->_impl_.code_ = from._impl_.code_; + // @@protoc_insertion_point(copy_constructor:connectrpc.conformance.EchoStatus) +} + +inline void EchoStatus::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.message_) {} + + , decltype(_impl_.code_) { 0 } + + , /*decltype(_impl_._cached_size_)*/{} + }; + _impl_.message_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.message_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +EchoStatus::~EchoStatus() { + // @@protoc_insertion_point(destructor:connectrpc.conformance.EchoStatus) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void EchoStatus::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.message_.Destroy(); +} + +void EchoStatus::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void EchoStatus::Clear() { +// @@protoc_insertion_point(message_clear_start:connectrpc.conformance.EchoStatus) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.message_.ClearToEmpty(); + _impl_.code_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* EchoStatus::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int32 code = 1 [json_name = "code"]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) { + _impl_.code_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // string message = 2 [json_name = "message"]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { + auto str = _internal_mutable_message(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + CHK_(::_pbi::VerifyUTF8(str, "connectrpc.conformance.EchoStatus.message")); + } else { + goto handle_unusual; + } + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* EchoStatus::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:connectrpc.conformance.EchoStatus) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // int32 code = 1 [json_name = "code"]; + if (this->_internal_code() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray( + 1, this->_internal_code(), target); + } + + // string message = 2 [json_name = "message"]; + if (!this->_internal_message().empty()) { + const std::string& _s = this->_internal_message(); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "connectrpc.conformance.EchoStatus.message"); + target = stream->WriteStringMaybeAliased(2, _s, target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:connectrpc.conformance.EchoStatus) + return target; +} + +::size_t EchoStatus::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:connectrpc.conformance.EchoStatus) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string message = 2 [json_name = "message"]; + if (!this->_internal_message().empty()) { + total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_message()); + } + + // int32 code = 1 [json_name = "code"]; + if (this->_internal_code() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_code()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData EchoStatus::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + EchoStatus::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*EchoStatus::GetClassData() const { return &_class_data_; } + + +void EchoStatus::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:connectrpc.conformance.EchoStatus) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_message().empty()) { + _this->_internal_set_message(from._internal_message()); + } + if (from._internal_code() != 0) { + _this->_internal_set_code(from._internal_code()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void EchoStatus::CopyFrom(const EchoStatus& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:connectrpc.conformance.EchoStatus) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool EchoStatus::IsInitialized() const { + return true; +} + +void EchoStatus::InternalSwap(EchoStatus* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.message_, lhs_arena, + &other->_impl_.message_, rhs_arena); + + swap(_impl_.code_, other->_impl_.code_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata EchoStatus::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_getter, &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once, + file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto[1]); +} +// =================================================================== + +class SimpleRequest::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(SimpleRequest, _impl_._has_bits_); + static const ::connectrpc::conformance::Payload& payload(const SimpleRequest* msg); + static void set_has_payload(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::PROTOBUF_NAMESPACE_ID::BoolValue& response_compressed(const SimpleRequest* msg); + static void set_has_response_compressed(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::connectrpc::conformance::EchoStatus& response_status(const SimpleRequest* msg); + static void set_has_response_status(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static const ::PROTOBUF_NAMESPACE_ID::BoolValue& expect_compressed(const SimpleRequest* msg); + static void set_has_expect_compressed(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +const ::connectrpc::conformance::Payload& +SimpleRequest::_Internal::payload(const SimpleRequest* msg) { + return *msg->_impl_.payload_; +} +const ::PROTOBUF_NAMESPACE_ID::BoolValue& +SimpleRequest::_Internal::response_compressed(const SimpleRequest* msg) { + return *msg->_impl_.response_compressed_; +} +const ::connectrpc::conformance::EchoStatus& +SimpleRequest::_Internal::response_status(const SimpleRequest* msg) { + return *msg->_impl_.response_status_; +} +const ::PROTOBUF_NAMESPACE_ID::BoolValue& +SimpleRequest::_Internal::expect_compressed(const SimpleRequest* msg) { + return *msg->_impl_.expect_compressed_; +} +void SimpleRequest::clear_response_compressed() { + if (_impl_.response_compressed_ != nullptr) _impl_.response_compressed_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +void SimpleRequest::clear_expect_compressed() { + if (_impl_.expect_compressed_ != nullptr) _impl_.expect_compressed_->Clear(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +SimpleRequest::SimpleRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:connectrpc.conformance.SimpleRequest) +} +SimpleRequest::SimpleRequest(const SimpleRequest& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SimpleRequest* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.payload_){nullptr} + , decltype(_impl_.response_compressed_){nullptr} + , decltype(_impl_.response_status_){nullptr} + , decltype(_impl_.expect_compressed_){nullptr} + , decltype(_impl_.response_type_) {} + + , decltype(_impl_.response_size_) {} + + , decltype(_impl_.fill_username_) {} + + , decltype(_impl_.fill_oauth_scope_) {} + + , decltype(_impl_.fill_server_id_) {} + + , decltype(_impl_.fill_grpclb_route_type_) {} + }; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) { + _this->_impl_.payload_ = new ::connectrpc::conformance::Payload(*from._impl_.payload_); + } + if ((from._impl_._has_bits_[0] & 0x00000002u) != 0) { + _this->_impl_.response_compressed_ = new ::PROTOBUF_NAMESPACE_ID::BoolValue(*from._impl_.response_compressed_); + } + if ((from._impl_._has_bits_[0] & 0x00000004u) != 0) { + _this->_impl_.response_status_ = new ::connectrpc::conformance::EchoStatus(*from._impl_.response_status_); + } + if ((from._impl_._has_bits_[0] & 0x00000008u) != 0) { + _this->_impl_.expect_compressed_ = new ::PROTOBUF_NAMESPACE_ID::BoolValue(*from._impl_.expect_compressed_); + } + ::memcpy(&_impl_.response_type_, &from._impl_.response_type_, + static_cast<::size_t>(reinterpret_cast(&_impl_.fill_grpclb_route_type_) - + reinterpret_cast(&_impl_.response_type_)) + sizeof(_impl_.fill_grpclb_route_type_)); + // @@protoc_insertion_point(copy_constructor:connectrpc.conformance.SimpleRequest) +} + +inline void SimpleRequest::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.payload_){nullptr} + , decltype(_impl_.response_compressed_){nullptr} + , decltype(_impl_.response_status_){nullptr} + , decltype(_impl_.expect_compressed_){nullptr} + , decltype(_impl_.response_type_) { 0 } + + , decltype(_impl_.response_size_) { 0 } + + , decltype(_impl_.fill_username_) { false } + + , decltype(_impl_.fill_oauth_scope_) { false } + + , decltype(_impl_.fill_server_id_) { false } + + , decltype(_impl_.fill_grpclb_route_type_) { false } + + }; +} + +SimpleRequest::~SimpleRequest() { + // @@protoc_insertion_point(destructor:connectrpc.conformance.SimpleRequest) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SimpleRequest::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.payload_; + if (this != internal_default_instance()) delete _impl_.response_compressed_; + if (this != internal_default_instance()) delete _impl_.response_status_; + if (this != internal_default_instance()) delete _impl_.expect_compressed_; +} + +void SimpleRequest::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SimpleRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:connectrpc.conformance.SimpleRequest) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(_impl_.payload_ != nullptr); + _impl_.payload_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + ABSL_DCHECK(_impl_.response_compressed_ != nullptr); + _impl_.response_compressed_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + ABSL_DCHECK(_impl_.response_status_ != nullptr); + _impl_.response_status_->Clear(); + } + if (cached_has_bits & 0x00000008u) { + ABSL_DCHECK(_impl_.expect_compressed_ != nullptr); + _impl_.expect_compressed_->Clear(); + } + } + ::memset(&_impl_.response_type_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.fill_grpclb_route_type_) - + reinterpret_cast(&_impl_.response_type_)) + sizeof(_impl_.fill_grpclb_route_type_)); + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SimpleRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .connectrpc.conformance.PayloadType response_type = 1 [json_name = "responseType"]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) { + ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + _internal_set_response_type(static_cast<::connectrpc::conformance::PayloadType>(val)); + } else { + goto handle_unusual; + } + continue; + // int32 response_size = 2 [json_name = "responseSize"]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) { + _impl_.response_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // .connectrpc.conformance.Payload payload = 3 [json_name = "payload"]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_payload(), ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // bool fill_username = 4 [json_name = "fillUsername"]; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) { + _impl_.fill_username_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // bool fill_oauth_scope = 5 [json_name = "fillOauthScope"]; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) { + _impl_.fill_oauth_scope_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // .google.protobuf.BoolValue response_compressed = 6 [json_name = "responseCompressed"]; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_response_compressed(), ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // .connectrpc.conformance.EchoStatus response_status = 7 [json_name = "responseStatus"]; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_response_status(), ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // .google.protobuf.BoolValue expect_compressed = 8 [json_name = "expectCompressed"]; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 66)) { + ptr = ctx->ParseMessage(_internal_mutable_expect_compressed(), ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // bool fill_server_id = 9 [json_name = "fillServerId"]; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 72)) { + _impl_.fill_server_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // bool fill_grpclb_route_type = 10 [json_name = "fillGrpclbRouteType"]; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 80)) { + _impl_.fill_grpclb_route_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* SimpleRequest::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:connectrpc.conformance.SimpleRequest) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // .connectrpc.conformance.PayloadType response_type = 1 [json_name = "responseType"]; + if (this->_internal_response_type() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this->_internal_response_type(), target); + } + + // int32 response_size = 2 [json_name = "responseSize"]; + if (this->_internal_response_size() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray( + 2, this->_internal_response_size(), target); + } + + cached_has_bits = _impl_._has_bits_[0]; + // .connectrpc.conformance.Payload payload = 3 [json_name = "payload"]; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::payload(this), + _Internal::payload(this).GetCachedSize(), target, stream); + } + + // bool fill_username = 4 [json_name = "fillUsername"]; + if (this->_internal_fill_username() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 4, this->_internal_fill_username(), target); + } + + // bool fill_oauth_scope = 5 [json_name = "fillOauthScope"]; + if (this->_internal_fill_oauth_scope() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 5, this->_internal_fill_oauth_scope(), target); + } + + // .google.protobuf.BoolValue response_compressed = 6 [json_name = "responseCompressed"]; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(6, _Internal::response_compressed(this), + _Internal::response_compressed(this).GetCachedSize(), target, stream); + } + + // .connectrpc.conformance.EchoStatus response_status = 7 [json_name = "responseStatus"]; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(7, _Internal::response_status(this), + _Internal::response_status(this).GetCachedSize(), target, stream); + } + + // .google.protobuf.BoolValue expect_compressed = 8 [json_name = "expectCompressed"]; + if (cached_has_bits & 0x00000008u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(8, _Internal::expect_compressed(this), + _Internal::expect_compressed(this).GetCachedSize(), target, stream); + } + + // bool fill_server_id = 9 [json_name = "fillServerId"]; + if (this->_internal_fill_server_id() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 9, this->_internal_fill_server_id(), target); + } + + // bool fill_grpclb_route_type = 10 [json_name = "fillGrpclbRouteType"]; + if (this->_internal_fill_grpclb_route_type() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 10, this->_internal_fill_grpclb_route_type(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:connectrpc.conformance.SimpleRequest) + return target; +} + +::size_t SimpleRequest::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:connectrpc.conformance.SimpleRequest) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // .connectrpc.conformance.Payload payload = 3 [json_name = "payload"]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.payload_); + } + + // .google.protobuf.BoolValue response_compressed = 6 [json_name = "responseCompressed"]; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.response_compressed_); + } + + // .connectrpc.conformance.EchoStatus response_status = 7 [json_name = "responseStatus"]; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.response_status_); + } + + // .google.protobuf.BoolValue expect_compressed = 8 [json_name = "expectCompressed"]; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.expect_compressed_); + } + + } + // .connectrpc.conformance.PayloadType response_type = 1 [json_name = "responseType"]; + if (this->_internal_response_type() != 0) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_response_type()); + } + + // int32 response_size = 2 [json_name = "responseSize"]; + if (this->_internal_response_size() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_response_size()); + } + + // bool fill_username = 4 [json_name = "fillUsername"]; + if (this->_internal_fill_username() != 0) { + total_size += 2; + } + + // bool fill_oauth_scope = 5 [json_name = "fillOauthScope"]; + if (this->_internal_fill_oauth_scope() != 0) { + total_size += 2; + } + + // bool fill_server_id = 9 [json_name = "fillServerId"]; + if (this->_internal_fill_server_id() != 0) { + total_size += 2; + } + + // bool fill_grpclb_route_type = 10 [json_name = "fillGrpclbRouteType"]; + if (this->_internal_fill_grpclb_route_type() != 0) { + total_size += 2; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SimpleRequest::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SimpleRequest::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SimpleRequest::GetClassData() const { return &_class_data_; } + + +void SimpleRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:connectrpc.conformance.SimpleRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_payload()->::connectrpc::conformance::Payload::MergeFrom( + from._internal_payload()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_response_compressed()->::PROTOBUF_NAMESPACE_ID::BoolValue::MergeFrom( + from._internal_response_compressed()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_response_status()->::connectrpc::conformance::EchoStatus::MergeFrom( + from._internal_response_status()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_mutable_expect_compressed()->::PROTOBUF_NAMESPACE_ID::BoolValue::MergeFrom( + from._internal_expect_compressed()); + } + } + if (from._internal_response_type() != 0) { + _this->_internal_set_response_type(from._internal_response_type()); + } + if (from._internal_response_size() != 0) { + _this->_internal_set_response_size(from._internal_response_size()); + } + if (from._internal_fill_username() != 0) { + _this->_internal_set_fill_username(from._internal_fill_username()); + } + if (from._internal_fill_oauth_scope() != 0) { + _this->_internal_set_fill_oauth_scope(from._internal_fill_oauth_scope()); + } + if (from._internal_fill_server_id() != 0) { + _this->_internal_set_fill_server_id(from._internal_fill_server_id()); + } + if (from._internal_fill_grpclb_route_type() != 0) { + _this->_internal_set_fill_grpclb_route_type(from._internal_fill_grpclb_route_type()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SimpleRequest::CopyFrom(const SimpleRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:connectrpc.conformance.SimpleRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SimpleRequest::IsInitialized() const { + return true; +} + +void SimpleRequest::InternalSwap(SimpleRequest* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SimpleRequest, _impl_.fill_grpclb_route_type_) + + sizeof(SimpleRequest::_impl_.fill_grpclb_route_type_) + - PROTOBUF_FIELD_OFFSET(SimpleRequest, _impl_.payload_)>( + reinterpret_cast(&_impl_.payload_), + reinterpret_cast(&other->_impl_.payload_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SimpleRequest::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_getter, &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once, + file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto[2]); +} +// =================================================================== + +class SimpleResponse::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(SimpleResponse, _impl_._has_bits_); + static const ::connectrpc::conformance::Payload& payload(const SimpleResponse* msg); + static void set_has_payload(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +const ::connectrpc::conformance::Payload& +SimpleResponse::_Internal::payload(const SimpleResponse* msg) { + return *msg->_impl_.payload_; +} +SimpleResponse::SimpleResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:connectrpc.conformance.SimpleResponse) +} +SimpleResponse::SimpleResponse(const SimpleResponse& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SimpleResponse* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.username_) {} + + , decltype(_impl_.oauth_scope_) {} + + , decltype(_impl_.server_id_) {} + + , decltype(_impl_.hostname_) {} + + , decltype(_impl_.payload_){nullptr} + , decltype(_impl_.grpclb_route_type_) {} + }; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.username_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.username_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_username().empty()) { + _this->_impl_.username_.Set(from._internal_username(), _this->GetArenaForAllocation()); + } + _impl_.oauth_scope_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.oauth_scope_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_oauth_scope().empty()) { + _this->_impl_.oauth_scope_.Set(from._internal_oauth_scope(), _this->GetArenaForAllocation()); + } + _impl_.server_id_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.server_id_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_server_id().empty()) { + _this->_impl_.server_id_.Set(from._internal_server_id(), _this->GetArenaForAllocation()); + } + _impl_.hostname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.hostname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_hostname().empty()) { + _this->_impl_.hostname_.Set(from._internal_hostname(), _this->GetArenaForAllocation()); + } + if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) { + _this->_impl_.payload_ = new ::connectrpc::conformance::Payload(*from._impl_.payload_); + } + _this->_impl_.grpclb_route_type_ = from._impl_.grpclb_route_type_; + // @@protoc_insertion_point(copy_constructor:connectrpc.conformance.SimpleResponse) +} + +inline void SimpleResponse::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.username_) {} + + , decltype(_impl_.oauth_scope_) {} + + , decltype(_impl_.server_id_) {} + + , decltype(_impl_.hostname_) {} + + , decltype(_impl_.payload_){nullptr} + , decltype(_impl_.grpclb_route_type_) { 0 } + + }; + _impl_.username_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.username_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.oauth_scope_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.oauth_scope_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.server_id_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.server_id_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.hostname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.hostname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +SimpleResponse::~SimpleResponse() { + // @@protoc_insertion_point(destructor:connectrpc.conformance.SimpleResponse) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SimpleResponse::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.username_.Destroy(); + _impl_.oauth_scope_.Destroy(); + _impl_.server_id_.Destroy(); + _impl_.hostname_.Destroy(); + if (this != internal_default_instance()) delete _impl_.payload_; +} + +void SimpleResponse::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SimpleResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:connectrpc.conformance.SimpleResponse) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.username_.ClearToEmpty(); + _impl_.oauth_scope_.ClearToEmpty(); + _impl_.server_id_.ClearToEmpty(); + _impl_.hostname_.ClearToEmpty(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(_impl_.payload_ != nullptr); + _impl_.payload_->Clear(); + } + _impl_.grpclb_route_type_ = 0; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SimpleResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .connectrpc.conformance.Payload payload = 1 [json_name = "payload"]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_payload(), ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // string username = 2 [json_name = "username"]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { + auto str = _internal_mutable_username(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + CHK_(::_pbi::VerifyUTF8(str, "connectrpc.conformance.SimpleResponse.username")); + } else { + goto handle_unusual; + } + continue; + // string oauth_scope = 3 [json_name = "oauthScope"]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) { + auto str = _internal_mutable_oauth_scope(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + CHK_(::_pbi::VerifyUTF8(str, "connectrpc.conformance.SimpleResponse.oauth_scope")); + } else { + goto handle_unusual; + } + continue; + // string server_id = 4 [json_name = "serverId"]; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) { + auto str = _internal_mutable_server_id(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + CHK_(::_pbi::VerifyUTF8(str, "connectrpc.conformance.SimpleResponse.server_id")); + } else { + goto handle_unusual; + } + continue; + // .connectrpc.conformance.GrpclbRouteType grpclb_route_type = 5 [json_name = "grpclbRouteType"]; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) { + ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + _internal_set_grpclb_route_type(static_cast<::connectrpc::conformance::GrpclbRouteType>(val)); + } else { + goto handle_unusual; + } + continue; + // string hostname = 6 [json_name = "hostname"]; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) { + auto str = _internal_mutable_hostname(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + CHK_(::_pbi::VerifyUTF8(str, "connectrpc.conformance.SimpleResponse.hostname")); + } else { + goto handle_unusual; + } + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* SimpleResponse::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:connectrpc.conformance.SimpleResponse) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // .connectrpc.conformance.Payload payload = 1 [json_name = "payload"]; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::payload(this), + _Internal::payload(this).GetCachedSize(), target, stream); + } + + // string username = 2 [json_name = "username"]; + if (!this->_internal_username().empty()) { + const std::string& _s = this->_internal_username(); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "connectrpc.conformance.SimpleResponse.username"); + target = stream->WriteStringMaybeAliased(2, _s, target); + } + + // string oauth_scope = 3 [json_name = "oauthScope"]; + if (!this->_internal_oauth_scope().empty()) { + const std::string& _s = this->_internal_oauth_scope(); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "connectrpc.conformance.SimpleResponse.oauth_scope"); + target = stream->WriteStringMaybeAliased(3, _s, target); + } + + // string server_id = 4 [json_name = "serverId"]; + if (!this->_internal_server_id().empty()) { + const std::string& _s = this->_internal_server_id(); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "connectrpc.conformance.SimpleResponse.server_id"); + target = stream->WriteStringMaybeAliased(4, _s, target); + } + + // .connectrpc.conformance.GrpclbRouteType grpclb_route_type = 5 [json_name = "grpclbRouteType"]; + if (this->_internal_grpclb_route_type() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 5, this->_internal_grpclb_route_type(), target); + } + + // string hostname = 6 [json_name = "hostname"]; + if (!this->_internal_hostname().empty()) { + const std::string& _s = this->_internal_hostname(); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "connectrpc.conformance.SimpleResponse.hostname"); + target = stream->WriteStringMaybeAliased(6, _s, target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:connectrpc.conformance.SimpleResponse) + return target; +} + +::size_t SimpleResponse::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:connectrpc.conformance.SimpleResponse) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string username = 2 [json_name = "username"]; + if (!this->_internal_username().empty()) { + total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_username()); + } + + // string oauth_scope = 3 [json_name = "oauthScope"]; + if (!this->_internal_oauth_scope().empty()) { + total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_oauth_scope()); + } + + // string server_id = 4 [json_name = "serverId"]; + if (!this->_internal_server_id().empty()) { + total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_server_id()); + } + + // string hostname = 6 [json_name = "hostname"]; + if (!this->_internal_hostname().empty()) { + total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_hostname()); + } + + // .connectrpc.conformance.Payload payload = 1 [json_name = "payload"]; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.payload_); + } + + // .connectrpc.conformance.GrpclbRouteType grpclb_route_type = 5 [json_name = "grpclbRouteType"]; + if (this->_internal_grpclb_route_type() != 0) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_grpclb_route_type()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SimpleResponse::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SimpleResponse::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SimpleResponse::GetClassData() const { return &_class_data_; } + + +void SimpleResponse::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:connectrpc.conformance.SimpleResponse) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_username().empty()) { + _this->_internal_set_username(from._internal_username()); + } + if (!from._internal_oauth_scope().empty()) { + _this->_internal_set_oauth_scope(from._internal_oauth_scope()); + } + if (!from._internal_server_id().empty()) { + _this->_internal_set_server_id(from._internal_server_id()); + } + if (!from._internal_hostname().empty()) { + _this->_internal_set_hostname(from._internal_hostname()); + } + if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) { + _this->_internal_mutable_payload()->::connectrpc::conformance::Payload::MergeFrom( + from._internal_payload()); + } + if (from._internal_grpclb_route_type() != 0) { + _this->_internal_set_grpclb_route_type(from._internal_grpclb_route_type()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SimpleResponse::CopyFrom(const SimpleResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:connectrpc.conformance.SimpleResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SimpleResponse::IsInitialized() const { + return true; +} + +void SimpleResponse::InternalSwap(SimpleResponse* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.username_, lhs_arena, + &other->_impl_.username_, rhs_arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.oauth_scope_, lhs_arena, + &other->_impl_.oauth_scope_, rhs_arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.server_id_, lhs_arena, + &other->_impl_.server_id_, rhs_arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.hostname_, lhs_arena, + &other->_impl_.hostname_, rhs_arena); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SimpleResponse, _impl_.grpclb_route_type_) + + sizeof(SimpleResponse::_impl_.grpclb_route_type_) + - PROTOBUF_FIELD_OFFSET(SimpleResponse, _impl_.payload_)>( + reinterpret_cast(&_impl_.payload_), + reinterpret_cast(&other->_impl_.payload_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SimpleResponse::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_getter, &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once, + file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto[3]); +} +// =================================================================== + +class StreamingInputCallRequest::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(StreamingInputCallRequest, _impl_._has_bits_); + static const ::connectrpc::conformance::Payload& payload(const StreamingInputCallRequest* msg); + static void set_has_payload(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::PROTOBUF_NAMESPACE_ID::BoolValue& expect_compressed(const StreamingInputCallRequest* msg); + static void set_has_expect_compressed(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::connectrpc::conformance::Payload& +StreamingInputCallRequest::_Internal::payload(const StreamingInputCallRequest* msg) { + return *msg->_impl_.payload_; +} +const ::PROTOBUF_NAMESPACE_ID::BoolValue& +StreamingInputCallRequest::_Internal::expect_compressed(const StreamingInputCallRequest* msg) { + return *msg->_impl_.expect_compressed_; +} +void StreamingInputCallRequest::clear_expect_compressed() { + if (_impl_.expect_compressed_ != nullptr) _impl_.expect_compressed_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +StreamingInputCallRequest::StreamingInputCallRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:connectrpc.conformance.StreamingInputCallRequest) +} +StreamingInputCallRequest::StreamingInputCallRequest(const StreamingInputCallRequest& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + StreamingInputCallRequest* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.payload_){nullptr} + , decltype(_impl_.expect_compressed_){nullptr}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) { + _this->_impl_.payload_ = new ::connectrpc::conformance::Payload(*from._impl_.payload_); + } + if ((from._impl_._has_bits_[0] & 0x00000002u) != 0) { + _this->_impl_.expect_compressed_ = new ::PROTOBUF_NAMESPACE_ID::BoolValue(*from._impl_.expect_compressed_); + } + // @@protoc_insertion_point(copy_constructor:connectrpc.conformance.StreamingInputCallRequest) +} + +inline void StreamingInputCallRequest::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.payload_){nullptr} + , decltype(_impl_.expect_compressed_){nullptr} + }; +} + +StreamingInputCallRequest::~StreamingInputCallRequest() { + // @@protoc_insertion_point(destructor:connectrpc.conformance.StreamingInputCallRequest) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void StreamingInputCallRequest::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.payload_; + if (this != internal_default_instance()) delete _impl_.expect_compressed_; +} + +void StreamingInputCallRequest::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void StreamingInputCallRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:connectrpc.conformance.StreamingInputCallRequest) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(_impl_.payload_ != nullptr); + _impl_.payload_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + ABSL_DCHECK(_impl_.expect_compressed_ != nullptr); + _impl_.expect_compressed_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* StreamingInputCallRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .connectrpc.conformance.Payload payload = 1 [json_name = "payload"]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_payload(), ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // .google.protobuf.BoolValue expect_compressed = 2 [json_name = "expectCompressed"]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_expect_compressed(), ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* StreamingInputCallRequest::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:connectrpc.conformance.StreamingInputCallRequest) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // .connectrpc.conformance.Payload payload = 1 [json_name = "payload"]; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::payload(this), + _Internal::payload(this).GetCachedSize(), target, stream); + } + + // .google.protobuf.BoolValue expect_compressed = 2 [json_name = "expectCompressed"]; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::expect_compressed(this), + _Internal::expect_compressed(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:connectrpc.conformance.StreamingInputCallRequest) + return target; +} + +::size_t StreamingInputCallRequest::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:connectrpc.conformance.StreamingInputCallRequest) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // .connectrpc.conformance.Payload payload = 1 [json_name = "payload"]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.payload_); + } + + // .google.protobuf.BoolValue expect_compressed = 2 [json_name = "expectCompressed"]; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.expect_compressed_); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData StreamingInputCallRequest::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + StreamingInputCallRequest::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*StreamingInputCallRequest::GetClassData() const { return &_class_data_; } + + +void StreamingInputCallRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:connectrpc.conformance.StreamingInputCallRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_payload()->::connectrpc::conformance::Payload::MergeFrom( + from._internal_payload()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_expect_compressed()->::PROTOBUF_NAMESPACE_ID::BoolValue::MergeFrom( + from._internal_expect_compressed()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void StreamingInputCallRequest::CopyFrom(const StreamingInputCallRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:connectrpc.conformance.StreamingInputCallRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool StreamingInputCallRequest::IsInitialized() const { + return true; +} + +void StreamingInputCallRequest::InternalSwap(StreamingInputCallRequest* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(StreamingInputCallRequest, _impl_.expect_compressed_) + + sizeof(StreamingInputCallRequest::_impl_.expect_compressed_) + - PROTOBUF_FIELD_OFFSET(StreamingInputCallRequest, _impl_.payload_)>( + reinterpret_cast(&_impl_.payload_), + reinterpret_cast(&other->_impl_.payload_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata StreamingInputCallRequest::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_getter, &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once, + file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto[4]); +} +// =================================================================== + +class StreamingInputCallResponse::_Internal { + public: +}; + +StreamingInputCallResponse::StreamingInputCallResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:connectrpc.conformance.StreamingInputCallResponse) +} +StreamingInputCallResponse::StreamingInputCallResponse(const StreamingInputCallResponse& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>( + from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:connectrpc.conformance.StreamingInputCallResponse) +} + +inline void StreamingInputCallResponse::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.aggregated_payload_size_) { 0 } + + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +StreamingInputCallResponse::~StreamingInputCallResponse() { + // @@protoc_insertion_point(destructor:connectrpc.conformance.StreamingInputCallResponse) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void StreamingInputCallResponse::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); +} + +void StreamingInputCallResponse::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void StreamingInputCallResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:connectrpc.conformance.StreamingInputCallResponse) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.aggregated_payload_size_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* StreamingInputCallResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int32 aggregated_payload_size = 1 [json_name = "aggregatedPayloadSize"]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) { + _impl_.aggregated_payload_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* StreamingInputCallResponse::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:connectrpc.conformance.StreamingInputCallResponse) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // int32 aggregated_payload_size = 1 [json_name = "aggregatedPayloadSize"]; + if (this->_internal_aggregated_payload_size() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray( + 1, this->_internal_aggregated_payload_size(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:connectrpc.conformance.StreamingInputCallResponse) + return target; +} + +::size_t StreamingInputCallResponse::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:connectrpc.conformance.StreamingInputCallResponse) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // int32 aggregated_payload_size = 1 [json_name = "aggregatedPayloadSize"]; + if (this->_internal_aggregated_payload_size() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_aggregated_payload_size()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData StreamingInputCallResponse::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + StreamingInputCallResponse::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*StreamingInputCallResponse::GetClassData() const { return &_class_data_; } + + +void StreamingInputCallResponse::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:connectrpc.conformance.StreamingInputCallResponse) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_aggregated_payload_size() != 0) { + _this->_internal_set_aggregated_payload_size(from._internal_aggregated_payload_size()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void StreamingInputCallResponse::CopyFrom(const StreamingInputCallResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:connectrpc.conformance.StreamingInputCallResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool StreamingInputCallResponse::IsInitialized() const { + return true; +} + +void StreamingInputCallResponse::InternalSwap(StreamingInputCallResponse* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + + swap(_impl_.aggregated_payload_size_, other->_impl_.aggregated_payload_size_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata StreamingInputCallResponse::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_getter, &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once, + file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto[5]); +} +// =================================================================== + +class ResponseParameters::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(ResponseParameters, _impl_._has_bits_); + static const ::PROTOBUF_NAMESPACE_ID::BoolValue& compressed(const ResponseParameters* msg); + static void set_has_compressed(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +const ::PROTOBUF_NAMESPACE_ID::BoolValue& +ResponseParameters::_Internal::compressed(const ResponseParameters* msg) { + return *msg->_impl_.compressed_; +} +void ResponseParameters::clear_compressed() { + if (_impl_.compressed_ != nullptr) _impl_.compressed_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +ResponseParameters::ResponseParameters(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:connectrpc.conformance.ResponseParameters) +} +ResponseParameters::ResponseParameters(const ResponseParameters& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + ResponseParameters* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.compressed_){nullptr} + , decltype(_impl_.size_) {} + + , decltype(_impl_.interval_us_) {} + }; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) { + _this->_impl_.compressed_ = new ::PROTOBUF_NAMESPACE_ID::BoolValue(*from._impl_.compressed_); + } + ::memcpy(&_impl_.size_, &from._impl_.size_, + static_cast<::size_t>(reinterpret_cast(&_impl_.interval_us_) - + reinterpret_cast(&_impl_.size_)) + sizeof(_impl_.interval_us_)); + // @@protoc_insertion_point(copy_constructor:connectrpc.conformance.ResponseParameters) +} + +inline void ResponseParameters::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.compressed_){nullptr} + , decltype(_impl_.size_) { 0 } + + , decltype(_impl_.interval_us_) { 0 } + + }; +} + +ResponseParameters::~ResponseParameters() { + // @@protoc_insertion_point(destructor:connectrpc.conformance.ResponseParameters) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ResponseParameters::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.compressed_; +} + +void ResponseParameters::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ResponseParameters::Clear() { +// @@protoc_insertion_point(message_clear_start:connectrpc.conformance.ResponseParameters) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(_impl_.compressed_ != nullptr); + _impl_.compressed_->Clear(); + } + ::memset(&_impl_.size_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.interval_us_) - + reinterpret_cast(&_impl_.size_)) + sizeof(_impl_.interval_us_)); + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ResponseParameters::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int32 size = 1 [json_name = "size"]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) { + _impl_.size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // int32 interval_us = 2 [json_name = "intervalUs"]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) { + _impl_.interval_us_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // .google.protobuf.BoolValue compressed = 3 [json_name = "compressed"]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_compressed(), ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* ResponseParameters::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:connectrpc.conformance.ResponseParameters) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // int32 size = 1 [json_name = "size"]; + if (this->_internal_size() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray( + 1, this->_internal_size(), target); + } + + // int32 interval_us = 2 [json_name = "intervalUs"]; + if (this->_internal_interval_us() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray( + 2, this->_internal_interval_us(), target); + } + + cached_has_bits = _impl_._has_bits_[0]; + // .google.protobuf.BoolValue compressed = 3 [json_name = "compressed"]; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::compressed(this), + _Internal::compressed(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:connectrpc.conformance.ResponseParameters) + return target; +} + +::size_t ResponseParameters::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:connectrpc.conformance.ResponseParameters) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .google.protobuf.BoolValue compressed = 3 [json_name = "compressed"]; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.compressed_); + } + + // int32 size = 1 [json_name = "size"]; + if (this->_internal_size() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_size()); + } + + // int32 interval_us = 2 [json_name = "intervalUs"]; + if (this->_internal_interval_us() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_interval_us()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ResponseParameters::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + ResponseParameters::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ResponseParameters::GetClassData() const { return &_class_data_; } + + +void ResponseParameters::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:connectrpc.conformance.ResponseParameters) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) { + _this->_internal_mutable_compressed()->::PROTOBUF_NAMESPACE_ID::BoolValue::MergeFrom( + from._internal_compressed()); + } + if (from._internal_size() != 0) { + _this->_internal_set_size(from._internal_size()); + } + if (from._internal_interval_us() != 0) { + _this->_internal_set_interval_us(from._internal_interval_us()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ResponseParameters::CopyFrom(const ResponseParameters& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:connectrpc.conformance.ResponseParameters) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ResponseParameters::IsInitialized() const { + return true; +} + +void ResponseParameters::InternalSwap(ResponseParameters* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ResponseParameters, _impl_.interval_us_) + + sizeof(ResponseParameters::_impl_.interval_us_) + - PROTOBUF_FIELD_OFFSET(ResponseParameters, _impl_.compressed_)>( + reinterpret_cast(&_impl_.compressed_), + reinterpret_cast(&other->_impl_.compressed_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ResponseParameters::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_getter, &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once, + file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto[6]); +} +// =================================================================== + +class StreamingOutputCallRequest::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(StreamingOutputCallRequest, _impl_._has_bits_); + static const ::connectrpc::conformance::Payload& payload(const StreamingOutputCallRequest* msg); + static void set_has_payload(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::connectrpc::conformance::EchoStatus& response_status(const StreamingOutputCallRequest* msg); + static void set_has_response_status(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::connectrpc::conformance::Payload& +StreamingOutputCallRequest::_Internal::payload(const StreamingOutputCallRequest* msg) { + return *msg->_impl_.payload_; +} +const ::connectrpc::conformance::EchoStatus& +StreamingOutputCallRequest::_Internal::response_status(const StreamingOutputCallRequest* msg) { + return *msg->_impl_.response_status_; +} +StreamingOutputCallRequest::StreamingOutputCallRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:connectrpc.conformance.StreamingOutputCallRequest) +} +StreamingOutputCallRequest::StreamingOutputCallRequest(const StreamingOutputCallRequest& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + StreamingOutputCallRequest* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.response_parameters_){from._impl_.response_parameters_} + , decltype(_impl_.payload_){nullptr} + , decltype(_impl_.response_status_){nullptr} + , decltype(_impl_.response_type_) {} + }; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) { + _this->_impl_.payload_ = new ::connectrpc::conformance::Payload(*from._impl_.payload_); + } + if ((from._impl_._has_bits_[0] & 0x00000002u) != 0) { + _this->_impl_.response_status_ = new ::connectrpc::conformance::EchoStatus(*from._impl_.response_status_); + } + _this->_impl_.response_type_ = from._impl_.response_type_; + // @@protoc_insertion_point(copy_constructor:connectrpc.conformance.StreamingOutputCallRequest) +} + +inline void StreamingOutputCallRequest::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.response_parameters_){arena} + , decltype(_impl_.payload_){nullptr} + , decltype(_impl_.response_status_){nullptr} + , decltype(_impl_.response_type_) { 0 } + + }; +} + +StreamingOutputCallRequest::~StreamingOutputCallRequest() { + // @@protoc_insertion_point(destructor:connectrpc.conformance.StreamingOutputCallRequest) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void StreamingOutputCallRequest::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _internal_mutable_response_parameters()->~RepeatedPtrField(); + if (this != internal_default_instance()) delete _impl_.payload_; + if (this != internal_default_instance()) delete _impl_.response_status_; +} + +void StreamingOutputCallRequest::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void StreamingOutputCallRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:connectrpc.conformance.StreamingOutputCallRequest) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_mutable_response_parameters()->Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(_impl_.payload_ != nullptr); + _impl_.payload_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + ABSL_DCHECK(_impl_.response_status_ != nullptr); + _impl_.response_status_->Clear(); + } + } + _impl_.response_type_ = 0; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* StreamingOutputCallRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .connectrpc.conformance.PayloadType response_type = 1 [json_name = "responseType"]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) { + ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + _internal_set_response_type(static_cast<::connectrpc::conformance::PayloadType>(val)); + } else { + goto handle_unusual; + } + continue; + // repeated .connectrpc.conformance.ResponseParameters response_parameters = 2 [json_name = "responseParameters"]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_response_parameters(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else { + goto handle_unusual; + } + continue; + // .connectrpc.conformance.Payload payload = 3 [json_name = "payload"]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_payload(), ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // .connectrpc.conformance.EchoStatus response_status = 7 [json_name = "responseStatus"]; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_response_status(), ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* StreamingOutputCallRequest::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:connectrpc.conformance.StreamingOutputCallRequest) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // .connectrpc.conformance.PayloadType response_type = 1 [json_name = "responseType"]; + if (this->_internal_response_type() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this->_internal_response_type(), target); + } + + // repeated .connectrpc.conformance.ResponseParameters response_parameters = 2 [json_name = "responseParameters"]; + for (unsigned i = 0, + n = static_cast(this->_internal_response_parameters_size()); i < n; i++) { + const auto& repfield = this->_internal_response_parameters(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream); + } + + cached_has_bits = _impl_._has_bits_[0]; + // .connectrpc.conformance.Payload payload = 3 [json_name = "payload"]; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::payload(this), + _Internal::payload(this).GetCachedSize(), target, stream); + } + + // .connectrpc.conformance.EchoStatus response_status = 7 [json_name = "responseStatus"]; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(7, _Internal::response_status(this), + _Internal::response_status(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:connectrpc.conformance.StreamingOutputCallRequest) + return target; +} + +::size_t StreamingOutputCallRequest::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:connectrpc.conformance.StreamingOutputCallRequest) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .connectrpc.conformance.ResponseParameters response_parameters = 2 [json_name = "responseParameters"]; + total_size += 1UL * this->_internal_response_parameters_size(); + for (const auto& msg : this->_internal_response_parameters()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // .connectrpc.conformance.Payload payload = 3 [json_name = "payload"]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.payload_); + } + + // .connectrpc.conformance.EchoStatus response_status = 7 [json_name = "responseStatus"]; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.response_status_); + } + + } + // .connectrpc.conformance.PayloadType response_type = 1 [json_name = "responseType"]; + if (this->_internal_response_type() != 0) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_response_type()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData StreamingOutputCallRequest::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + StreamingOutputCallRequest::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*StreamingOutputCallRequest::GetClassData() const { return &_class_data_; } + + +void StreamingOutputCallRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:connectrpc.conformance.StreamingOutputCallRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_mutable_response_parameters()->MergeFrom(from._internal_response_parameters()); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_payload()->::connectrpc::conformance::Payload::MergeFrom( + from._internal_payload()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_response_status()->::connectrpc::conformance::EchoStatus::MergeFrom( + from._internal_response_status()); + } + } + if (from._internal_response_type() != 0) { + _this->_internal_set_response_type(from._internal_response_type()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void StreamingOutputCallRequest::CopyFrom(const StreamingOutputCallRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:connectrpc.conformance.StreamingOutputCallRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool StreamingOutputCallRequest::IsInitialized() const { + return true; +} + +void StreamingOutputCallRequest::InternalSwap(StreamingOutputCallRequest* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _internal_mutable_response_parameters()->InternalSwap(other->_internal_mutable_response_parameters()); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(StreamingOutputCallRequest, _impl_.response_type_) + + sizeof(StreamingOutputCallRequest::_impl_.response_type_) + - PROTOBUF_FIELD_OFFSET(StreamingOutputCallRequest, _impl_.payload_)>( + reinterpret_cast(&_impl_.payload_), + reinterpret_cast(&other->_impl_.payload_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata StreamingOutputCallRequest::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_getter, &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once, + file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto[7]); +} +// =================================================================== + +class StreamingOutputCallResponse::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(StreamingOutputCallResponse, _impl_._has_bits_); + static const ::connectrpc::conformance::Payload& payload(const StreamingOutputCallResponse* msg); + static void set_has_payload(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +const ::connectrpc::conformance::Payload& +StreamingOutputCallResponse::_Internal::payload(const StreamingOutputCallResponse* msg) { + return *msg->_impl_.payload_; +} +StreamingOutputCallResponse::StreamingOutputCallResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:connectrpc.conformance.StreamingOutputCallResponse) +} +StreamingOutputCallResponse::StreamingOutputCallResponse(const StreamingOutputCallResponse& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + StreamingOutputCallResponse* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.payload_){nullptr}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) { + _this->_impl_.payload_ = new ::connectrpc::conformance::Payload(*from._impl_.payload_); + } + // @@protoc_insertion_point(copy_constructor:connectrpc.conformance.StreamingOutputCallResponse) +} + +inline void StreamingOutputCallResponse::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.payload_){nullptr} + }; +} + +StreamingOutputCallResponse::~StreamingOutputCallResponse() { + // @@protoc_insertion_point(destructor:connectrpc.conformance.StreamingOutputCallResponse) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void StreamingOutputCallResponse::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.payload_; +} + +void StreamingOutputCallResponse::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void StreamingOutputCallResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:connectrpc.conformance.StreamingOutputCallResponse) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(_impl_.payload_ != nullptr); + _impl_.payload_->Clear(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* StreamingOutputCallResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .connectrpc.conformance.Payload payload = 1 [json_name = "payload"]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_payload(), ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* StreamingOutputCallResponse::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:connectrpc.conformance.StreamingOutputCallResponse) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // .connectrpc.conformance.Payload payload = 1 [json_name = "payload"]; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::payload(this), + _Internal::payload(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:connectrpc.conformance.StreamingOutputCallResponse) + return target; +} + +::size_t StreamingOutputCallResponse::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:connectrpc.conformance.StreamingOutputCallResponse) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .connectrpc.conformance.Payload payload = 1 [json_name = "payload"]; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.payload_); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData StreamingOutputCallResponse::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + StreamingOutputCallResponse::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*StreamingOutputCallResponse::GetClassData() const { return &_class_data_; } + + +void StreamingOutputCallResponse::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:connectrpc.conformance.StreamingOutputCallResponse) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) { + _this->_internal_mutable_payload()->::connectrpc::conformance::Payload::MergeFrom( + from._internal_payload()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void StreamingOutputCallResponse::CopyFrom(const StreamingOutputCallResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:connectrpc.conformance.StreamingOutputCallResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool StreamingOutputCallResponse::IsInitialized() const { + return true; +} + +void StreamingOutputCallResponse::InternalSwap(StreamingOutputCallResponse* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_.payload_, other->_impl_.payload_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata StreamingOutputCallResponse::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_getter, &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once, + file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto[8]); +} +// =================================================================== + +class ReconnectParams::_Internal { + public: +}; + +ReconnectParams::ReconnectParams(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:connectrpc.conformance.ReconnectParams) +} +ReconnectParams::ReconnectParams(const ReconnectParams& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>( + from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:connectrpc.conformance.ReconnectParams) +} + +inline void ReconnectParams::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.max_reconnect_backoff_ms_) { 0 } + + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +ReconnectParams::~ReconnectParams() { + // @@protoc_insertion_point(destructor:connectrpc.conformance.ReconnectParams) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ReconnectParams::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); +} + +void ReconnectParams::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ReconnectParams::Clear() { +// @@protoc_insertion_point(message_clear_start:connectrpc.conformance.ReconnectParams) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.max_reconnect_backoff_ms_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ReconnectParams::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int32 max_reconnect_backoff_ms = 1 [json_name = "maxReconnectBackoffMs"]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) { + _impl_.max_reconnect_backoff_ms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* ReconnectParams::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:connectrpc.conformance.ReconnectParams) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // int32 max_reconnect_backoff_ms = 1 [json_name = "maxReconnectBackoffMs"]; + if (this->_internal_max_reconnect_backoff_ms() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray( + 1, this->_internal_max_reconnect_backoff_ms(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:connectrpc.conformance.ReconnectParams) + return target; +} + +::size_t ReconnectParams::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:connectrpc.conformance.ReconnectParams) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // int32 max_reconnect_backoff_ms = 1 [json_name = "maxReconnectBackoffMs"]; + if (this->_internal_max_reconnect_backoff_ms() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_max_reconnect_backoff_ms()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ReconnectParams::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + ReconnectParams::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ReconnectParams::GetClassData() const { return &_class_data_; } + + +void ReconnectParams::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:connectrpc.conformance.ReconnectParams) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_max_reconnect_backoff_ms() != 0) { + _this->_internal_set_max_reconnect_backoff_ms(from._internal_max_reconnect_backoff_ms()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ReconnectParams::CopyFrom(const ReconnectParams& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:connectrpc.conformance.ReconnectParams) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ReconnectParams::IsInitialized() const { + return true; +} + +void ReconnectParams::InternalSwap(ReconnectParams* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + + swap(_impl_.max_reconnect_backoff_ms_, other->_impl_.max_reconnect_backoff_ms_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ReconnectParams::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_getter, &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once, + file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto[9]); +} +// =================================================================== + +class ReconnectInfo::_Internal { + public: +}; + +ReconnectInfo::ReconnectInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:connectrpc.conformance.ReconnectInfo) +} +ReconnectInfo::ReconnectInfo(const ReconnectInfo& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + ReconnectInfo* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.backoff_ms_) { from._impl_.backoff_ms_ } + ,/* _impl_._backoff_ms_cached_byte_size_ = */ { 0 } + + , decltype(_impl_.passed_) {} + + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _this->_impl_.passed_ = from._impl_.passed_; + // @@protoc_insertion_point(copy_constructor:connectrpc.conformance.ReconnectInfo) +} + +inline void ReconnectInfo::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.backoff_ms_) { arena } + ,/* _impl_._backoff_ms_cached_byte_size_ = */ { 0 } + + , decltype(_impl_.passed_) { false } + + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +ReconnectInfo::~ReconnectInfo() { + // @@protoc_insertion_point(destructor:connectrpc.conformance.ReconnectInfo) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ReconnectInfo::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.backoff_ms_.~RepeatedField(); +} + +void ReconnectInfo::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ReconnectInfo::Clear() { +// @@protoc_insertion_point(message_clear_start:connectrpc.conformance.ReconnectInfo) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_mutable_backoff_ms()->Clear(); + _impl_.passed_ = false; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ReconnectInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // bool passed = 1 [json_name = "passed"]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) { + _impl_.passed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // repeated int32 backoff_ms = 2 [json_name = "backoffMs"]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_backoff_ms(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::uint8_t>(tag) == 16) { + _internal_add_backoff_ms(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* ReconnectInfo::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:connectrpc.conformance.ReconnectInfo) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // bool passed = 1 [json_name = "passed"]; + if (this->_internal_passed() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 1, this->_internal_passed(), target); + } + + // repeated int32 backoff_ms = 2 [json_name = "backoffMs"]; + { + int byte_size = _impl_._backoff_ms_cached_byte_size_.Get(); + if (byte_size > 0) { + target = stream->WriteInt32Packed(2, _internal_backoff_ms(), + byte_size, target); + } + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:connectrpc.conformance.ReconnectInfo) + return target; +} + +::size_t ReconnectInfo::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:connectrpc.conformance.ReconnectInfo) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated int32 backoff_ms = 2 [json_name = "backoffMs"]; + { + std::size_t data_size = ::_pbi::WireFormatLite::Int32Size( + this->_internal_backoff_ms()) + ; + _impl_._backoff_ms_cached_byte_size_.Set(::_pbi::ToCachedSize(data_size)); + std::size_t tag_size = data_size == 0 + ? 0 + : 1 + ::_pbi::WireFormatLite::Int32Size( + static_cast(data_size)) + ; + total_size += tag_size + data_size; + } + + // bool passed = 1 [json_name = "passed"]; + if (this->_internal_passed() != 0) { + total_size += 2; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ReconnectInfo::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + ReconnectInfo::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ReconnectInfo::GetClassData() const { return &_class_data_; } + + +void ReconnectInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:connectrpc.conformance.ReconnectInfo) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.backoff_ms_.MergeFrom(from._impl_.backoff_ms_); + if (from._internal_passed() != 0) { + _this->_internal_set_passed(from._internal_passed()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ReconnectInfo::CopyFrom(const ReconnectInfo& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:connectrpc.conformance.ReconnectInfo) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ReconnectInfo::IsInitialized() const { + return true; +} + +void ReconnectInfo::InternalSwap(ReconnectInfo* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.backoff_ms_.InternalSwap(&other->_impl_.backoff_ms_); + + swap(_impl_.passed_, other->_impl_.passed_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ReconnectInfo::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_getter, &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once, + file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto[10]); +} +// =================================================================== + +class LoadBalancerStatsRequest::_Internal { + public: +}; + +LoadBalancerStatsRequest::LoadBalancerStatsRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:connectrpc.conformance.LoadBalancerStatsRequest) +} +LoadBalancerStatsRequest::LoadBalancerStatsRequest(const LoadBalancerStatsRequest& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>( + from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:connectrpc.conformance.LoadBalancerStatsRequest) +} + +inline void LoadBalancerStatsRequest::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.num_rpcs_) { 0 } + + , decltype(_impl_.timeout_sec_) { 0 } + + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +LoadBalancerStatsRequest::~LoadBalancerStatsRequest() { + // @@protoc_insertion_point(destructor:connectrpc.conformance.LoadBalancerStatsRequest) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void LoadBalancerStatsRequest::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); +} + +void LoadBalancerStatsRequest::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void LoadBalancerStatsRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:connectrpc.conformance.LoadBalancerStatsRequest) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.num_rpcs_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.timeout_sec_) - + reinterpret_cast(&_impl_.num_rpcs_)) + sizeof(_impl_.timeout_sec_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* LoadBalancerStatsRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int32 num_rpcs = 1 [json_name = "numRpcs"]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) { + _impl_.num_rpcs_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // int32 timeout_sec = 2 [json_name = "timeoutSec"]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) { + _impl_.timeout_sec_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* LoadBalancerStatsRequest::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:connectrpc.conformance.LoadBalancerStatsRequest) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // int32 num_rpcs = 1 [json_name = "numRpcs"]; + if (this->_internal_num_rpcs() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray( + 1, this->_internal_num_rpcs(), target); + } + + // int32 timeout_sec = 2 [json_name = "timeoutSec"]; + if (this->_internal_timeout_sec() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray( + 2, this->_internal_timeout_sec(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:connectrpc.conformance.LoadBalancerStatsRequest) + return target; +} + +::size_t LoadBalancerStatsRequest::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:connectrpc.conformance.LoadBalancerStatsRequest) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // int32 num_rpcs = 1 [json_name = "numRpcs"]; + if (this->_internal_num_rpcs() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_num_rpcs()); + } + + // int32 timeout_sec = 2 [json_name = "timeoutSec"]; + if (this->_internal_timeout_sec() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_timeout_sec()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData LoadBalancerStatsRequest::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + LoadBalancerStatsRequest::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*LoadBalancerStatsRequest::GetClassData() const { return &_class_data_; } + + +void LoadBalancerStatsRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:connectrpc.conformance.LoadBalancerStatsRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_num_rpcs() != 0) { + _this->_internal_set_num_rpcs(from._internal_num_rpcs()); + } + if (from._internal_timeout_sec() != 0) { + _this->_internal_set_timeout_sec(from._internal_timeout_sec()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void LoadBalancerStatsRequest::CopyFrom(const LoadBalancerStatsRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:connectrpc.conformance.LoadBalancerStatsRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool LoadBalancerStatsRequest::IsInitialized() const { + return true; +} + +void LoadBalancerStatsRequest::InternalSwap(LoadBalancerStatsRequest* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(LoadBalancerStatsRequest, _impl_.timeout_sec_) + + sizeof(LoadBalancerStatsRequest::_impl_.timeout_sec_) + - PROTOBUF_FIELD_OFFSET(LoadBalancerStatsRequest, _impl_.num_rpcs_)>( + reinterpret_cast(&_impl_.num_rpcs_), + reinterpret_cast(&other->_impl_.num_rpcs_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata LoadBalancerStatsRequest::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_getter, &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once, + file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto[11]); +} +// =================================================================== + +LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse::LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse() {} +LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse::LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : SuperType(arena) {} +void LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse::MergeFrom(const LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse& other) { + MergeFromInternal(other); +} +::PROTOBUF_NAMESPACE_ID::Metadata LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_getter, &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once, + file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto[12]); +} +// =================================================================== + +class LoadBalancerStatsResponse_RpcsByPeer::_Internal { + public: +}; + +LoadBalancerStatsResponse_RpcsByPeer::LoadBalancerStatsResponse_RpcsByPeer(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:connectrpc.conformance.LoadBalancerStatsResponse.RpcsByPeer) +} +LoadBalancerStatsResponse_RpcsByPeer::LoadBalancerStatsResponse_RpcsByPeer(const LoadBalancerStatsResponse_RpcsByPeer& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + LoadBalancerStatsResponse_RpcsByPeer* const _this = this; (void)_this; + new (&_impl_) Impl_{ + /*decltype(_impl_.rpcs_by_peer_)*/{} + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _this->_impl_.rpcs_by_peer_.MergeFrom(from._impl_.rpcs_by_peer_); + // @@protoc_insertion_point(copy_constructor:connectrpc.conformance.LoadBalancerStatsResponse.RpcsByPeer) +} + +inline void LoadBalancerStatsResponse_RpcsByPeer::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + /*decltype(_impl_.rpcs_by_peer_)*/{::_pbi::ArenaInitialized(), arena} + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +LoadBalancerStatsResponse_RpcsByPeer::~LoadBalancerStatsResponse_RpcsByPeer() { + // @@protoc_insertion_point(destructor:connectrpc.conformance.LoadBalancerStatsResponse.RpcsByPeer) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void LoadBalancerStatsResponse_RpcsByPeer::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.rpcs_by_peer_.~MapField(); +} + +void LoadBalancerStatsResponse_RpcsByPeer::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void LoadBalancerStatsResponse_RpcsByPeer::Clear() { +// @@protoc_insertion_point(message_clear_start:connectrpc.conformance.LoadBalancerStatsResponse.RpcsByPeer) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.rpcs_by_peer_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* LoadBalancerStatsResponse_RpcsByPeer::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // map rpcs_by_peer = 1 [json_name = "rpcsByPeer"]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(&_impl_.rpcs_by_peer_, ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else { + goto handle_unusual; + } + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* LoadBalancerStatsResponse_RpcsByPeer::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:connectrpc.conformance.LoadBalancerStatsResponse.RpcsByPeer) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // map rpcs_by_peer = 1 [json_name = "rpcsByPeer"]; + if (!this->_internal_rpcs_by_peer().empty()) { + using MapType = ::_pb::Map; + using WireHelper = LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse::Funcs; + const auto& map_field = this->_internal_rpcs_by_peer(); + auto check_utf8 = [](const MapType::value_type& entry) { + (void)entry; + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + entry.first.data(), static_cast(entry.first.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "connectrpc.conformance.LoadBalancerStatsResponse.RpcsByPeer.rpcs_by_peer"); + }; + + if (stream->IsSerializationDeterministic() && map_field.size() > 1) { + for (const auto& entry : ::_pbi::MapSorterPtr(map_field)) { + target = WireHelper::InternalSerialize(1, entry.first, entry.second, target, stream); + check_utf8(entry); + } + } else { + for (const auto& entry : map_field) { + target = WireHelper::InternalSerialize(1, entry.first, entry.second, target, stream); + check_utf8(entry); + } + } + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:connectrpc.conformance.LoadBalancerStatsResponse.RpcsByPeer) + return target; +} + +::size_t LoadBalancerStatsResponse_RpcsByPeer::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:connectrpc.conformance.LoadBalancerStatsResponse.RpcsByPeer) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // map rpcs_by_peer = 1 [json_name = "rpcsByPeer"]; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_rpcs_by_peer_size()); + for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >::const_iterator + it = this->_internal_rpcs_by_peer().begin(); + it != this->_internal_rpcs_by_peer().end(); ++it) { + total_size += LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData LoadBalancerStatsResponse_RpcsByPeer::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + LoadBalancerStatsResponse_RpcsByPeer::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*LoadBalancerStatsResponse_RpcsByPeer::GetClassData() const { return &_class_data_; } + + +void LoadBalancerStatsResponse_RpcsByPeer::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:connectrpc.conformance.LoadBalancerStatsResponse.RpcsByPeer) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.rpcs_by_peer_.MergeFrom(from._impl_.rpcs_by_peer_); + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void LoadBalancerStatsResponse_RpcsByPeer::CopyFrom(const LoadBalancerStatsResponse_RpcsByPeer& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:connectrpc.conformance.LoadBalancerStatsResponse.RpcsByPeer) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool LoadBalancerStatsResponse_RpcsByPeer::IsInitialized() const { + return true; +} + +void LoadBalancerStatsResponse_RpcsByPeer::InternalSwap(LoadBalancerStatsResponse_RpcsByPeer* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.rpcs_by_peer_.InternalSwap(&other->_impl_.rpcs_by_peer_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata LoadBalancerStatsResponse_RpcsByPeer::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_getter, &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once, + file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto[13]); +} +// =================================================================== + +LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse::LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse() {} +LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse::LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : SuperType(arena) {} +void LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse::MergeFrom(const LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse& other) { + MergeFromInternal(other); +} +::PROTOBUF_NAMESPACE_ID::Metadata LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_getter, &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once, + file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto[14]); +} +// =================================================================== + +LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse::LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse() {} +LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse::LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : SuperType(arena) {} +void LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse::MergeFrom(const LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse& other) { + MergeFromInternal(other); +} +::PROTOBUF_NAMESPACE_ID::Metadata LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_getter, &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once, + file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto[15]); +} +// =================================================================== + +class LoadBalancerStatsResponse::_Internal { + public: +}; + +LoadBalancerStatsResponse::LoadBalancerStatsResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:connectrpc.conformance.LoadBalancerStatsResponse) +} +LoadBalancerStatsResponse::LoadBalancerStatsResponse(const LoadBalancerStatsResponse& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + LoadBalancerStatsResponse* const _this = this; (void)_this; + new (&_impl_) Impl_{ + /*decltype(_impl_.rpcs_by_peer_)*/{} + , /*decltype(_impl_.rpcs_by_method_)*/{} + , decltype(_impl_.num_failures_) {} + + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _this->_impl_.rpcs_by_peer_.MergeFrom(from._impl_.rpcs_by_peer_); + _this->_impl_.rpcs_by_method_.MergeFrom(from._impl_.rpcs_by_method_); + _this->_impl_.num_failures_ = from._impl_.num_failures_; + // @@protoc_insertion_point(copy_constructor:connectrpc.conformance.LoadBalancerStatsResponse) +} + +inline void LoadBalancerStatsResponse::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + /*decltype(_impl_.rpcs_by_peer_)*/{::_pbi::ArenaInitialized(), arena} + , /*decltype(_impl_.rpcs_by_method_)*/{::_pbi::ArenaInitialized(), arena} + , decltype(_impl_.num_failures_) { 0 } + + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +LoadBalancerStatsResponse::~LoadBalancerStatsResponse() { + // @@protoc_insertion_point(destructor:connectrpc.conformance.LoadBalancerStatsResponse) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void LoadBalancerStatsResponse::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.rpcs_by_peer_.~MapField(); + _impl_.rpcs_by_method_.~MapField(); +} + +void LoadBalancerStatsResponse::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void LoadBalancerStatsResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:connectrpc.conformance.LoadBalancerStatsResponse) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.rpcs_by_peer_.Clear(); + _impl_.rpcs_by_method_.Clear(); + _impl_.num_failures_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* LoadBalancerStatsResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // map rpcs_by_peer = 1 [json_name = "rpcsByPeer"]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(&_impl_.rpcs_by_peer_, ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else { + goto handle_unusual; + } + continue; + // int32 num_failures = 2 [json_name = "numFailures"]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) { + _impl_.num_failures_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // map rpcs_by_method = 3 [json_name = "rpcsByMethod"]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(&_impl_.rpcs_by_method_, ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else { + goto handle_unusual; + } + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* LoadBalancerStatsResponse::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:connectrpc.conformance.LoadBalancerStatsResponse) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // map rpcs_by_peer = 1 [json_name = "rpcsByPeer"]; + if (!this->_internal_rpcs_by_peer().empty()) { + using MapType = ::_pb::Map; + using WireHelper = LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse::Funcs; + const auto& map_field = this->_internal_rpcs_by_peer(); + auto check_utf8 = [](const MapType::value_type& entry) { + (void)entry; + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + entry.first.data(), static_cast(entry.first.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "connectrpc.conformance.LoadBalancerStatsResponse.rpcs_by_peer"); + }; + + if (stream->IsSerializationDeterministic() && map_field.size() > 1) { + for (const auto& entry : ::_pbi::MapSorterPtr(map_field)) { + target = WireHelper::InternalSerialize(1, entry.first, entry.second, target, stream); + check_utf8(entry); + } + } else { + for (const auto& entry : map_field) { + target = WireHelper::InternalSerialize(1, entry.first, entry.second, target, stream); + check_utf8(entry); + } + } + } + + // int32 num_failures = 2 [json_name = "numFailures"]; + if (this->_internal_num_failures() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray( + 2, this->_internal_num_failures(), target); + } + + // map rpcs_by_method = 3 [json_name = "rpcsByMethod"]; + if (!this->_internal_rpcs_by_method().empty()) { + using MapType = ::_pb::Map; + using WireHelper = LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse::Funcs; + const auto& map_field = this->_internal_rpcs_by_method(); + auto check_utf8 = [](const MapType::value_type& entry) { + (void)entry; + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + entry.first.data(), static_cast(entry.first.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "connectrpc.conformance.LoadBalancerStatsResponse.rpcs_by_method"); + }; + + if (stream->IsSerializationDeterministic() && map_field.size() > 1) { + for (const auto& entry : ::_pbi::MapSorterPtr(map_field)) { + target = WireHelper::InternalSerialize(3, entry.first, entry.second, target, stream); + check_utf8(entry); + } + } else { + for (const auto& entry : map_field) { + target = WireHelper::InternalSerialize(3, entry.first, entry.second, target, stream); + check_utf8(entry); + } + } + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:connectrpc.conformance.LoadBalancerStatsResponse) + return target; +} + +::size_t LoadBalancerStatsResponse::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:connectrpc.conformance.LoadBalancerStatsResponse) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // map rpcs_by_peer = 1 [json_name = "rpcsByPeer"]; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_rpcs_by_peer_size()); + for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >::const_iterator + it = this->_internal_rpcs_by_peer().begin(); + it != this->_internal_rpcs_by_peer().end(); ++it) { + total_size += LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second); + } + + // map rpcs_by_method = 3 [json_name = "rpcsByMethod"]; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_rpcs_by_method_size()); + for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeer >::const_iterator + it = this->_internal_rpcs_by_method().begin(); + it != this->_internal_rpcs_by_method().end(); ++it) { + total_size += LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second); + } + + // int32 num_failures = 2 [json_name = "numFailures"]; + if (this->_internal_num_failures() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_num_failures()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData LoadBalancerStatsResponse::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + LoadBalancerStatsResponse::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*LoadBalancerStatsResponse::GetClassData() const { return &_class_data_; } + + +void LoadBalancerStatsResponse::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:connectrpc.conformance.LoadBalancerStatsResponse) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.rpcs_by_peer_.MergeFrom(from._impl_.rpcs_by_peer_); + _this->_impl_.rpcs_by_method_.MergeFrom(from._impl_.rpcs_by_method_); + if (from._internal_num_failures() != 0) { + _this->_internal_set_num_failures(from._internal_num_failures()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void LoadBalancerStatsResponse::CopyFrom(const LoadBalancerStatsResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:connectrpc.conformance.LoadBalancerStatsResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool LoadBalancerStatsResponse::IsInitialized() const { + return true; +} + +void LoadBalancerStatsResponse::InternalSwap(LoadBalancerStatsResponse* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.rpcs_by_peer_.InternalSwap(&other->_impl_.rpcs_by_peer_); + _impl_.rpcs_by_method_.InternalSwap(&other->_impl_.rpcs_by_method_); + + swap(_impl_.num_failures_, other->_impl_.num_failures_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata LoadBalancerStatsResponse::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_getter, &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once, + file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto[16]); +} +// =================================================================== + +class LoadBalancerAccumulatedStatsRequest::_Internal { + public: +}; + +LoadBalancerAccumulatedStatsRequest::LoadBalancerAccumulatedStatsRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena) { + // @@protoc_insertion_point(arena_constructor:connectrpc.conformance.LoadBalancerAccumulatedStatsRequest) +} +LoadBalancerAccumulatedStatsRequest::LoadBalancerAccumulatedStatsRequest(const LoadBalancerAccumulatedStatsRequest& from) + : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() { + LoadBalancerAccumulatedStatsRequest* const _this = this; (void)_this; + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:connectrpc.conformance.LoadBalancerAccumulatedStatsRequest) +} + + + + + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData LoadBalancerAccumulatedStatsRequest::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl, + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl, +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*LoadBalancerAccumulatedStatsRequest::GetClassData() const { return &_class_data_; } + + + + + + + +::PROTOBUF_NAMESPACE_ID::Metadata LoadBalancerAccumulatedStatsRequest::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_getter, &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once, + file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto[17]); +} +// =================================================================== + +LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse::LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse() {} +LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse::LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : SuperType(arena) {} +void LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse::MergeFrom(const LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse& other) { + MergeFromInternal(other); +} +::PROTOBUF_NAMESPACE_ID::Metadata LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_getter, &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once, + file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto[18]); +} +// =================================================================== + +LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse::LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse() {} +LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse::LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : SuperType(arena) {} +void LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse::MergeFrom(const LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse& other) { + MergeFromInternal(other); +} +::PROTOBUF_NAMESPACE_ID::Metadata LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_getter, &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once, + file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto[19]); +} +// =================================================================== + +LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse::LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse() {} +LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse::LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : SuperType(arena) {} +void LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse::MergeFrom(const LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse& other) { + MergeFromInternal(other); +} +::PROTOBUF_NAMESPACE_ID::Metadata LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_getter, &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once, + file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto[20]); +} +// =================================================================== + +LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse::LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse() {} +LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse::LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : SuperType(arena) {} +void LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse::MergeFrom(const LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse& other) { + MergeFromInternal(other); +} +::PROTOBUF_NAMESPACE_ID::Metadata LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_getter, &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once, + file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto[21]); +} +// =================================================================== + +class LoadBalancerAccumulatedStatsResponse_MethodStats::_Internal { + public: +}; + +LoadBalancerAccumulatedStatsResponse_MethodStats::LoadBalancerAccumulatedStatsResponse_MethodStats(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.MethodStats) +} +LoadBalancerAccumulatedStatsResponse_MethodStats::LoadBalancerAccumulatedStatsResponse_MethodStats(const LoadBalancerAccumulatedStatsResponse_MethodStats& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + LoadBalancerAccumulatedStatsResponse_MethodStats* const _this = this; (void)_this; + new (&_impl_) Impl_{ + /*decltype(_impl_.result_)*/{} + , decltype(_impl_.rpcs_started_) {} + + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _this->_impl_.result_.MergeFrom(from._impl_.result_); + _this->_impl_.rpcs_started_ = from._impl_.rpcs_started_; + // @@protoc_insertion_point(copy_constructor:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.MethodStats) +} + +inline void LoadBalancerAccumulatedStatsResponse_MethodStats::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + /*decltype(_impl_.result_)*/{::_pbi::ArenaInitialized(), arena} + , decltype(_impl_.rpcs_started_) { 0 } + + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +LoadBalancerAccumulatedStatsResponse_MethodStats::~LoadBalancerAccumulatedStatsResponse_MethodStats() { + // @@protoc_insertion_point(destructor:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.MethodStats) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void LoadBalancerAccumulatedStatsResponse_MethodStats::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.result_.~MapField(); +} + +void LoadBalancerAccumulatedStatsResponse_MethodStats::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void LoadBalancerAccumulatedStatsResponse_MethodStats::Clear() { +// @@protoc_insertion_point(message_clear_start:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.MethodStats) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.result_.Clear(); + _impl_.rpcs_started_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* LoadBalancerAccumulatedStatsResponse_MethodStats::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int32 rpcs_started = 1 [json_name = "rpcsStarted"]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) { + _impl_.rpcs_started_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // map result = 2 [json_name = "result"]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(&_impl_.result_, ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else { + goto handle_unusual; + } + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* LoadBalancerAccumulatedStatsResponse_MethodStats::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.MethodStats) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // int32 rpcs_started = 1 [json_name = "rpcsStarted"]; + if (this->_internal_rpcs_started() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray( + 1, this->_internal_rpcs_started(), target); + } + + // map result = 2 [json_name = "result"]; + if (!this->_internal_result().empty()) { + using MapType = ::_pb::Map<::int32_t, ::int32_t>; + using WireHelper = LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse::Funcs; + const auto& map_field = this->_internal_result(); + + if (stream->IsSerializationDeterministic() && map_field.size() > 1) { + for (const auto& entry : ::_pbi::MapSorterFlat(map_field)) { + target = WireHelper::InternalSerialize(2, entry.first, entry.second, target, stream); + } + } else { + for (const auto& entry : map_field) { + target = WireHelper::InternalSerialize(2, entry.first, entry.second, target, stream); + } + } + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.MethodStats) + return target; +} + +::size_t LoadBalancerAccumulatedStatsResponse_MethodStats::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.MethodStats) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // map result = 2 [json_name = "result"]; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_result_size()); + for (::PROTOBUF_NAMESPACE_ID::Map< ::int32_t, ::int32_t >::const_iterator + it = this->_internal_result().begin(); + it != this->_internal_result().end(); ++it) { + total_size += LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second); + } + + // int32 rpcs_started = 1 [json_name = "rpcsStarted"]; + if (this->_internal_rpcs_started() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_rpcs_started()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData LoadBalancerAccumulatedStatsResponse_MethodStats::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + LoadBalancerAccumulatedStatsResponse_MethodStats::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*LoadBalancerAccumulatedStatsResponse_MethodStats::GetClassData() const { return &_class_data_; } + + +void LoadBalancerAccumulatedStatsResponse_MethodStats::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.MethodStats) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.result_.MergeFrom(from._impl_.result_); + if (from._internal_rpcs_started() != 0) { + _this->_internal_set_rpcs_started(from._internal_rpcs_started()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void LoadBalancerAccumulatedStatsResponse_MethodStats::CopyFrom(const LoadBalancerAccumulatedStatsResponse_MethodStats& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.MethodStats) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool LoadBalancerAccumulatedStatsResponse_MethodStats::IsInitialized() const { + return true; +} + +void LoadBalancerAccumulatedStatsResponse_MethodStats::InternalSwap(LoadBalancerAccumulatedStatsResponse_MethodStats* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.result_.InternalSwap(&other->_impl_.result_); + + swap(_impl_.rpcs_started_, other->_impl_.rpcs_started_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata LoadBalancerAccumulatedStatsResponse_MethodStats::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_getter, &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once, + file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto[22]); +} +// =================================================================== + +LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse::LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse() {} +LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse::LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : SuperType(arena) {} +void LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse::MergeFrom(const LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse& other) { + MergeFromInternal(other); +} +::PROTOBUF_NAMESPACE_ID::Metadata LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_getter, &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once, + file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto[23]); +} +// =================================================================== + +class LoadBalancerAccumulatedStatsResponse::_Internal { + public: +}; + +LoadBalancerAccumulatedStatsResponse::LoadBalancerAccumulatedStatsResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse) +} +LoadBalancerAccumulatedStatsResponse::LoadBalancerAccumulatedStatsResponse(const LoadBalancerAccumulatedStatsResponse& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + LoadBalancerAccumulatedStatsResponse* const _this = this; (void)_this; + new (&_impl_) Impl_{ + /*decltype(_impl_.num_rpcs_started_by_method_)*/{} + , /*decltype(_impl_.num_rpcs_succeeded_by_method_)*/{} + , /*decltype(_impl_.num_rpcs_failed_by_method_)*/{} + , /*decltype(_impl_.stats_per_method_)*/{} + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _this->_impl_.num_rpcs_started_by_method_.MergeFrom(from._impl_.num_rpcs_started_by_method_); + _this->_impl_.num_rpcs_succeeded_by_method_.MergeFrom(from._impl_.num_rpcs_succeeded_by_method_); + _this->_impl_.num_rpcs_failed_by_method_.MergeFrom(from._impl_.num_rpcs_failed_by_method_); + _this->_impl_.stats_per_method_.MergeFrom(from._impl_.stats_per_method_); + // @@protoc_insertion_point(copy_constructor:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse) +} + +inline void LoadBalancerAccumulatedStatsResponse::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + /*decltype(_impl_.num_rpcs_started_by_method_)*/{::_pbi::ArenaInitialized(), arena} + , /*decltype(_impl_.num_rpcs_succeeded_by_method_)*/{::_pbi::ArenaInitialized(), arena} + , /*decltype(_impl_.num_rpcs_failed_by_method_)*/{::_pbi::ArenaInitialized(), arena} + , /*decltype(_impl_.stats_per_method_)*/{::_pbi::ArenaInitialized(), arena} + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +LoadBalancerAccumulatedStatsResponse::~LoadBalancerAccumulatedStatsResponse() { + // @@protoc_insertion_point(destructor:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void LoadBalancerAccumulatedStatsResponse::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.num_rpcs_started_by_method_.~MapField(); + _impl_.num_rpcs_succeeded_by_method_.~MapField(); + _impl_.num_rpcs_failed_by_method_.~MapField(); + _impl_.stats_per_method_.~MapField(); +} + +void LoadBalancerAccumulatedStatsResponse::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void LoadBalancerAccumulatedStatsResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.num_rpcs_started_by_method_.Clear(); + _impl_.num_rpcs_succeeded_by_method_.Clear(); + _impl_.num_rpcs_failed_by_method_.Clear(); + _impl_.stats_per_method_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* LoadBalancerAccumulatedStatsResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // map num_rpcs_started_by_method = 1 [json_name = "numRpcsStartedByMethod", deprecated = true]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(&_impl_.num_rpcs_started_by_method_, ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else { + goto handle_unusual; + } + continue; + // map num_rpcs_succeeded_by_method = 2 [json_name = "numRpcsSucceededByMethod", deprecated = true]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(&_impl_.num_rpcs_succeeded_by_method_, ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else { + goto handle_unusual; + } + continue; + // map num_rpcs_failed_by_method = 3 [json_name = "numRpcsFailedByMethod", deprecated = true]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(&_impl_.num_rpcs_failed_by_method_, ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else { + goto handle_unusual; + } + continue; + // map stats_per_method = 4 [json_name = "statsPerMethod"]; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(&_impl_.stats_per_method_, ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); + } else { + goto handle_unusual; + } + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* LoadBalancerAccumulatedStatsResponse::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // map num_rpcs_started_by_method = 1 [json_name = "numRpcsStartedByMethod", deprecated = true]; + if (!this->_internal_num_rpcs_started_by_method().empty()) { + using MapType = ::_pb::Map; + using WireHelper = LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse::Funcs; + const auto& map_field = this->_internal_num_rpcs_started_by_method(); + auto check_utf8 = [](const MapType::value_type& entry) { + (void)entry; + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + entry.first.data(), static_cast(entry.first.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.num_rpcs_started_by_method"); + }; + + if (stream->IsSerializationDeterministic() && map_field.size() > 1) { + for (const auto& entry : ::_pbi::MapSorterPtr(map_field)) { + target = WireHelper::InternalSerialize(1, entry.first, entry.second, target, stream); + check_utf8(entry); + } + } else { + for (const auto& entry : map_field) { + target = WireHelper::InternalSerialize(1, entry.first, entry.second, target, stream); + check_utf8(entry); + } + } + } + + // map num_rpcs_succeeded_by_method = 2 [json_name = "numRpcsSucceededByMethod", deprecated = true]; + if (!this->_internal_num_rpcs_succeeded_by_method().empty()) { + using MapType = ::_pb::Map; + using WireHelper = LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse::Funcs; + const auto& map_field = this->_internal_num_rpcs_succeeded_by_method(); + auto check_utf8 = [](const MapType::value_type& entry) { + (void)entry; + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + entry.first.data(), static_cast(entry.first.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.num_rpcs_succeeded_by_method"); + }; + + if (stream->IsSerializationDeterministic() && map_field.size() > 1) { + for (const auto& entry : ::_pbi::MapSorterPtr(map_field)) { + target = WireHelper::InternalSerialize(2, entry.first, entry.second, target, stream); + check_utf8(entry); + } + } else { + for (const auto& entry : map_field) { + target = WireHelper::InternalSerialize(2, entry.first, entry.second, target, stream); + check_utf8(entry); + } + } + } + + // map num_rpcs_failed_by_method = 3 [json_name = "numRpcsFailedByMethod", deprecated = true]; + if (!this->_internal_num_rpcs_failed_by_method().empty()) { + using MapType = ::_pb::Map; + using WireHelper = LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse::Funcs; + const auto& map_field = this->_internal_num_rpcs_failed_by_method(); + auto check_utf8 = [](const MapType::value_type& entry) { + (void)entry; + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + entry.first.data(), static_cast(entry.first.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.num_rpcs_failed_by_method"); + }; + + if (stream->IsSerializationDeterministic() && map_field.size() > 1) { + for (const auto& entry : ::_pbi::MapSorterPtr(map_field)) { + target = WireHelper::InternalSerialize(3, entry.first, entry.second, target, stream); + check_utf8(entry); + } + } else { + for (const auto& entry : map_field) { + target = WireHelper::InternalSerialize(3, entry.first, entry.second, target, stream); + check_utf8(entry); + } + } + } + + // map stats_per_method = 4 [json_name = "statsPerMethod"]; + if (!this->_internal_stats_per_method().empty()) { + using MapType = ::_pb::Map; + using WireHelper = LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse::Funcs; + const auto& map_field = this->_internal_stats_per_method(); + auto check_utf8 = [](const MapType::value_type& entry) { + (void)entry; + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + entry.first.data(), static_cast(entry.first.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.stats_per_method"); + }; + + if (stream->IsSerializationDeterministic() && map_field.size() > 1) { + for (const auto& entry : ::_pbi::MapSorterPtr(map_field)) { + target = WireHelper::InternalSerialize(4, entry.first, entry.second, target, stream); + check_utf8(entry); + } + } else { + for (const auto& entry : map_field) { + target = WireHelper::InternalSerialize(4, entry.first, entry.second, target, stream); + check_utf8(entry); + } + } + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse) + return target; +} + +::size_t LoadBalancerAccumulatedStatsResponse::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // map num_rpcs_started_by_method = 1 [json_name = "numRpcsStartedByMethod", deprecated = true]; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_num_rpcs_started_by_method_size()); + for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >::const_iterator + it = this->_internal_num_rpcs_started_by_method().begin(); + it != this->_internal_num_rpcs_started_by_method().end(); ++it) { + total_size += LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second); + } + + // map num_rpcs_succeeded_by_method = 2 [json_name = "numRpcsSucceededByMethod", deprecated = true]; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_num_rpcs_succeeded_by_method_size()); + for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >::const_iterator + it = this->_internal_num_rpcs_succeeded_by_method().begin(); + it != this->_internal_num_rpcs_succeeded_by_method().end(); ++it) { + total_size += LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second); + } + + // map num_rpcs_failed_by_method = 3 [json_name = "numRpcsFailedByMethod", deprecated = true]; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_num_rpcs_failed_by_method_size()); + for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >::const_iterator + it = this->_internal_num_rpcs_failed_by_method().begin(); + it != this->_internal_num_rpcs_failed_by_method().end(); ++it) { + total_size += LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second); + } + + // map stats_per_method = 4 [json_name = "statsPerMethod"]; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_stats_per_method_size()); + for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_MethodStats >::const_iterator + it = this->_internal_stats_per_method().begin(); + it != this->_internal_stats_per_method().end(); ++it) { + total_size += LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData LoadBalancerAccumulatedStatsResponse::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + LoadBalancerAccumulatedStatsResponse::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*LoadBalancerAccumulatedStatsResponse::GetClassData() const { return &_class_data_; } + + +void LoadBalancerAccumulatedStatsResponse::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.num_rpcs_started_by_method_.MergeFrom(from._impl_.num_rpcs_started_by_method_); + _this->_impl_.num_rpcs_succeeded_by_method_.MergeFrom(from._impl_.num_rpcs_succeeded_by_method_); + _this->_impl_.num_rpcs_failed_by_method_.MergeFrom(from._impl_.num_rpcs_failed_by_method_); + _this->_impl_.stats_per_method_.MergeFrom(from._impl_.stats_per_method_); + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void LoadBalancerAccumulatedStatsResponse::CopyFrom(const LoadBalancerAccumulatedStatsResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool LoadBalancerAccumulatedStatsResponse::IsInitialized() const { + return true; +} + +void LoadBalancerAccumulatedStatsResponse::InternalSwap(LoadBalancerAccumulatedStatsResponse* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.num_rpcs_started_by_method_.InternalSwap(&other->_impl_.num_rpcs_started_by_method_); + _impl_.num_rpcs_succeeded_by_method_.InternalSwap(&other->_impl_.num_rpcs_succeeded_by_method_); + _impl_.num_rpcs_failed_by_method_.InternalSwap(&other->_impl_.num_rpcs_failed_by_method_); + _impl_.stats_per_method_.InternalSwap(&other->_impl_.stats_per_method_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata LoadBalancerAccumulatedStatsResponse::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_getter, &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once, + file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto[24]); +} +// =================================================================== + +class ClientConfigureRequest_Metadata::_Internal { + public: +}; + +ClientConfigureRequest_Metadata::ClientConfigureRequest_Metadata(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:connectrpc.conformance.ClientConfigureRequest.Metadata) +} +ClientConfigureRequest_Metadata::ClientConfigureRequest_Metadata(const ClientConfigureRequest_Metadata& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + ClientConfigureRequest_Metadata* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.key_) {} + + , decltype(_impl_.value_) {} + + , decltype(_impl_.type_) {} + + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.key_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.key_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_key().empty()) { + _this->_impl_.key_.Set(from._internal_key(), _this->GetArenaForAllocation()); + } + _impl_.value_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.value_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_value().empty()) { + _this->_impl_.value_.Set(from._internal_value(), _this->GetArenaForAllocation()); + } + _this->_impl_.type_ = from._impl_.type_; + // @@protoc_insertion_point(copy_constructor:connectrpc.conformance.ClientConfigureRequest.Metadata) +} + +inline void ClientConfigureRequest_Metadata::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.key_) {} + + , decltype(_impl_.value_) {} + + , decltype(_impl_.type_) { 0 } + + , /*decltype(_impl_._cached_size_)*/{} + }; + _impl_.key_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.key_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.value_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.value_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +ClientConfigureRequest_Metadata::~ClientConfigureRequest_Metadata() { + // @@protoc_insertion_point(destructor:connectrpc.conformance.ClientConfigureRequest.Metadata) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ClientConfigureRequest_Metadata::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.key_.Destroy(); + _impl_.value_.Destroy(); +} + +void ClientConfigureRequest_Metadata::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ClientConfigureRequest_Metadata::Clear() { +// @@protoc_insertion_point(message_clear_start:connectrpc.conformance.ClientConfigureRequest.Metadata) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.key_.ClearToEmpty(); + _impl_.value_.ClearToEmpty(); + _impl_.type_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ClientConfigureRequest_Metadata::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .connectrpc.conformance.ClientConfigureRequest.RpcType type = 1 [json_name = "type"]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) { + ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + _internal_set_type(static_cast<::connectrpc::conformance::ClientConfigureRequest_RpcType>(val)); + } else { + goto handle_unusual; + } + continue; + // string key = 2 [json_name = "key"]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { + auto str = _internal_mutable_key(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + CHK_(::_pbi::VerifyUTF8(str, "connectrpc.conformance.ClientConfigureRequest.Metadata.key")); + } else { + goto handle_unusual; + } + continue; + // string value = 3 [json_name = "value"]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) { + auto str = _internal_mutable_value(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + CHK_(::_pbi::VerifyUTF8(str, "connectrpc.conformance.ClientConfigureRequest.Metadata.value")); + } else { + goto handle_unusual; + } + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* ClientConfigureRequest_Metadata::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:connectrpc.conformance.ClientConfigureRequest.Metadata) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // .connectrpc.conformance.ClientConfigureRequest.RpcType type = 1 [json_name = "type"]; + if (this->_internal_type() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this->_internal_type(), target); + } + + // string key = 2 [json_name = "key"]; + if (!this->_internal_key().empty()) { + const std::string& _s = this->_internal_key(); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "connectrpc.conformance.ClientConfigureRequest.Metadata.key"); + target = stream->WriteStringMaybeAliased(2, _s, target); + } + + // string value = 3 [json_name = "value"]; + if (!this->_internal_value().empty()) { + const std::string& _s = this->_internal_value(); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "connectrpc.conformance.ClientConfigureRequest.Metadata.value"); + target = stream->WriteStringMaybeAliased(3, _s, target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:connectrpc.conformance.ClientConfigureRequest.Metadata) + return target; +} + +::size_t ClientConfigureRequest_Metadata::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:connectrpc.conformance.ClientConfigureRequest.Metadata) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string key = 2 [json_name = "key"]; + if (!this->_internal_key().empty()) { + total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_key()); + } + + // string value = 3 [json_name = "value"]; + if (!this->_internal_value().empty()) { + total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_value()); + } + + // .connectrpc.conformance.ClientConfigureRequest.RpcType type = 1 [json_name = "type"]; + if (this->_internal_type() != 0) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_type()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ClientConfigureRequest_Metadata::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + ClientConfigureRequest_Metadata::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ClientConfigureRequest_Metadata::GetClassData() const { return &_class_data_; } + + +void ClientConfigureRequest_Metadata::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:connectrpc.conformance.ClientConfigureRequest.Metadata) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_key().empty()) { + _this->_internal_set_key(from._internal_key()); + } + if (!from._internal_value().empty()) { + _this->_internal_set_value(from._internal_value()); + } + if (from._internal_type() != 0) { + _this->_internal_set_type(from._internal_type()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ClientConfigureRequest_Metadata::CopyFrom(const ClientConfigureRequest_Metadata& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:connectrpc.conformance.ClientConfigureRequest.Metadata) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ClientConfigureRequest_Metadata::IsInitialized() const { + return true; +} + +void ClientConfigureRequest_Metadata::InternalSwap(ClientConfigureRequest_Metadata* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.key_, lhs_arena, + &other->_impl_.key_, rhs_arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.value_, lhs_arena, + &other->_impl_.value_, rhs_arena); + swap(_impl_.type_, other->_impl_.type_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ClientConfigureRequest_Metadata::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_getter, &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once, + file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto[25]); +} +// =================================================================== + +class ClientConfigureRequest::_Internal { + public: +}; + +ClientConfigureRequest::ClientConfigureRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:connectrpc.conformance.ClientConfigureRequest) +} +ClientConfigureRequest::ClientConfigureRequest(const ClientConfigureRequest& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + ClientConfigureRequest* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.types_) { from._internal_types() } + , /*decltype(_impl_._types_cached_byte_size_)*/ { 0 } + + , decltype(_impl_.metadata_){from._impl_.metadata_} + , decltype(_impl_.timeout_sec_) {} + + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _this->_impl_.timeout_sec_ = from._impl_.timeout_sec_; + // @@protoc_insertion_point(copy_constructor:connectrpc.conformance.ClientConfigureRequest) +} + +inline void ClientConfigureRequest::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.types_) { arena } + , /*decltype(_impl_._types_cached_byte_size_)*/ { 0 } + + , decltype(_impl_.metadata_){arena} + , decltype(_impl_.timeout_sec_) { 0 } + + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +ClientConfigureRequest::~ClientConfigureRequest() { + // @@protoc_insertion_point(destructor:connectrpc.conformance.ClientConfigureRequest) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ClientConfigureRequest::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _internal_mutable_types()->~RepeatedField(); + _internal_mutable_metadata()->~RepeatedPtrField(); +} + +void ClientConfigureRequest::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ClientConfigureRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:connectrpc.conformance.ClientConfigureRequest) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_mutable_types()->Clear(); + _internal_mutable_metadata()->Clear(); + _impl_.timeout_sec_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ClientConfigureRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .connectrpc.conformance.ClientConfigureRequest.RpcType types = 1 [json_name = "types"]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser(_internal_mutable_types(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::uint8_t>(tag) == 8) { + ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + _internal_add_types(static_cast<::connectrpc::conformance::ClientConfigureRequest_RpcType>(val)); + } else { + goto handle_unusual; + } + continue; + // repeated .connectrpc.conformance.ClientConfigureRequest.Metadata metadata = 2 [json_name = "metadata"]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_metadata(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else { + goto handle_unusual; + } + continue; + // int32 timeout_sec = 3 [json_name = "timeoutSec"]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) { + _impl_.timeout_sec_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* ClientConfigureRequest::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:connectrpc.conformance.ClientConfigureRequest) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .connectrpc.conformance.ClientConfigureRequest.RpcType types = 1 [json_name = "types"]; + { + int byte_size = _impl_._types_cached_byte_size_.Get(); + if (byte_size > 0) { + target = stream->WriteEnumPacked(1, _internal_types(), + byte_size, target); + } + } + + // repeated .connectrpc.conformance.ClientConfigureRequest.Metadata metadata = 2 [json_name = "metadata"]; + for (unsigned i = 0, + n = static_cast(this->_internal_metadata_size()); i < n; i++) { + const auto& repfield = this->_internal_metadata(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream); + } + + // int32 timeout_sec = 3 [json_name = "timeoutSec"]; + if (this->_internal_timeout_sec() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray( + 3, this->_internal_timeout_sec(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:connectrpc.conformance.ClientConfigureRequest) + return target; +} + +::size_t ClientConfigureRequest::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:connectrpc.conformance.ClientConfigureRequest) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .connectrpc.conformance.ClientConfigureRequest.RpcType types = 1 [json_name = "types"]; + { + std::size_t data_size = 0; + auto count = static_cast(this->_internal_types_size()); + + for (std::size_t i = 0; i < count; ++i) { + data_size += ::_pbi::WireFormatLite::EnumSize( + this->_internal_types(static_cast(i))); + } + total_size += data_size; + if (data_size > 0) { + total_size += 1; + total_size += ::_pbi::WireFormatLite::Int32Size( + static_cast(data_size)); + } + _impl_._types_cached_byte_size_.Set(::_pbi::ToCachedSize(data_size)); + } + + // repeated .connectrpc.conformance.ClientConfigureRequest.Metadata metadata = 2 [json_name = "metadata"]; + total_size += 1UL * this->_internal_metadata_size(); + for (const auto& msg : this->_internal_metadata()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // int32 timeout_sec = 3 [json_name = "timeoutSec"]; + if (this->_internal_timeout_sec() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_timeout_sec()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ClientConfigureRequest::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + ClientConfigureRequest::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ClientConfigureRequest::GetClassData() const { return &_class_data_; } + + +void ClientConfigureRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:connectrpc.conformance.ClientConfigureRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_mutable_types()->MergeFrom(from._internal_types()); + _this->_internal_mutable_metadata()->MergeFrom(from._internal_metadata()); + if (from._internal_timeout_sec() != 0) { + _this->_internal_set_timeout_sec(from._internal_timeout_sec()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ClientConfigureRequest::CopyFrom(const ClientConfigureRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:connectrpc.conformance.ClientConfigureRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ClientConfigureRequest::IsInitialized() const { + return true; +} + +void ClientConfigureRequest::InternalSwap(ClientConfigureRequest* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _internal_mutable_types()->InternalSwap( + other->_internal_mutable_types()); + _internal_mutable_metadata()->InternalSwap(other->_internal_mutable_metadata()); + + swap(_impl_.timeout_sec_, other->_impl_.timeout_sec_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ClientConfigureRequest::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_getter, &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once, + file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto[26]); +} +// =================================================================== + +class ClientConfigureResponse::_Internal { + public: +}; + +ClientConfigureResponse::ClientConfigureResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena) { + // @@protoc_insertion_point(arena_constructor:connectrpc.conformance.ClientConfigureResponse) +} +ClientConfigureResponse::ClientConfigureResponse(const ClientConfigureResponse& from) + : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() { + ClientConfigureResponse* const _this = this; (void)_this; + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:connectrpc.conformance.ClientConfigureResponse) +} + + + + + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ClientConfigureResponse::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl, + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl, +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ClientConfigureResponse::GetClassData() const { return &_class_data_; } + + + + + + + +::PROTOBUF_NAMESPACE_ID::Metadata ClientConfigureResponse::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_getter, &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once, + file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto[27]); +} +// =================================================================== + +class ErrorDetail::_Internal { + public: +}; + +ErrorDetail::ErrorDetail(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:connectrpc.conformance.ErrorDetail) +} +ErrorDetail::ErrorDetail(const ErrorDetail& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + ErrorDetail* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.reason_) {} + + , decltype(_impl_.domain_) {} + + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.reason_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.reason_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_reason().empty()) { + _this->_impl_.reason_.Set(from._internal_reason(), _this->GetArenaForAllocation()); + } + _impl_.domain_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.domain_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_domain().empty()) { + _this->_impl_.domain_.Set(from._internal_domain(), _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:connectrpc.conformance.ErrorDetail) +} + +inline void ErrorDetail::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.reason_) {} + + , decltype(_impl_.domain_) {} + + , /*decltype(_impl_._cached_size_)*/{} + }; + _impl_.reason_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.reason_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.domain_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.domain_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +ErrorDetail::~ErrorDetail() { + // @@protoc_insertion_point(destructor:connectrpc.conformance.ErrorDetail) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ErrorDetail::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.reason_.Destroy(); + _impl_.domain_.Destroy(); +} + +void ErrorDetail::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ErrorDetail::Clear() { +// @@protoc_insertion_point(message_clear_start:connectrpc.conformance.ErrorDetail) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.reason_.ClearToEmpty(); + _impl_.domain_.ClearToEmpty(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ErrorDetail::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // string reason = 1 [json_name = "reason"]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { + auto str = _internal_mutable_reason(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + CHK_(::_pbi::VerifyUTF8(str, "connectrpc.conformance.ErrorDetail.reason")); + } else { + goto handle_unusual; + } + continue; + // string domain = 2 [json_name = "domain"]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { + auto str = _internal_mutable_domain(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + CHK_(::_pbi::VerifyUTF8(str, "connectrpc.conformance.ErrorDetail.domain")); + } else { + goto handle_unusual; + } + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* ErrorDetail::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:connectrpc.conformance.ErrorDetail) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // string reason = 1 [json_name = "reason"]; + if (!this->_internal_reason().empty()) { + const std::string& _s = this->_internal_reason(); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "connectrpc.conformance.ErrorDetail.reason"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // string domain = 2 [json_name = "domain"]; + if (!this->_internal_domain().empty()) { + const std::string& _s = this->_internal_domain(); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "connectrpc.conformance.ErrorDetail.domain"); + target = stream->WriteStringMaybeAliased(2, _s, target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:connectrpc.conformance.ErrorDetail) + return target; +} + +::size_t ErrorDetail::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:connectrpc.conformance.ErrorDetail) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string reason = 1 [json_name = "reason"]; + if (!this->_internal_reason().empty()) { + total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_reason()); + } + + // string domain = 2 [json_name = "domain"]; + if (!this->_internal_domain().empty()) { + total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_domain()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ErrorDetail::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + ErrorDetail::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ErrorDetail::GetClassData() const { return &_class_data_; } + + +void ErrorDetail::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:connectrpc.conformance.ErrorDetail) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_reason().empty()) { + _this->_internal_set_reason(from._internal_reason()); + } + if (!from._internal_domain().empty()) { + _this->_internal_set_domain(from._internal_domain()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ErrorDetail::CopyFrom(const ErrorDetail& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:connectrpc.conformance.ErrorDetail) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ErrorDetail::IsInitialized() const { + return true; +} + +void ErrorDetail::InternalSwap(ErrorDetail* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.reason_, lhs_arena, + &other->_impl_.reason_, rhs_arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.domain_, lhs_arena, + &other->_impl_.domain_, rhs_arena); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ErrorDetail::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_getter, &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once, + file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto[28]); +} +// =================================================================== + +class ErrorStatus::_Internal { + public: +}; + +void ErrorStatus::clear_details() { + _internal_mutable_details()->Clear(); +} +ErrorStatus::ErrorStatus(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:connectrpc.conformance.ErrorStatus) +} +ErrorStatus::ErrorStatus(const ErrorStatus& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + ErrorStatus* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.details_){from._impl_.details_} + , decltype(_impl_.message_) {} + + , decltype(_impl_.code_) {} + + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.message_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.message_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_message().empty()) { + _this->_impl_.message_.Set(from._internal_message(), _this->GetArenaForAllocation()); + } + _this->_impl_.code_ = from._impl_.code_; + // @@protoc_insertion_point(copy_constructor:connectrpc.conformance.ErrorStatus) +} + +inline void ErrorStatus::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.details_){arena} + , decltype(_impl_.message_) {} + + , decltype(_impl_.code_) { 0 } + + , /*decltype(_impl_._cached_size_)*/{} + }; + _impl_.message_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.message_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +ErrorStatus::~ErrorStatus() { + // @@protoc_insertion_point(destructor:connectrpc.conformance.ErrorStatus) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ErrorStatus::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _internal_mutable_details()->~RepeatedPtrField(); + _impl_.message_.Destroy(); +} + +void ErrorStatus::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ErrorStatus::Clear() { +// @@protoc_insertion_point(message_clear_start:connectrpc.conformance.ErrorStatus) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_mutable_details()->Clear(); + _impl_.message_.ClearToEmpty(); + _impl_.code_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ErrorStatus::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int32 code = 1 [json_name = "code"]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) { + _impl_.code_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // string message = 2 [json_name = "message"]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { + auto str = _internal_mutable_message(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + CHK_(::_pbi::VerifyUTF8(str, "connectrpc.conformance.ErrorStatus.message")); + } else { + goto handle_unusual; + } + continue; + // repeated .google.protobuf.Any details = 3 [json_name = "details"]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_details(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else { + goto handle_unusual; + } + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* ErrorStatus::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:connectrpc.conformance.ErrorStatus) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // int32 code = 1 [json_name = "code"]; + if (this->_internal_code() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray( + 1, this->_internal_code(), target); + } + + // string message = 2 [json_name = "message"]; + if (!this->_internal_message().empty()) { + const std::string& _s = this->_internal_message(); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "connectrpc.conformance.ErrorStatus.message"); + target = stream->WriteStringMaybeAliased(2, _s, target); + } + + // repeated .google.protobuf.Any details = 3 [json_name = "details"]; + for (unsigned i = 0, + n = static_cast(this->_internal_details_size()); i < n; i++) { + const auto& repfield = this->_internal_details(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:connectrpc.conformance.ErrorStatus) + return target; +} + +::size_t ErrorStatus::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:connectrpc.conformance.ErrorStatus) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .google.protobuf.Any details = 3 [json_name = "details"]; + total_size += 1UL * this->_internal_details_size(); + for (const auto& msg : this->_internal_details()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // string message = 2 [json_name = "message"]; + if (!this->_internal_message().empty()) { + total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_message()); + } + + // int32 code = 1 [json_name = "code"]; + if (this->_internal_code() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_code()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ErrorStatus::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + ErrorStatus::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ErrorStatus::GetClassData() const { return &_class_data_; } + + +void ErrorStatus::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:connectrpc.conformance.ErrorStatus) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_mutable_details()->MergeFrom(from._internal_details()); + if (!from._internal_message().empty()) { + _this->_internal_set_message(from._internal_message()); + } + if (from._internal_code() != 0) { + _this->_internal_set_code(from._internal_code()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ErrorStatus::CopyFrom(const ErrorStatus& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:connectrpc.conformance.ErrorStatus) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ErrorStatus::IsInitialized() const { + return true; +} + +void ErrorStatus::InternalSwap(ErrorStatus* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _internal_mutable_details()->InternalSwap(other->_internal_mutable_details()); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.message_, lhs_arena, + &other->_impl_.message_, rhs_arena); + + swap(_impl_.code_, other->_impl_.code_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ErrorStatus::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_getter, &descriptor_table_connectrpc_2fconformance_2fmessages_2eproto_once, + file_level_metadata_connectrpc_2fconformance_2fmessages_2eproto[29]); +} +// @@protoc_insertion_point(namespace_scope) +} // namespace conformance +} // namespace connectrpc +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::connectrpc::conformance::Payload* +Arena::CreateMaybeMessage< ::connectrpc::conformance::Payload >(Arena* arena) { + return Arena::CreateMessageInternal< ::connectrpc::conformance::Payload >(arena); +} +template<> PROTOBUF_NOINLINE ::connectrpc::conformance::EchoStatus* +Arena::CreateMaybeMessage< ::connectrpc::conformance::EchoStatus >(Arena* arena) { + return Arena::CreateMessageInternal< ::connectrpc::conformance::EchoStatus >(arena); +} +template<> PROTOBUF_NOINLINE ::connectrpc::conformance::SimpleRequest* +Arena::CreateMaybeMessage< ::connectrpc::conformance::SimpleRequest >(Arena* arena) { + return Arena::CreateMessageInternal< ::connectrpc::conformance::SimpleRequest >(arena); +} +template<> PROTOBUF_NOINLINE ::connectrpc::conformance::SimpleResponse* +Arena::CreateMaybeMessage< ::connectrpc::conformance::SimpleResponse >(Arena* arena) { + return Arena::CreateMessageInternal< ::connectrpc::conformance::SimpleResponse >(arena); +} +template<> PROTOBUF_NOINLINE ::connectrpc::conformance::StreamingInputCallRequest* +Arena::CreateMaybeMessage< ::connectrpc::conformance::StreamingInputCallRequest >(Arena* arena) { + return Arena::CreateMessageInternal< ::connectrpc::conformance::StreamingInputCallRequest >(arena); +} +template<> PROTOBUF_NOINLINE ::connectrpc::conformance::StreamingInputCallResponse* +Arena::CreateMaybeMessage< ::connectrpc::conformance::StreamingInputCallResponse >(Arena* arena) { + return Arena::CreateMessageInternal< ::connectrpc::conformance::StreamingInputCallResponse >(arena); +} +template<> PROTOBUF_NOINLINE ::connectrpc::conformance::ResponseParameters* +Arena::CreateMaybeMessage< ::connectrpc::conformance::ResponseParameters >(Arena* arena) { + return Arena::CreateMessageInternal< ::connectrpc::conformance::ResponseParameters >(arena); +} +template<> PROTOBUF_NOINLINE ::connectrpc::conformance::StreamingOutputCallRequest* +Arena::CreateMaybeMessage< ::connectrpc::conformance::StreamingOutputCallRequest >(Arena* arena) { + return Arena::CreateMessageInternal< ::connectrpc::conformance::StreamingOutputCallRequest >(arena); +} +template<> PROTOBUF_NOINLINE ::connectrpc::conformance::StreamingOutputCallResponse* +Arena::CreateMaybeMessage< ::connectrpc::conformance::StreamingOutputCallResponse >(Arena* arena) { + return Arena::CreateMessageInternal< ::connectrpc::conformance::StreamingOutputCallResponse >(arena); +} +template<> PROTOBUF_NOINLINE ::connectrpc::conformance::ReconnectParams* +Arena::CreateMaybeMessage< ::connectrpc::conformance::ReconnectParams >(Arena* arena) { + return Arena::CreateMessageInternal< ::connectrpc::conformance::ReconnectParams >(arena); +} +template<> PROTOBUF_NOINLINE ::connectrpc::conformance::ReconnectInfo* +Arena::CreateMaybeMessage< ::connectrpc::conformance::ReconnectInfo >(Arena* arena) { + return Arena::CreateMessageInternal< ::connectrpc::conformance::ReconnectInfo >(arena); +} +template<> PROTOBUF_NOINLINE ::connectrpc::conformance::LoadBalancerStatsRequest* +Arena::CreateMaybeMessage< ::connectrpc::conformance::LoadBalancerStatsRequest >(Arena* arena) { + return Arena::CreateMessageInternal< ::connectrpc::conformance::LoadBalancerStatsRequest >(arena); +} +template<> PROTOBUF_NOINLINE ::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse* +Arena::CreateMaybeMessage< ::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse >(Arena* arena) { + return Arena::CreateMessageInternal< ::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse >(arena); +} +template<> PROTOBUF_NOINLINE ::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeer* +Arena::CreateMaybeMessage< ::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeer >(Arena* arena) { + return Arena::CreateMessageInternal< ::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeer >(arena); +} +template<> PROTOBUF_NOINLINE ::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse* +Arena::CreateMaybeMessage< ::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse >(Arena* arena) { + return Arena::CreateMessageInternal< ::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse >(arena); +} +template<> PROTOBUF_NOINLINE ::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse* +Arena::CreateMaybeMessage< ::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse >(Arena* arena) { + return Arena::CreateMessageInternal< ::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse >(arena); +} +template<> PROTOBUF_NOINLINE ::connectrpc::conformance::LoadBalancerStatsResponse* +Arena::CreateMaybeMessage< ::connectrpc::conformance::LoadBalancerStatsResponse >(Arena* arena) { + return Arena::CreateMessageInternal< ::connectrpc::conformance::LoadBalancerStatsResponse >(arena); +} +template<> PROTOBUF_NOINLINE ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest* +Arena::CreateMaybeMessage< ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest >(Arena* arena) { + return Arena::CreateMessageInternal< ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest >(arena); +} +template<> PROTOBUF_NOINLINE ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse* +Arena::CreateMaybeMessage< ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse >(Arena* arena) { + return Arena::CreateMessageInternal< ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse >(arena); +} +template<> PROTOBUF_NOINLINE ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse* +Arena::CreateMaybeMessage< ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse >(Arena* arena) { + return Arena::CreateMessageInternal< ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse >(arena); +} +template<> PROTOBUF_NOINLINE ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse* +Arena::CreateMaybeMessage< ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse >(Arena* arena) { + return Arena::CreateMessageInternal< ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse >(arena); +} +template<> PROTOBUF_NOINLINE ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse* +Arena::CreateMaybeMessage< ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse >(Arena* arena) { + return Arena::CreateMessageInternal< ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse >(arena); +} +template<> PROTOBUF_NOINLINE ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_MethodStats* +Arena::CreateMaybeMessage< ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_MethodStats >(Arena* arena) { + return Arena::CreateMessageInternal< ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_MethodStats >(arena); +} +template<> PROTOBUF_NOINLINE ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse* +Arena::CreateMaybeMessage< ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse >(Arena* arena) { + return Arena::CreateMessageInternal< ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse >(arena); +} +template<> PROTOBUF_NOINLINE ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse* +Arena::CreateMaybeMessage< ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse >(Arena* arena) { + return Arena::CreateMessageInternal< ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse >(arena); +} +template<> PROTOBUF_NOINLINE ::connectrpc::conformance::ClientConfigureRequest_Metadata* +Arena::CreateMaybeMessage< ::connectrpc::conformance::ClientConfigureRequest_Metadata >(Arena* arena) { + return Arena::CreateMessageInternal< ::connectrpc::conformance::ClientConfigureRequest_Metadata >(arena); +} +template<> PROTOBUF_NOINLINE ::connectrpc::conformance::ClientConfigureRequest* +Arena::CreateMaybeMessage< ::connectrpc::conformance::ClientConfigureRequest >(Arena* arena) { + return Arena::CreateMessageInternal< ::connectrpc::conformance::ClientConfigureRequest >(arena); +} +template<> PROTOBUF_NOINLINE ::connectrpc::conformance::ClientConfigureResponse* +Arena::CreateMaybeMessage< ::connectrpc::conformance::ClientConfigureResponse >(Arena* arena) { + return Arena::CreateMessageInternal< ::connectrpc::conformance::ClientConfigureResponse >(arena); +} +template<> PROTOBUF_NOINLINE ::connectrpc::conformance::ErrorDetail* +Arena::CreateMaybeMessage< ::connectrpc::conformance::ErrorDetail >(Arena* arena) { + return Arena::CreateMessageInternal< ::connectrpc::conformance::ErrorDetail >(arena); +} +template<> PROTOBUF_NOINLINE ::connectrpc::conformance::ErrorStatus* +Arena::CreateMaybeMessage< ::connectrpc::conformance::ErrorStatus >(Arena* arena) { + return Arena::CreateMessageInternal< ::connectrpc::conformance::ErrorStatus >(arena); +} +PROTOBUF_NAMESPACE_CLOSE +// @@protoc_insertion_point(global_scope) +#include "google/protobuf/port_undef.inc" diff --git a/cc/gen/connectrpc/conformance/messages.pb.h b/cc/gen/connectrpc/conformance/messages.pb.h new file mode 100644 index 00000000..b9b8853f --- /dev/null +++ b/cc/gen/connectrpc/conformance/messages.pb.h @@ -0,0 +1,7176 @@ +// Copyright 2022 Buf Technologies, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: connectrpc/conformance/messages.proto + +#ifndef GOOGLE_PROTOBUF_INCLUDED_connectrpc_2fconformance_2fmessages_2eproto_2epb_2eh +#define GOOGLE_PROTOBUF_INCLUDED_connectrpc_2fconformance_2fmessages_2eproto_2epb_2eh + +#include +#include +#include + +#include "google/protobuf/port_def.inc" +#if PROTOBUF_VERSION < 4023000 +#error "This file was generated by a newer version of protoc which is" +#error "incompatible with your Protocol Buffer headers. Please update" +#error "your headers." +#endif // PROTOBUF_VERSION + +#if 4023004 < PROTOBUF_MIN_PROTOC_VERSION +#error "This file was generated by an older version of protoc which is" +#error "incompatible with your Protocol Buffer headers. Please" +#error "regenerate this file with a newer version of protoc." +#endif // PROTOBUF_MIN_PROTOC_VERSION +#include "google/protobuf/port_undef.inc" +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/arena.h" +#include "google/protobuf/arenastring.h" +#include "google/protobuf/generated_message_bases.h" +#include "google/protobuf/generated_message_util.h" +#include "google/protobuf/metadata_lite.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" +#include "google/protobuf/any.pb.h" +#include "google/protobuf/wrappers.pb.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" + +#define PROTOBUF_INTERNAL_EXPORT_connectrpc_2fconformance_2fmessages_2eproto + +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_connectrpc_2fconformance_2fmessages_2eproto { + static const ::uint32_t offsets[]; +}; +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable + descriptor_table_connectrpc_2fconformance_2fmessages_2eproto; +namespace connectrpc { +namespace conformance { +class ClientConfigureRequest; +struct ClientConfigureRequestDefaultTypeInternal; +extern ClientConfigureRequestDefaultTypeInternal _ClientConfigureRequest_default_instance_; +class ClientConfigureRequest_Metadata; +struct ClientConfigureRequest_MetadataDefaultTypeInternal; +extern ClientConfigureRequest_MetadataDefaultTypeInternal _ClientConfigureRequest_Metadata_default_instance_; +class ClientConfigureResponse; +struct ClientConfigureResponseDefaultTypeInternal; +extern ClientConfigureResponseDefaultTypeInternal _ClientConfigureResponse_default_instance_; +class EchoStatus; +struct EchoStatusDefaultTypeInternal; +extern EchoStatusDefaultTypeInternal _EchoStatus_default_instance_; +class ErrorDetail; +struct ErrorDetailDefaultTypeInternal; +extern ErrorDetailDefaultTypeInternal _ErrorDetail_default_instance_; +class ErrorStatus; +struct ErrorStatusDefaultTypeInternal; +extern ErrorStatusDefaultTypeInternal _ErrorStatus_default_instance_; +class LoadBalancerAccumulatedStatsRequest; +struct LoadBalancerAccumulatedStatsRequestDefaultTypeInternal; +extern LoadBalancerAccumulatedStatsRequestDefaultTypeInternal _LoadBalancerAccumulatedStatsRequest_default_instance_; +class LoadBalancerAccumulatedStatsResponse; +struct LoadBalancerAccumulatedStatsResponseDefaultTypeInternal; +extern LoadBalancerAccumulatedStatsResponseDefaultTypeInternal _LoadBalancerAccumulatedStatsResponse_default_instance_; +class LoadBalancerAccumulatedStatsResponse_MethodStats; +struct LoadBalancerAccumulatedStatsResponse_MethodStatsDefaultTypeInternal; +extern LoadBalancerAccumulatedStatsResponse_MethodStatsDefaultTypeInternal _LoadBalancerAccumulatedStatsResponse_MethodStats_default_instance_; +class LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse; +struct LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUseDefaultTypeInternal; +extern LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUseDefaultTypeInternal _LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse_default_instance_; +class LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse; +struct LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUseDefaultTypeInternal; +extern LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUseDefaultTypeInternal _LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse_default_instance_; +class LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse; +struct LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUseDefaultTypeInternal; +extern LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUseDefaultTypeInternal _LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse_default_instance_; +class LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse; +struct LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUseDefaultTypeInternal; +extern LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUseDefaultTypeInternal _LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse_default_instance_; +class LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse; +struct LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUseDefaultTypeInternal; +extern LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUseDefaultTypeInternal _LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse_default_instance_; +class LoadBalancerStatsRequest; +struct LoadBalancerStatsRequestDefaultTypeInternal; +extern LoadBalancerStatsRequestDefaultTypeInternal _LoadBalancerStatsRequest_default_instance_; +class LoadBalancerStatsResponse; +struct LoadBalancerStatsResponseDefaultTypeInternal; +extern LoadBalancerStatsResponseDefaultTypeInternal _LoadBalancerStatsResponse_default_instance_; +class LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse; +struct LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUseDefaultTypeInternal; +extern LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUseDefaultTypeInternal _LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse_default_instance_; +class LoadBalancerStatsResponse_RpcsByPeer; +struct LoadBalancerStatsResponse_RpcsByPeerDefaultTypeInternal; +extern LoadBalancerStatsResponse_RpcsByPeerDefaultTypeInternal _LoadBalancerStatsResponse_RpcsByPeer_default_instance_; +class LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse; +struct LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUseDefaultTypeInternal; +extern LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUseDefaultTypeInternal _LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse_default_instance_; +class LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse; +struct LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUseDefaultTypeInternal; +extern LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUseDefaultTypeInternal _LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse_default_instance_; +class Payload; +struct PayloadDefaultTypeInternal; +extern PayloadDefaultTypeInternal _Payload_default_instance_; +class ReconnectInfo; +struct ReconnectInfoDefaultTypeInternal; +extern ReconnectInfoDefaultTypeInternal _ReconnectInfo_default_instance_; +class ReconnectParams; +struct ReconnectParamsDefaultTypeInternal; +extern ReconnectParamsDefaultTypeInternal _ReconnectParams_default_instance_; +class ResponseParameters; +struct ResponseParametersDefaultTypeInternal; +extern ResponseParametersDefaultTypeInternal _ResponseParameters_default_instance_; +class SimpleRequest; +struct SimpleRequestDefaultTypeInternal; +extern SimpleRequestDefaultTypeInternal _SimpleRequest_default_instance_; +class SimpleResponse; +struct SimpleResponseDefaultTypeInternal; +extern SimpleResponseDefaultTypeInternal _SimpleResponse_default_instance_; +class StreamingInputCallRequest; +struct StreamingInputCallRequestDefaultTypeInternal; +extern StreamingInputCallRequestDefaultTypeInternal _StreamingInputCallRequest_default_instance_; +class StreamingInputCallResponse; +struct StreamingInputCallResponseDefaultTypeInternal; +extern StreamingInputCallResponseDefaultTypeInternal _StreamingInputCallResponse_default_instance_; +class StreamingOutputCallRequest; +struct StreamingOutputCallRequestDefaultTypeInternal; +extern StreamingOutputCallRequestDefaultTypeInternal _StreamingOutputCallRequest_default_instance_; +class StreamingOutputCallResponse; +struct StreamingOutputCallResponseDefaultTypeInternal; +extern StreamingOutputCallResponseDefaultTypeInternal _StreamingOutputCallResponse_default_instance_; +} // namespace conformance +} // namespace connectrpc +PROTOBUF_NAMESPACE_OPEN +template <> +::connectrpc::conformance::ClientConfigureRequest* Arena::CreateMaybeMessage<::connectrpc::conformance::ClientConfigureRequest>(Arena*); +template <> +::connectrpc::conformance::ClientConfigureRequest_Metadata* Arena::CreateMaybeMessage<::connectrpc::conformance::ClientConfigureRequest_Metadata>(Arena*); +template <> +::connectrpc::conformance::ClientConfigureResponse* Arena::CreateMaybeMessage<::connectrpc::conformance::ClientConfigureResponse>(Arena*); +template <> +::connectrpc::conformance::EchoStatus* Arena::CreateMaybeMessage<::connectrpc::conformance::EchoStatus>(Arena*); +template <> +::connectrpc::conformance::ErrorDetail* Arena::CreateMaybeMessage<::connectrpc::conformance::ErrorDetail>(Arena*); +template <> +::connectrpc::conformance::ErrorStatus* Arena::CreateMaybeMessage<::connectrpc::conformance::ErrorStatus>(Arena*); +template <> +::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest* Arena::CreateMaybeMessage<::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest>(Arena*); +template <> +::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse* Arena::CreateMaybeMessage<::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse>(Arena*); +template <> +::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_MethodStats* Arena::CreateMaybeMessage<::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_MethodStats>(Arena*); +template <> +::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse* Arena::CreateMaybeMessage<::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse>(Arena*); +template <> +::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse* Arena::CreateMaybeMessage<::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse>(Arena*); +template <> +::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse* Arena::CreateMaybeMessage<::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse>(Arena*); +template <> +::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse* Arena::CreateMaybeMessage<::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse>(Arena*); +template <> +::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse* Arena::CreateMaybeMessage<::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse>(Arena*); +template <> +::connectrpc::conformance::LoadBalancerStatsRequest* Arena::CreateMaybeMessage<::connectrpc::conformance::LoadBalancerStatsRequest>(Arena*); +template <> +::connectrpc::conformance::LoadBalancerStatsResponse* Arena::CreateMaybeMessage<::connectrpc::conformance::LoadBalancerStatsResponse>(Arena*); +template <> +::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse* Arena::CreateMaybeMessage<::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse>(Arena*); +template <> +::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeer* Arena::CreateMaybeMessage<::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeer>(Arena*); +template <> +::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse* Arena::CreateMaybeMessage<::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse>(Arena*); +template <> +::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse* Arena::CreateMaybeMessage<::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse>(Arena*); +template <> +::connectrpc::conformance::Payload* Arena::CreateMaybeMessage<::connectrpc::conformance::Payload>(Arena*); +template <> +::connectrpc::conformance::ReconnectInfo* Arena::CreateMaybeMessage<::connectrpc::conformance::ReconnectInfo>(Arena*); +template <> +::connectrpc::conformance::ReconnectParams* Arena::CreateMaybeMessage<::connectrpc::conformance::ReconnectParams>(Arena*); +template <> +::connectrpc::conformance::ResponseParameters* Arena::CreateMaybeMessage<::connectrpc::conformance::ResponseParameters>(Arena*); +template <> +::connectrpc::conformance::SimpleRequest* Arena::CreateMaybeMessage<::connectrpc::conformance::SimpleRequest>(Arena*); +template <> +::connectrpc::conformance::SimpleResponse* Arena::CreateMaybeMessage<::connectrpc::conformance::SimpleResponse>(Arena*); +template <> +::connectrpc::conformance::StreamingInputCallRequest* Arena::CreateMaybeMessage<::connectrpc::conformance::StreamingInputCallRequest>(Arena*); +template <> +::connectrpc::conformance::StreamingInputCallResponse* Arena::CreateMaybeMessage<::connectrpc::conformance::StreamingInputCallResponse>(Arena*); +template <> +::connectrpc::conformance::StreamingOutputCallRequest* Arena::CreateMaybeMessage<::connectrpc::conformance::StreamingOutputCallRequest>(Arena*); +template <> +::connectrpc::conformance::StreamingOutputCallResponse* Arena::CreateMaybeMessage<::connectrpc::conformance::StreamingOutputCallResponse>(Arena*); +PROTOBUF_NAMESPACE_CLOSE + +namespace connectrpc { +namespace conformance { +enum ClientConfigureRequest_RpcType : int { + ClientConfigureRequest_RpcType_EMPTY_CALL = 0, + ClientConfigureRequest_RpcType_UNARY_CALL = 1, + ClientConfigureRequest_RpcType_ClientConfigureRequest_RpcType_INT_MIN_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::min(), + ClientConfigureRequest_RpcType_ClientConfigureRequest_RpcType_INT_MAX_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::max(), +}; + +bool ClientConfigureRequest_RpcType_IsValid(int value); +constexpr ClientConfigureRequest_RpcType ClientConfigureRequest_RpcType_RpcType_MIN = static_cast(0); +constexpr ClientConfigureRequest_RpcType ClientConfigureRequest_RpcType_RpcType_MAX = static_cast(1); +constexpr int ClientConfigureRequest_RpcType_RpcType_ARRAYSIZE = 1 + 1; +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* +ClientConfigureRequest_RpcType_descriptor(); +template +const std::string& ClientConfigureRequest_RpcType_Name(T value) { + static_assert(std::is_same::value || + std::is_integral::value, + "Incorrect type passed to RpcType_Name()."); + return ClientConfigureRequest_RpcType_Name(static_cast(value)); +} +template <> +inline const std::string& ClientConfigureRequest_RpcType_Name(ClientConfigureRequest_RpcType value) { + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfDenseEnum( + static_cast(value)); +} +inline bool ClientConfigureRequest_RpcType_Parse(absl::string_view name, ClientConfigureRequest_RpcType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + ClientConfigureRequest_RpcType_descriptor(), name, value); +} +enum PayloadType : int { + COMPRESSABLE = 0, + PayloadType_INT_MIN_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::min(), + PayloadType_INT_MAX_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::max(), +}; + +bool PayloadType_IsValid(int value); +constexpr PayloadType PayloadType_MIN = static_cast(0); +constexpr PayloadType PayloadType_MAX = static_cast(0); +constexpr int PayloadType_ARRAYSIZE = 0 + 1; +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* +PayloadType_descriptor(); +template +const std::string& PayloadType_Name(T value) { + static_assert(std::is_same::value || + std::is_integral::value, + "Incorrect type passed to PayloadType_Name()."); + return PayloadType_Name(static_cast(value)); +} +template <> +inline const std::string& PayloadType_Name(PayloadType value) { + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfDenseEnum( + static_cast(value)); +} +inline bool PayloadType_Parse(absl::string_view name, PayloadType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + PayloadType_descriptor(), name, value); +} +enum GrpclbRouteType : int { + GRPCLB_ROUTE_TYPE_UNKNOWN = 0, + GRPCLB_ROUTE_TYPE_FALLBACK = 1, + GRPCLB_ROUTE_TYPE_BACKEND = 2, + GrpclbRouteType_INT_MIN_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::min(), + GrpclbRouteType_INT_MAX_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::max(), +}; + +bool GrpclbRouteType_IsValid(int value); +constexpr GrpclbRouteType GrpclbRouteType_MIN = static_cast(0); +constexpr GrpclbRouteType GrpclbRouteType_MAX = static_cast(2); +constexpr int GrpclbRouteType_ARRAYSIZE = 2 + 1; +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* +GrpclbRouteType_descriptor(); +template +const std::string& GrpclbRouteType_Name(T value) { + static_assert(std::is_same::value || + std::is_integral::value, + "Incorrect type passed to GrpclbRouteType_Name()."); + return GrpclbRouteType_Name(static_cast(value)); +} +template <> +inline const std::string& GrpclbRouteType_Name(GrpclbRouteType value) { + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfDenseEnum( + static_cast(value)); +} +inline bool GrpclbRouteType_Parse(absl::string_view name, GrpclbRouteType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + GrpclbRouteType_descriptor(), name, value); +} + +// =================================================================== + + +// ------------------------------------------------------------------- + +class Payload final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:connectrpc.conformance.Payload) */ { + public: + inline Payload() : Payload(nullptr) {} + ~Payload() override; + template + explicit PROTOBUF_CONSTEXPR Payload(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Payload(const Payload& from); + Payload(Payload&& from) noexcept + : Payload() { + *this = ::std::move(from); + } + + inline Payload& operator=(const Payload& from) { + CopyFrom(from); + return *this; + } + inline Payload& operator=(Payload&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Payload& default_instance() { + return *internal_default_instance(); + } + static inline const Payload* internal_default_instance() { + return reinterpret_cast( + &_Payload_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(Payload& a, Payload& b) { + a.Swap(&b); + } + inline void Swap(Payload* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Payload* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Payload* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Payload& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Payload& from) { + Payload::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + 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; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Payload* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "connectrpc.conformance.Payload"; + } + protected: + explicit Payload(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kBodyFieldNumber = 2, + kTypeFieldNumber = 1, + }; + // bytes body = 2 [json_name = "body"]; + void clear_body() ; + const std::string& body() const; + + + + + template + void set_body(Arg_&& arg, Args_... args); + std::string* mutable_body(); + PROTOBUF_NODISCARD std::string* release_body(); + void set_allocated_body(std::string* ptr); + + private: + const std::string& _internal_body() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_body( + const std::string& value); + std::string* _internal_mutable_body(); + + public: + // .connectrpc.conformance.PayloadType type = 1 [json_name = "type"]; + void clear_type() ; + ::connectrpc::conformance::PayloadType type() const; + void set_type(::connectrpc::conformance::PayloadType value); + + private: + ::connectrpc::conformance::PayloadType _internal_type() const; + void _internal_set_type(::connectrpc::conformance::PayloadType value); + + public: + // @@protoc_insertion_point(class_scope:connectrpc.conformance.Payload) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr body_; + int type_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_connectrpc_2fconformance_2fmessages_2eproto; +};// ------------------------------------------------------------------- + +class EchoStatus final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:connectrpc.conformance.EchoStatus) */ { + public: + inline EchoStatus() : EchoStatus(nullptr) {} + ~EchoStatus() override; + template + explicit PROTOBUF_CONSTEXPR EchoStatus(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + EchoStatus(const EchoStatus& from); + EchoStatus(EchoStatus&& from) noexcept + : EchoStatus() { + *this = ::std::move(from); + } + + inline EchoStatus& operator=(const EchoStatus& from) { + CopyFrom(from); + return *this; + } + inline EchoStatus& operator=(EchoStatus&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const EchoStatus& default_instance() { + return *internal_default_instance(); + } + static inline const EchoStatus* internal_default_instance() { + return reinterpret_cast( + &_EchoStatus_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + friend void swap(EchoStatus& a, EchoStatus& b) { + a.Swap(&b); + } + inline void Swap(EchoStatus* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(EchoStatus* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + EchoStatus* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const EchoStatus& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const EchoStatus& from) { + EchoStatus::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + 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; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(EchoStatus* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "connectrpc.conformance.EchoStatus"; + } + protected: + explicit EchoStatus(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMessageFieldNumber = 2, + kCodeFieldNumber = 1, + }; + // string message = 2 [json_name = "message"]; + void clear_message() ; + const std::string& message() const; + + + + + template + void set_message(Arg_&& arg, Args_... args); + std::string* mutable_message(); + PROTOBUF_NODISCARD std::string* release_message(); + void set_allocated_message(std::string* ptr); + + private: + const std::string& _internal_message() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_message( + const std::string& value); + std::string* _internal_mutable_message(); + + public: + // int32 code = 1 [json_name = "code"]; + void clear_code() ; + ::int32_t code() const; + void set_code(::int32_t value); + + private: + ::int32_t _internal_code() const; + void _internal_set_code(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:connectrpc.conformance.EchoStatus) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_; + ::int32_t code_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_connectrpc_2fconformance_2fmessages_2eproto; +};// ------------------------------------------------------------------- + +class SimpleRequest final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:connectrpc.conformance.SimpleRequest) */ { + public: + inline SimpleRequest() : SimpleRequest(nullptr) {} + ~SimpleRequest() override; + template + explicit PROTOBUF_CONSTEXPR SimpleRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SimpleRequest(const SimpleRequest& from); + SimpleRequest(SimpleRequest&& from) noexcept + : SimpleRequest() { + *this = ::std::move(from); + } + + inline SimpleRequest& operator=(const SimpleRequest& from) { + CopyFrom(from); + return *this; + } + inline SimpleRequest& operator=(SimpleRequest&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SimpleRequest& default_instance() { + return *internal_default_instance(); + } + static inline const SimpleRequest* internal_default_instance() { + return reinterpret_cast( + &_SimpleRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = + 2; + + friend void swap(SimpleRequest& a, SimpleRequest& b) { + a.Swap(&b); + } + inline void Swap(SimpleRequest* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SimpleRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SimpleRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SimpleRequest& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SimpleRequest& from) { + SimpleRequest::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + 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; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SimpleRequest* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "connectrpc.conformance.SimpleRequest"; + } + protected: + explicit SimpleRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kPayloadFieldNumber = 3, + kResponseCompressedFieldNumber = 6, + kResponseStatusFieldNumber = 7, + kExpectCompressedFieldNumber = 8, + kResponseTypeFieldNumber = 1, + kResponseSizeFieldNumber = 2, + kFillUsernameFieldNumber = 4, + kFillOauthScopeFieldNumber = 5, + kFillServerIdFieldNumber = 9, + kFillGrpclbRouteTypeFieldNumber = 10, + }; + // .connectrpc.conformance.Payload payload = 3 [json_name = "payload"]; + bool has_payload() const; + void clear_payload() ; + const ::connectrpc::conformance::Payload& payload() const; + PROTOBUF_NODISCARD ::connectrpc::conformance::Payload* release_payload(); + ::connectrpc::conformance::Payload* mutable_payload(); + void set_allocated_payload(::connectrpc::conformance::Payload* payload); + private: + const ::connectrpc::conformance::Payload& _internal_payload() const; + ::connectrpc::conformance::Payload* _internal_mutable_payload(); + public: + void unsafe_arena_set_allocated_payload( + ::connectrpc::conformance::Payload* payload); + ::connectrpc::conformance::Payload* unsafe_arena_release_payload(); + // .google.protobuf.BoolValue response_compressed = 6 [json_name = "responseCompressed"]; + bool has_response_compressed() const; + void clear_response_compressed() ; + const ::PROTOBUF_NAMESPACE_ID::BoolValue& response_compressed() const; + PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::BoolValue* release_response_compressed(); + ::PROTOBUF_NAMESPACE_ID::BoolValue* mutable_response_compressed(); + void set_allocated_response_compressed(::PROTOBUF_NAMESPACE_ID::BoolValue* response_compressed); + private: + const ::PROTOBUF_NAMESPACE_ID::BoolValue& _internal_response_compressed() const; + ::PROTOBUF_NAMESPACE_ID::BoolValue* _internal_mutable_response_compressed(); + public: + void unsafe_arena_set_allocated_response_compressed( + ::PROTOBUF_NAMESPACE_ID::BoolValue* response_compressed); + ::PROTOBUF_NAMESPACE_ID::BoolValue* unsafe_arena_release_response_compressed(); + // .connectrpc.conformance.EchoStatus response_status = 7 [json_name = "responseStatus"]; + bool has_response_status() const; + void clear_response_status() ; + const ::connectrpc::conformance::EchoStatus& response_status() const; + PROTOBUF_NODISCARD ::connectrpc::conformance::EchoStatus* release_response_status(); + ::connectrpc::conformance::EchoStatus* mutable_response_status(); + void set_allocated_response_status(::connectrpc::conformance::EchoStatus* response_status); + private: + const ::connectrpc::conformance::EchoStatus& _internal_response_status() const; + ::connectrpc::conformance::EchoStatus* _internal_mutable_response_status(); + public: + void unsafe_arena_set_allocated_response_status( + ::connectrpc::conformance::EchoStatus* response_status); + ::connectrpc::conformance::EchoStatus* unsafe_arena_release_response_status(); + // .google.protobuf.BoolValue expect_compressed = 8 [json_name = "expectCompressed"]; + bool has_expect_compressed() const; + void clear_expect_compressed() ; + const ::PROTOBUF_NAMESPACE_ID::BoolValue& expect_compressed() const; + PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::BoolValue* release_expect_compressed(); + ::PROTOBUF_NAMESPACE_ID::BoolValue* mutable_expect_compressed(); + void set_allocated_expect_compressed(::PROTOBUF_NAMESPACE_ID::BoolValue* expect_compressed); + private: + const ::PROTOBUF_NAMESPACE_ID::BoolValue& _internal_expect_compressed() const; + ::PROTOBUF_NAMESPACE_ID::BoolValue* _internal_mutable_expect_compressed(); + public: + void unsafe_arena_set_allocated_expect_compressed( + ::PROTOBUF_NAMESPACE_ID::BoolValue* expect_compressed); + ::PROTOBUF_NAMESPACE_ID::BoolValue* unsafe_arena_release_expect_compressed(); + // .connectrpc.conformance.PayloadType response_type = 1 [json_name = "responseType"]; + void clear_response_type() ; + ::connectrpc::conformance::PayloadType response_type() const; + void set_response_type(::connectrpc::conformance::PayloadType value); + + private: + ::connectrpc::conformance::PayloadType _internal_response_type() const; + void _internal_set_response_type(::connectrpc::conformance::PayloadType value); + + public: + // int32 response_size = 2 [json_name = "responseSize"]; + void clear_response_size() ; + ::int32_t response_size() const; + void set_response_size(::int32_t value); + + private: + ::int32_t _internal_response_size() const; + void _internal_set_response_size(::int32_t value); + + public: + // bool fill_username = 4 [json_name = "fillUsername"]; + void clear_fill_username() ; + bool fill_username() const; + void set_fill_username(bool value); + + private: + bool _internal_fill_username() const; + void _internal_set_fill_username(bool value); + + public: + // bool fill_oauth_scope = 5 [json_name = "fillOauthScope"]; + void clear_fill_oauth_scope() ; + bool fill_oauth_scope() const; + void set_fill_oauth_scope(bool value); + + private: + bool _internal_fill_oauth_scope() const; + void _internal_set_fill_oauth_scope(bool value); + + public: + // bool fill_server_id = 9 [json_name = "fillServerId"]; + void clear_fill_server_id() ; + bool fill_server_id() const; + void set_fill_server_id(bool value); + + private: + bool _internal_fill_server_id() const; + void _internal_set_fill_server_id(bool value); + + public: + // bool fill_grpclb_route_type = 10 [json_name = "fillGrpclbRouteType"]; + void clear_fill_grpclb_route_type() ; + bool fill_grpclb_route_type() const; + void set_fill_grpclb_route_type(bool value); + + private: + bool _internal_fill_grpclb_route_type() const; + void _internal_set_fill_grpclb_route_type(bool value); + + public: + // @@protoc_insertion_point(class_scope:connectrpc.conformance.SimpleRequest) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::connectrpc::conformance::Payload* payload_; + ::PROTOBUF_NAMESPACE_ID::BoolValue* response_compressed_; + ::connectrpc::conformance::EchoStatus* response_status_; + ::PROTOBUF_NAMESPACE_ID::BoolValue* expect_compressed_; + int response_type_; + ::int32_t response_size_; + bool fill_username_; + bool fill_oauth_scope_; + bool fill_server_id_; + bool fill_grpclb_route_type_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_connectrpc_2fconformance_2fmessages_2eproto; +};// ------------------------------------------------------------------- + +class SimpleResponse final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:connectrpc.conformance.SimpleResponse) */ { + public: + inline SimpleResponse() : SimpleResponse(nullptr) {} + ~SimpleResponse() override; + template + explicit PROTOBUF_CONSTEXPR SimpleResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SimpleResponse(const SimpleResponse& from); + SimpleResponse(SimpleResponse&& from) noexcept + : SimpleResponse() { + *this = ::std::move(from); + } + + inline SimpleResponse& operator=(const SimpleResponse& from) { + CopyFrom(from); + return *this; + } + inline SimpleResponse& operator=(SimpleResponse&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SimpleResponse& default_instance() { + return *internal_default_instance(); + } + static inline const SimpleResponse* internal_default_instance() { + return reinterpret_cast( + &_SimpleResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = + 3; + + friend void swap(SimpleResponse& a, SimpleResponse& b) { + a.Swap(&b); + } + inline void Swap(SimpleResponse* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SimpleResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SimpleResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SimpleResponse& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SimpleResponse& from) { + SimpleResponse::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + 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; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SimpleResponse* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "connectrpc.conformance.SimpleResponse"; + } + protected: + explicit SimpleResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kUsernameFieldNumber = 2, + kOauthScopeFieldNumber = 3, + kServerIdFieldNumber = 4, + kHostnameFieldNumber = 6, + kPayloadFieldNumber = 1, + kGrpclbRouteTypeFieldNumber = 5, + }; + // string username = 2 [json_name = "username"]; + void clear_username() ; + const std::string& username() const; + + + + + template + void set_username(Arg_&& arg, Args_... args); + std::string* mutable_username(); + PROTOBUF_NODISCARD std::string* release_username(); + void set_allocated_username(std::string* ptr); + + private: + const std::string& _internal_username() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_username( + const std::string& value); + std::string* _internal_mutable_username(); + + public: + // string oauth_scope = 3 [json_name = "oauthScope"]; + void clear_oauth_scope() ; + const std::string& oauth_scope() const; + + + + + template + void set_oauth_scope(Arg_&& arg, Args_... args); + std::string* mutable_oauth_scope(); + PROTOBUF_NODISCARD std::string* release_oauth_scope(); + void set_allocated_oauth_scope(std::string* ptr); + + private: + const std::string& _internal_oauth_scope() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_oauth_scope( + const std::string& value); + std::string* _internal_mutable_oauth_scope(); + + public: + // string server_id = 4 [json_name = "serverId"]; + void clear_server_id() ; + const std::string& server_id() const; + + + + + template + void set_server_id(Arg_&& arg, Args_... args); + std::string* mutable_server_id(); + PROTOBUF_NODISCARD std::string* release_server_id(); + void set_allocated_server_id(std::string* ptr); + + private: + const std::string& _internal_server_id() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_server_id( + const std::string& value); + std::string* _internal_mutable_server_id(); + + public: + // string hostname = 6 [json_name = "hostname"]; + void clear_hostname() ; + const std::string& hostname() const; + + + + + template + void set_hostname(Arg_&& arg, Args_... args); + std::string* mutable_hostname(); + PROTOBUF_NODISCARD std::string* release_hostname(); + void set_allocated_hostname(std::string* ptr); + + private: + const std::string& _internal_hostname() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_hostname( + const std::string& value); + std::string* _internal_mutable_hostname(); + + public: + // .connectrpc.conformance.Payload payload = 1 [json_name = "payload"]; + bool has_payload() const; + void clear_payload() ; + const ::connectrpc::conformance::Payload& payload() const; + PROTOBUF_NODISCARD ::connectrpc::conformance::Payload* release_payload(); + ::connectrpc::conformance::Payload* mutable_payload(); + void set_allocated_payload(::connectrpc::conformance::Payload* payload); + private: + const ::connectrpc::conformance::Payload& _internal_payload() const; + ::connectrpc::conformance::Payload* _internal_mutable_payload(); + public: + void unsafe_arena_set_allocated_payload( + ::connectrpc::conformance::Payload* payload); + ::connectrpc::conformance::Payload* unsafe_arena_release_payload(); + // .connectrpc.conformance.GrpclbRouteType grpclb_route_type = 5 [json_name = "grpclbRouteType"]; + void clear_grpclb_route_type() ; + ::connectrpc::conformance::GrpclbRouteType grpclb_route_type() const; + void set_grpclb_route_type(::connectrpc::conformance::GrpclbRouteType value); + + private: + ::connectrpc::conformance::GrpclbRouteType _internal_grpclb_route_type() const; + void _internal_set_grpclb_route_type(::connectrpc::conformance::GrpclbRouteType value); + + public: + // @@protoc_insertion_point(class_scope:connectrpc.conformance.SimpleResponse) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr username_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr oauth_scope_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr server_id_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hostname_; + ::connectrpc::conformance::Payload* payload_; + int grpclb_route_type_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_connectrpc_2fconformance_2fmessages_2eproto; +};// ------------------------------------------------------------------- + +class StreamingInputCallRequest final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:connectrpc.conformance.StreamingInputCallRequest) */ { + public: + inline StreamingInputCallRequest() : StreamingInputCallRequest(nullptr) {} + ~StreamingInputCallRequest() override; + template + explicit PROTOBUF_CONSTEXPR StreamingInputCallRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + StreamingInputCallRequest(const StreamingInputCallRequest& from); + StreamingInputCallRequest(StreamingInputCallRequest&& from) noexcept + : StreamingInputCallRequest() { + *this = ::std::move(from); + } + + inline StreamingInputCallRequest& operator=(const StreamingInputCallRequest& from) { + CopyFrom(from); + return *this; + } + inline StreamingInputCallRequest& operator=(StreamingInputCallRequest&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const StreamingInputCallRequest& default_instance() { + return *internal_default_instance(); + } + static inline const StreamingInputCallRequest* internal_default_instance() { + return reinterpret_cast( + &_StreamingInputCallRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = + 4; + + friend void swap(StreamingInputCallRequest& a, StreamingInputCallRequest& b) { + a.Swap(&b); + } + inline void Swap(StreamingInputCallRequest* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(StreamingInputCallRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + StreamingInputCallRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const StreamingInputCallRequest& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const StreamingInputCallRequest& from) { + StreamingInputCallRequest::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + 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; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(StreamingInputCallRequest* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "connectrpc.conformance.StreamingInputCallRequest"; + } + protected: + explicit StreamingInputCallRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kPayloadFieldNumber = 1, + kExpectCompressedFieldNumber = 2, + }; + // .connectrpc.conformance.Payload payload = 1 [json_name = "payload"]; + bool has_payload() const; + void clear_payload() ; + const ::connectrpc::conformance::Payload& payload() const; + PROTOBUF_NODISCARD ::connectrpc::conformance::Payload* release_payload(); + ::connectrpc::conformance::Payload* mutable_payload(); + void set_allocated_payload(::connectrpc::conformance::Payload* payload); + private: + const ::connectrpc::conformance::Payload& _internal_payload() const; + ::connectrpc::conformance::Payload* _internal_mutable_payload(); + public: + void unsafe_arena_set_allocated_payload( + ::connectrpc::conformance::Payload* payload); + ::connectrpc::conformance::Payload* unsafe_arena_release_payload(); + // .google.protobuf.BoolValue expect_compressed = 2 [json_name = "expectCompressed"]; + bool has_expect_compressed() const; + void clear_expect_compressed() ; + const ::PROTOBUF_NAMESPACE_ID::BoolValue& expect_compressed() const; + PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::BoolValue* release_expect_compressed(); + ::PROTOBUF_NAMESPACE_ID::BoolValue* mutable_expect_compressed(); + void set_allocated_expect_compressed(::PROTOBUF_NAMESPACE_ID::BoolValue* expect_compressed); + private: + const ::PROTOBUF_NAMESPACE_ID::BoolValue& _internal_expect_compressed() const; + ::PROTOBUF_NAMESPACE_ID::BoolValue* _internal_mutable_expect_compressed(); + public: + void unsafe_arena_set_allocated_expect_compressed( + ::PROTOBUF_NAMESPACE_ID::BoolValue* expect_compressed); + ::PROTOBUF_NAMESPACE_ID::BoolValue* unsafe_arena_release_expect_compressed(); + // @@protoc_insertion_point(class_scope:connectrpc.conformance.StreamingInputCallRequest) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::connectrpc::conformance::Payload* payload_; + ::PROTOBUF_NAMESPACE_ID::BoolValue* expect_compressed_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_connectrpc_2fconformance_2fmessages_2eproto; +};// ------------------------------------------------------------------- + +class StreamingInputCallResponse final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:connectrpc.conformance.StreamingInputCallResponse) */ { + public: + inline StreamingInputCallResponse() : StreamingInputCallResponse(nullptr) {} + ~StreamingInputCallResponse() override; + template + explicit PROTOBUF_CONSTEXPR StreamingInputCallResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + StreamingInputCallResponse(const StreamingInputCallResponse& from); + StreamingInputCallResponse(StreamingInputCallResponse&& from) noexcept + : StreamingInputCallResponse() { + *this = ::std::move(from); + } + + inline StreamingInputCallResponse& operator=(const StreamingInputCallResponse& from) { + CopyFrom(from); + return *this; + } + inline StreamingInputCallResponse& operator=(StreamingInputCallResponse&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const StreamingInputCallResponse& default_instance() { + return *internal_default_instance(); + } + static inline const StreamingInputCallResponse* internal_default_instance() { + return reinterpret_cast( + &_StreamingInputCallResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = + 5; + + friend void swap(StreamingInputCallResponse& a, StreamingInputCallResponse& b) { + a.Swap(&b); + } + inline void Swap(StreamingInputCallResponse* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(StreamingInputCallResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + StreamingInputCallResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const StreamingInputCallResponse& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const StreamingInputCallResponse& from) { + StreamingInputCallResponse::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + 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; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(StreamingInputCallResponse* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "connectrpc.conformance.StreamingInputCallResponse"; + } + protected: + explicit StreamingInputCallResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kAggregatedPayloadSizeFieldNumber = 1, + }; + // int32 aggregated_payload_size = 1 [json_name = "aggregatedPayloadSize"]; + void clear_aggregated_payload_size() ; + ::int32_t aggregated_payload_size() const; + void set_aggregated_payload_size(::int32_t value); + + private: + ::int32_t _internal_aggregated_payload_size() const; + void _internal_set_aggregated_payload_size(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:connectrpc.conformance.StreamingInputCallResponse) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::int32_t aggregated_payload_size_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_connectrpc_2fconformance_2fmessages_2eproto; +};// ------------------------------------------------------------------- + +class ResponseParameters final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:connectrpc.conformance.ResponseParameters) */ { + public: + inline ResponseParameters() : ResponseParameters(nullptr) {} + ~ResponseParameters() override; + template + explicit PROTOBUF_CONSTEXPR ResponseParameters(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ResponseParameters(const ResponseParameters& from); + ResponseParameters(ResponseParameters&& from) noexcept + : ResponseParameters() { + *this = ::std::move(from); + } + + inline ResponseParameters& operator=(const ResponseParameters& from) { + CopyFrom(from); + return *this; + } + inline ResponseParameters& operator=(ResponseParameters&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ResponseParameters& default_instance() { + return *internal_default_instance(); + } + static inline const ResponseParameters* internal_default_instance() { + return reinterpret_cast( + &_ResponseParameters_default_instance_); + } + static constexpr int kIndexInFileMessages = + 6; + + friend void swap(ResponseParameters& a, ResponseParameters& b) { + a.Swap(&b); + } + inline void Swap(ResponseParameters* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ResponseParameters* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ResponseParameters* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ResponseParameters& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const ResponseParameters& from) { + ResponseParameters::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + 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; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ResponseParameters* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "connectrpc.conformance.ResponseParameters"; + } + protected: + explicit ResponseParameters(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kCompressedFieldNumber = 3, + kSizeFieldNumber = 1, + kIntervalUsFieldNumber = 2, + }; + // .google.protobuf.BoolValue compressed = 3 [json_name = "compressed"]; + bool has_compressed() const; + void clear_compressed() ; + const ::PROTOBUF_NAMESPACE_ID::BoolValue& compressed() const; + PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::BoolValue* release_compressed(); + ::PROTOBUF_NAMESPACE_ID::BoolValue* mutable_compressed(); + void set_allocated_compressed(::PROTOBUF_NAMESPACE_ID::BoolValue* compressed); + private: + const ::PROTOBUF_NAMESPACE_ID::BoolValue& _internal_compressed() const; + ::PROTOBUF_NAMESPACE_ID::BoolValue* _internal_mutable_compressed(); + public: + void unsafe_arena_set_allocated_compressed( + ::PROTOBUF_NAMESPACE_ID::BoolValue* compressed); + ::PROTOBUF_NAMESPACE_ID::BoolValue* unsafe_arena_release_compressed(); + // int32 size = 1 [json_name = "size"]; + void clear_size() ; + ::int32_t size() const; + void set_size(::int32_t value); + + private: + ::int32_t _internal_size() const; + void _internal_set_size(::int32_t value); + + public: + // int32 interval_us = 2 [json_name = "intervalUs"]; + void clear_interval_us() ; + ::int32_t interval_us() const; + void set_interval_us(::int32_t value); + + private: + ::int32_t _internal_interval_us() const; + void _internal_set_interval_us(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:connectrpc.conformance.ResponseParameters) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::BoolValue* compressed_; + ::int32_t size_; + ::int32_t interval_us_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_connectrpc_2fconformance_2fmessages_2eproto; +};// ------------------------------------------------------------------- + +class StreamingOutputCallRequest final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:connectrpc.conformance.StreamingOutputCallRequest) */ { + public: + inline StreamingOutputCallRequest() : StreamingOutputCallRequest(nullptr) {} + ~StreamingOutputCallRequest() override; + template + explicit PROTOBUF_CONSTEXPR StreamingOutputCallRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + StreamingOutputCallRequest(const StreamingOutputCallRequest& from); + StreamingOutputCallRequest(StreamingOutputCallRequest&& from) noexcept + : StreamingOutputCallRequest() { + *this = ::std::move(from); + } + + inline StreamingOutputCallRequest& operator=(const StreamingOutputCallRequest& from) { + CopyFrom(from); + return *this; + } + inline StreamingOutputCallRequest& operator=(StreamingOutputCallRequest&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const StreamingOutputCallRequest& default_instance() { + return *internal_default_instance(); + } + static inline const StreamingOutputCallRequest* internal_default_instance() { + return reinterpret_cast( + &_StreamingOutputCallRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = + 7; + + friend void swap(StreamingOutputCallRequest& a, StreamingOutputCallRequest& b) { + a.Swap(&b); + } + inline void Swap(StreamingOutputCallRequest* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(StreamingOutputCallRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + StreamingOutputCallRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const StreamingOutputCallRequest& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const StreamingOutputCallRequest& from) { + StreamingOutputCallRequest::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + 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; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(StreamingOutputCallRequest* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "connectrpc.conformance.StreamingOutputCallRequest"; + } + protected: + explicit StreamingOutputCallRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kResponseParametersFieldNumber = 2, + kPayloadFieldNumber = 3, + kResponseStatusFieldNumber = 7, + kResponseTypeFieldNumber = 1, + }; + // repeated .connectrpc.conformance.ResponseParameters response_parameters = 2 [json_name = "responseParameters"]; + int response_parameters_size() const; + private: + int _internal_response_parameters_size() const; + + public: + void clear_response_parameters() ; + ::connectrpc::conformance::ResponseParameters* mutable_response_parameters(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::connectrpc::conformance::ResponseParameters >* + mutable_response_parameters(); + private: + const ::connectrpc::conformance::ResponseParameters& _internal_response_parameters(int index) const; + ::connectrpc::conformance::ResponseParameters* _internal_add_response_parameters(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::connectrpc::conformance::ResponseParameters>& _internal_response_parameters() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::connectrpc::conformance::ResponseParameters>* _internal_mutable_response_parameters(); + public: + const ::connectrpc::conformance::ResponseParameters& response_parameters(int index) const; + ::connectrpc::conformance::ResponseParameters* add_response_parameters(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::connectrpc::conformance::ResponseParameters >& + response_parameters() const; + // .connectrpc.conformance.Payload payload = 3 [json_name = "payload"]; + bool has_payload() const; + void clear_payload() ; + const ::connectrpc::conformance::Payload& payload() const; + PROTOBUF_NODISCARD ::connectrpc::conformance::Payload* release_payload(); + ::connectrpc::conformance::Payload* mutable_payload(); + void set_allocated_payload(::connectrpc::conformance::Payload* payload); + private: + const ::connectrpc::conformance::Payload& _internal_payload() const; + ::connectrpc::conformance::Payload* _internal_mutable_payload(); + public: + void unsafe_arena_set_allocated_payload( + ::connectrpc::conformance::Payload* payload); + ::connectrpc::conformance::Payload* unsafe_arena_release_payload(); + // .connectrpc.conformance.EchoStatus response_status = 7 [json_name = "responseStatus"]; + bool has_response_status() const; + void clear_response_status() ; + const ::connectrpc::conformance::EchoStatus& response_status() const; + PROTOBUF_NODISCARD ::connectrpc::conformance::EchoStatus* release_response_status(); + ::connectrpc::conformance::EchoStatus* mutable_response_status(); + void set_allocated_response_status(::connectrpc::conformance::EchoStatus* response_status); + private: + const ::connectrpc::conformance::EchoStatus& _internal_response_status() const; + ::connectrpc::conformance::EchoStatus* _internal_mutable_response_status(); + public: + void unsafe_arena_set_allocated_response_status( + ::connectrpc::conformance::EchoStatus* response_status); + ::connectrpc::conformance::EchoStatus* unsafe_arena_release_response_status(); + // .connectrpc.conformance.PayloadType response_type = 1 [json_name = "responseType"]; + void clear_response_type() ; + ::connectrpc::conformance::PayloadType response_type() const; + void set_response_type(::connectrpc::conformance::PayloadType value); + + private: + ::connectrpc::conformance::PayloadType _internal_response_type() const; + void _internal_set_response_type(::connectrpc::conformance::PayloadType value); + + public: + // @@protoc_insertion_point(class_scope:connectrpc.conformance.StreamingOutputCallRequest) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::connectrpc::conformance::ResponseParameters > response_parameters_; + ::connectrpc::conformance::Payload* payload_; + ::connectrpc::conformance::EchoStatus* response_status_; + int response_type_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_connectrpc_2fconformance_2fmessages_2eproto; +};// ------------------------------------------------------------------- + +class StreamingOutputCallResponse final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:connectrpc.conformance.StreamingOutputCallResponse) */ { + public: + inline StreamingOutputCallResponse() : StreamingOutputCallResponse(nullptr) {} + ~StreamingOutputCallResponse() override; + template + explicit PROTOBUF_CONSTEXPR StreamingOutputCallResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + StreamingOutputCallResponse(const StreamingOutputCallResponse& from); + StreamingOutputCallResponse(StreamingOutputCallResponse&& from) noexcept + : StreamingOutputCallResponse() { + *this = ::std::move(from); + } + + inline StreamingOutputCallResponse& operator=(const StreamingOutputCallResponse& from) { + CopyFrom(from); + return *this; + } + inline StreamingOutputCallResponse& operator=(StreamingOutputCallResponse&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const StreamingOutputCallResponse& default_instance() { + return *internal_default_instance(); + } + static inline const StreamingOutputCallResponse* internal_default_instance() { + return reinterpret_cast( + &_StreamingOutputCallResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = + 8; + + friend void swap(StreamingOutputCallResponse& a, StreamingOutputCallResponse& b) { + a.Swap(&b); + } + inline void Swap(StreamingOutputCallResponse* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(StreamingOutputCallResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + StreamingOutputCallResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const StreamingOutputCallResponse& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const StreamingOutputCallResponse& from) { + StreamingOutputCallResponse::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + 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; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(StreamingOutputCallResponse* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "connectrpc.conformance.StreamingOutputCallResponse"; + } + protected: + explicit StreamingOutputCallResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kPayloadFieldNumber = 1, + }; + // .connectrpc.conformance.Payload payload = 1 [json_name = "payload"]; + bool has_payload() const; + void clear_payload() ; + const ::connectrpc::conformance::Payload& payload() const; + PROTOBUF_NODISCARD ::connectrpc::conformance::Payload* release_payload(); + ::connectrpc::conformance::Payload* mutable_payload(); + void set_allocated_payload(::connectrpc::conformance::Payload* payload); + private: + const ::connectrpc::conformance::Payload& _internal_payload() const; + ::connectrpc::conformance::Payload* _internal_mutable_payload(); + public: + void unsafe_arena_set_allocated_payload( + ::connectrpc::conformance::Payload* payload); + ::connectrpc::conformance::Payload* unsafe_arena_release_payload(); + // @@protoc_insertion_point(class_scope:connectrpc.conformance.StreamingOutputCallResponse) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::connectrpc::conformance::Payload* payload_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_connectrpc_2fconformance_2fmessages_2eproto; +};// ------------------------------------------------------------------- + +class ReconnectParams final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:connectrpc.conformance.ReconnectParams) */ { + public: + inline ReconnectParams() : ReconnectParams(nullptr) {} + ~ReconnectParams() override; + template + explicit PROTOBUF_CONSTEXPR ReconnectParams(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ReconnectParams(const ReconnectParams& from); + ReconnectParams(ReconnectParams&& from) noexcept + : ReconnectParams() { + *this = ::std::move(from); + } + + inline ReconnectParams& operator=(const ReconnectParams& from) { + CopyFrom(from); + return *this; + } + inline ReconnectParams& operator=(ReconnectParams&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ReconnectParams& default_instance() { + return *internal_default_instance(); + } + static inline const ReconnectParams* internal_default_instance() { + return reinterpret_cast( + &_ReconnectParams_default_instance_); + } + static constexpr int kIndexInFileMessages = + 9; + + friend void swap(ReconnectParams& a, ReconnectParams& b) { + a.Swap(&b); + } + inline void Swap(ReconnectParams* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ReconnectParams* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ReconnectParams* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ReconnectParams& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const ReconnectParams& from) { + ReconnectParams::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + 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; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ReconnectParams* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "connectrpc.conformance.ReconnectParams"; + } + protected: + explicit ReconnectParams(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMaxReconnectBackoffMsFieldNumber = 1, + }; + // int32 max_reconnect_backoff_ms = 1 [json_name = "maxReconnectBackoffMs"]; + void clear_max_reconnect_backoff_ms() ; + ::int32_t max_reconnect_backoff_ms() const; + void set_max_reconnect_backoff_ms(::int32_t value); + + private: + ::int32_t _internal_max_reconnect_backoff_ms() const; + void _internal_set_max_reconnect_backoff_ms(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:connectrpc.conformance.ReconnectParams) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::int32_t max_reconnect_backoff_ms_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_connectrpc_2fconformance_2fmessages_2eproto; +};// ------------------------------------------------------------------- + +class ReconnectInfo final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:connectrpc.conformance.ReconnectInfo) */ { + public: + inline ReconnectInfo() : ReconnectInfo(nullptr) {} + ~ReconnectInfo() override; + template + explicit PROTOBUF_CONSTEXPR ReconnectInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ReconnectInfo(const ReconnectInfo& from); + ReconnectInfo(ReconnectInfo&& from) noexcept + : ReconnectInfo() { + *this = ::std::move(from); + } + + inline ReconnectInfo& operator=(const ReconnectInfo& from) { + CopyFrom(from); + return *this; + } + inline ReconnectInfo& operator=(ReconnectInfo&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ReconnectInfo& default_instance() { + return *internal_default_instance(); + } + static inline const ReconnectInfo* internal_default_instance() { + return reinterpret_cast( + &_ReconnectInfo_default_instance_); + } + static constexpr int kIndexInFileMessages = + 10; + + friend void swap(ReconnectInfo& a, ReconnectInfo& b) { + a.Swap(&b); + } + inline void Swap(ReconnectInfo* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ReconnectInfo* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ReconnectInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ReconnectInfo& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const ReconnectInfo& from) { + ReconnectInfo::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + 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; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ReconnectInfo* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "connectrpc.conformance.ReconnectInfo"; + } + protected: + explicit ReconnectInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kBackoffMsFieldNumber = 2, + kPassedFieldNumber = 1, + }; + // repeated int32 backoff_ms = 2 [json_name = "backoffMs"]; + int backoff_ms_size() const; + private: + int _internal_backoff_ms_size() const; + + public: + void clear_backoff_ms() ; + ::int32_t backoff_ms(int index) const; + void set_backoff_ms(int index, ::int32_t value); + void add_backoff_ms(::int32_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& backoff_ms() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* mutable_backoff_ms(); + + private: + ::int32_t _internal_backoff_ms(int index) const; + void _internal_add_backoff_ms(::int32_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& _internal_backoff_ms() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* _internal_mutable_backoff_ms(); + + public: + // bool passed = 1 [json_name = "passed"]; + void clear_passed() ; + bool passed() const; + void set_passed(bool value); + + private: + bool _internal_passed() const; + void _internal_set_passed(bool value); + + public: + // @@protoc_insertion_point(class_scope:connectrpc.conformance.ReconnectInfo) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t> backoff_ms_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _backoff_ms_cached_byte_size_; + bool passed_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_connectrpc_2fconformance_2fmessages_2eproto; +};// ------------------------------------------------------------------- + +class LoadBalancerStatsRequest final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:connectrpc.conformance.LoadBalancerStatsRequest) */ { + public: + inline LoadBalancerStatsRequest() : LoadBalancerStatsRequest(nullptr) {} + ~LoadBalancerStatsRequest() override; + template + explicit PROTOBUF_CONSTEXPR LoadBalancerStatsRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + LoadBalancerStatsRequest(const LoadBalancerStatsRequest& from); + LoadBalancerStatsRequest(LoadBalancerStatsRequest&& from) noexcept + : LoadBalancerStatsRequest() { + *this = ::std::move(from); + } + + inline LoadBalancerStatsRequest& operator=(const LoadBalancerStatsRequest& from) { + CopyFrom(from); + return *this; + } + inline LoadBalancerStatsRequest& operator=(LoadBalancerStatsRequest&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const LoadBalancerStatsRequest& default_instance() { + return *internal_default_instance(); + } + static inline const LoadBalancerStatsRequest* internal_default_instance() { + return reinterpret_cast( + &_LoadBalancerStatsRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = + 11; + + friend void swap(LoadBalancerStatsRequest& a, LoadBalancerStatsRequest& b) { + a.Swap(&b); + } + inline void Swap(LoadBalancerStatsRequest* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(LoadBalancerStatsRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + LoadBalancerStatsRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const LoadBalancerStatsRequest& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const LoadBalancerStatsRequest& from) { + LoadBalancerStatsRequest::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + 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; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(LoadBalancerStatsRequest* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "connectrpc.conformance.LoadBalancerStatsRequest"; + } + protected: + explicit LoadBalancerStatsRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNumRpcsFieldNumber = 1, + kTimeoutSecFieldNumber = 2, + }; + // int32 num_rpcs = 1 [json_name = "numRpcs"]; + void clear_num_rpcs() ; + ::int32_t num_rpcs() const; + void set_num_rpcs(::int32_t value); + + private: + ::int32_t _internal_num_rpcs() const; + void _internal_set_num_rpcs(::int32_t value); + + public: + // int32 timeout_sec = 2 [json_name = "timeoutSec"]; + void clear_timeout_sec() ; + ::int32_t timeout_sec() const; + void set_timeout_sec(::int32_t value); + + private: + ::int32_t _internal_timeout_sec() const; + void _internal_set_timeout_sec(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:connectrpc.conformance.LoadBalancerStatsRequest) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::int32_t num_rpcs_; + ::int32_t timeout_sec_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_connectrpc_2fconformance_2fmessages_2eproto; +};// ------------------------------------------------------------------- + +class LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse final : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry { +public: + typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry SuperType; + LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse(); + template + explicit PROTOBUF_CONSTEXPR LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + explicit LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void MergeFrom(const LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse& other); + static const LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse* internal_default_instance() { return reinterpret_cast(&_LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse_default_instance_); } + static bool ValidateKey(std::string* s) { + return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "connectrpc.conformance.LoadBalancerStatsResponse.RpcsByPeer.RpcsByPeerEntry.key"); + } + static bool ValidateValue(void*) { return true; } + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + friend struct ::TableStruct_connectrpc_2fconformance_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class LoadBalancerStatsResponse_RpcsByPeer final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:connectrpc.conformance.LoadBalancerStatsResponse.RpcsByPeer) */ { + public: + inline LoadBalancerStatsResponse_RpcsByPeer() : LoadBalancerStatsResponse_RpcsByPeer(nullptr) {} + ~LoadBalancerStatsResponse_RpcsByPeer() override; + template + explicit PROTOBUF_CONSTEXPR LoadBalancerStatsResponse_RpcsByPeer(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + LoadBalancerStatsResponse_RpcsByPeer(const LoadBalancerStatsResponse_RpcsByPeer& from); + LoadBalancerStatsResponse_RpcsByPeer(LoadBalancerStatsResponse_RpcsByPeer&& from) noexcept + : LoadBalancerStatsResponse_RpcsByPeer() { + *this = ::std::move(from); + } + + inline LoadBalancerStatsResponse_RpcsByPeer& operator=(const LoadBalancerStatsResponse_RpcsByPeer& from) { + CopyFrom(from); + return *this; + } + inline LoadBalancerStatsResponse_RpcsByPeer& operator=(LoadBalancerStatsResponse_RpcsByPeer&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const LoadBalancerStatsResponse_RpcsByPeer& default_instance() { + return *internal_default_instance(); + } + static inline const LoadBalancerStatsResponse_RpcsByPeer* internal_default_instance() { + return reinterpret_cast( + &_LoadBalancerStatsResponse_RpcsByPeer_default_instance_); + } + static constexpr int kIndexInFileMessages = + 13; + + friend void swap(LoadBalancerStatsResponse_RpcsByPeer& a, LoadBalancerStatsResponse_RpcsByPeer& b) { + a.Swap(&b); + } + inline void Swap(LoadBalancerStatsResponse_RpcsByPeer* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(LoadBalancerStatsResponse_RpcsByPeer* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + LoadBalancerStatsResponse_RpcsByPeer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const LoadBalancerStatsResponse_RpcsByPeer& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const LoadBalancerStatsResponse_RpcsByPeer& from) { + LoadBalancerStatsResponse_RpcsByPeer::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + 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; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(LoadBalancerStatsResponse_RpcsByPeer* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "connectrpc.conformance.LoadBalancerStatsResponse.RpcsByPeer"; + } + protected: + explicit LoadBalancerStatsResponse_RpcsByPeer(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + + // accessors ------------------------------------------------------- + + enum : int { + kRpcsByPeerFieldNumber = 1, + }; + // map rpcs_by_peer = 1 [json_name = "rpcsByPeer"]; + int rpcs_by_peer_size() const; + private: + int _internal_rpcs_by_peer_size() const; + + public: + void clear_rpcs_by_peer() ; + private: + const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >& + _internal_rpcs_by_peer() const; + ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >* + _internal_mutable_rpcs_by_peer(); + public: + const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >& + rpcs_by_peer() const; + ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >* + mutable_rpcs_by_peer(); + // @@protoc_insertion_point(class_scope:connectrpc.conformance.LoadBalancerStatsResponse.RpcsByPeer) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::MapField< + LoadBalancerStatsResponse_RpcsByPeer_RpcsByPeerEntry_DoNotUse, + std::string, ::int32_t, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32> rpcs_by_peer_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_connectrpc_2fconformance_2fmessages_2eproto; +};// ------------------------------------------------------------------- + +class LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse final : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry { +public: + typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry SuperType; + LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse(); + template + explicit PROTOBUF_CONSTEXPR LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + explicit LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void MergeFrom(const LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse& other); + static const LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse* internal_default_instance() { return reinterpret_cast(&_LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse_default_instance_); } + static bool ValidateKey(std::string* s) { + return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "connectrpc.conformance.LoadBalancerStatsResponse.RpcsByPeerEntry.key"); + } + static bool ValidateValue(void*) { return true; } + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + friend struct ::TableStruct_connectrpc_2fconformance_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse final : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry { +public: + typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry SuperType; + LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse(); + template + explicit PROTOBUF_CONSTEXPR LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + explicit LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void MergeFrom(const LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse& other); + static const LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse* internal_default_instance() { return reinterpret_cast(&_LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse_default_instance_); } + static bool ValidateKey(std::string* s) { + return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "connectrpc.conformance.LoadBalancerStatsResponse.RpcsByMethodEntry.key"); + } + static bool ValidateValue(void*) { return true; } + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + friend struct ::TableStruct_connectrpc_2fconformance_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class LoadBalancerStatsResponse final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:connectrpc.conformance.LoadBalancerStatsResponse) */ { + public: + inline LoadBalancerStatsResponse() : LoadBalancerStatsResponse(nullptr) {} + ~LoadBalancerStatsResponse() override; + template + explicit PROTOBUF_CONSTEXPR LoadBalancerStatsResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + LoadBalancerStatsResponse(const LoadBalancerStatsResponse& from); + LoadBalancerStatsResponse(LoadBalancerStatsResponse&& from) noexcept + : LoadBalancerStatsResponse() { + *this = ::std::move(from); + } + + inline LoadBalancerStatsResponse& operator=(const LoadBalancerStatsResponse& from) { + CopyFrom(from); + return *this; + } + inline LoadBalancerStatsResponse& operator=(LoadBalancerStatsResponse&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const LoadBalancerStatsResponse& default_instance() { + return *internal_default_instance(); + } + static inline const LoadBalancerStatsResponse* internal_default_instance() { + return reinterpret_cast( + &_LoadBalancerStatsResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = + 16; + + friend void swap(LoadBalancerStatsResponse& a, LoadBalancerStatsResponse& b) { + a.Swap(&b); + } + inline void Swap(LoadBalancerStatsResponse* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(LoadBalancerStatsResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + LoadBalancerStatsResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const LoadBalancerStatsResponse& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const LoadBalancerStatsResponse& from) { + LoadBalancerStatsResponse::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + 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; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(LoadBalancerStatsResponse* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "connectrpc.conformance.LoadBalancerStatsResponse"; + } + protected: + explicit LoadBalancerStatsResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef LoadBalancerStatsResponse_RpcsByPeer RpcsByPeer; + + // accessors ------------------------------------------------------- + + enum : int { + kRpcsByPeerFieldNumber = 1, + kRpcsByMethodFieldNumber = 3, + kNumFailuresFieldNumber = 2, + }; + // map rpcs_by_peer = 1 [json_name = "rpcsByPeer"]; + int rpcs_by_peer_size() const; + private: + int _internal_rpcs_by_peer_size() const; + + public: + void clear_rpcs_by_peer() ; + private: + const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >& + _internal_rpcs_by_peer() const; + ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >* + _internal_mutable_rpcs_by_peer(); + public: + const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >& + rpcs_by_peer() const; + ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >* + mutable_rpcs_by_peer(); + // map rpcs_by_method = 3 [json_name = "rpcsByMethod"]; + int rpcs_by_method_size() const; + private: + int _internal_rpcs_by_method_size() const; + + public: + void clear_rpcs_by_method() ; + private: + const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeer >& + _internal_rpcs_by_method() const; + ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeer >* + _internal_mutable_rpcs_by_method(); + public: + const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeer >& + rpcs_by_method() const; + ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeer >* + mutable_rpcs_by_method(); + // int32 num_failures = 2 [json_name = "numFailures"]; + void clear_num_failures() ; + ::int32_t num_failures() const; + void set_num_failures(::int32_t value); + + private: + ::int32_t _internal_num_failures() const; + void _internal_set_num_failures(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:connectrpc.conformance.LoadBalancerStatsResponse) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::MapField< + LoadBalancerStatsResponse_RpcsByPeerEntry_DoNotUse, + std::string, ::int32_t, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32> rpcs_by_peer_; + ::PROTOBUF_NAMESPACE_ID::internal::MapField< + LoadBalancerStatsResponse_RpcsByMethodEntry_DoNotUse, + std::string, ::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeer, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> rpcs_by_method_; + ::int32_t num_failures_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_connectrpc_2fconformance_2fmessages_2eproto; +};// ------------------------------------------------------------------- + +class LoadBalancerAccumulatedStatsRequest final : + public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:connectrpc.conformance.LoadBalancerAccumulatedStatsRequest) */ { + public: + inline LoadBalancerAccumulatedStatsRequest() : LoadBalancerAccumulatedStatsRequest(nullptr) {} + template + explicit PROTOBUF_CONSTEXPR LoadBalancerAccumulatedStatsRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + LoadBalancerAccumulatedStatsRequest(const LoadBalancerAccumulatedStatsRequest& from); + LoadBalancerAccumulatedStatsRequest(LoadBalancerAccumulatedStatsRequest&& from) noexcept + : LoadBalancerAccumulatedStatsRequest() { + *this = ::std::move(from); + } + + inline LoadBalancerAccumulatedStatsRequest& operator=(const LoadBalancerAccumulatedStatsRequest& from) { + CopyFrom(from); + return *this; + } + inline LoadBalancerAccumulatedStatsRequest& operator=(LoadBalancerAccumulatedStatsRequest&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const LoadBalancerAccumulatedStatsRequest& default_instance() { + return *internal_default_instance(); + } + static inline const LoadBalancerAccumulatedStatsRequest* internal_default_instance() { + return reinterpret_cast( + &_LoadBalancerAccumulatedStatsRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = + 17; + + friend void swap(LoadBalancerAccumulatedStatsRequest& a, LoadBalancerAccumulatedStatsRequest& b) { + a.Swap(&b); + } + inline void Swap(LoadBalancerAccumulatedStatsRequest* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(LoadBalancerAccumulatedStatsRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + LoadBalancerAccumulatedStatsRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const LoadBalancerAccumulatedStatsRequest& from) { + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from); + } + using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const LoadBalancerAccumulatedStatsRequest& from) { + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from); + } + public: + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "connectrpc.conformance.LoadBalancerAccumulatedStatsRequest"; + } + protected: + explicit LoadBalancerAccumulatedStatsRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // @@protoc_insertion_point(class_scope:connectrpc.conformance.LoadBalancerAccumulatedStatsRequest) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + }; + friend struct ::TableStruct_connectrpc_2fconformance_2fmessages_2eproto; +};// ------------------------------------------------------------------- + +class LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse final : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry { +public: + typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry SuperType; + LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse(); + template + explicit PROTOBUF_CONSTEXPR LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + explicit LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void MergeFrom(const LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse& other); + static const LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse* internal_default_instance() { return reinterpret_cast(&_LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse_default_instance_); } + static bool ValidateKey(std::string* s) { + return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.NumRpcsStartedByMethodEntry.key"); + } + static bool ValidateValue(void*) { return true; } + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + friend struct ::TableStruct_connectrpc_2fconformance_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse final : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry { +public: + typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry SuperType; + LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse(); + template + explicit PROTOBUF_CONSTEXPR LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + explicit LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void MergeFrom(const LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse& other); + static const LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse* internal_default_instance() { return reinterpret_cast(&_LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse_default_instance_); } + static bool ValidateKey(std::string* s) { + return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.NumRpcsSucceededByMethodEntry.key"); + } + static bool ValidateValue(void*) { return true; } + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + friend struct ::TableStruct_connectrpc_2fconformance_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse final : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry { +public: + typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry SuperType; + LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse(); + template + explicit PROTOBUF_CONSTEXPR LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + explicit LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void MergeFrom(const LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse& other); + static const LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse* internal_default_instance() { return reinterpret_cast(&_LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse_default_instance_); } + static bool ValidateKey(std::string* s) { + return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.NumRpcsFailedByMethodEntry.key"); + } + static bool ValidateValue(void*) { return true; } + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + friend struct ::TableStruct_connectrpc_2fconformance_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse final : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry { +public: + typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry SuperType; + LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse(); + template + explicit PROTOBUF_CONSTEXPR LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + explicit LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void MergeFrom(const LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse& other); + static const LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse* internal_default_instance() { return reinterpret_cast(&_LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse_default_instance_); } + static bool ValidateKey(void*) { return true; } + static bool ValidateValue(void*) { return true; } + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + friend struct ::TableStruct_connectrpc_2fconformance_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class LoadBalancerAccumulatedStatsResponse_MethodStats final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.MethodStats) */ { + public: + inline LoadBalancerAccumulatedStatsResponse_MethodStats() : LoadBalancerAccumulatedStatsResponse_MethodStats(nullptr) {} + ~LoadBalancerAccumulatedStatsResponse_MethodStats() override; + template + explicit PROTOBUF_CONSTEXPR LoadBalancerAccumulatedStatsResponse_MethodStats(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + LoadBalancerAccumulatedStatsResponse_MethodStats(const LoadBalancerAccumulatedStatsResponse_MethodStats& from); + LoadBalancerAccumulatedStatsResponse_MethodStats(LoadBalancerAccumulatedStatsResponse_MethodStats&& from) noexcept + : LoadBalancerAccumulatedStatsResponse_MethodStats() { + *this = ::std::move(from); + } + + inline LoadBalancerAccumulatedStatsResponse_MethodStats& operator=(const LoadBalancerAccumulatedStatsResponse_MethodStats& from) { + CopyFrom(from); + return *this; + } + inline LoadBalancerAccumulatedStatsResponse_MethodStats& operator=(LoadBalancerAccumulatedStatsResponse_MethodStats&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const LoadBalancerAccumulatedStatsResponse_MethodStats& default_instance() { + return *internal_default_instance(); + } + static inline const LoadBalancerAccumulatedStatsResponse_MethodStats* internal_default_instance() { + return reinterpret_cast( + &_LoadBalancerAccumulatedStatsResponse_MethodStats_default_instance_); + } + static constexpr int kIndexInFileMessages = + 22; + + friend void swap(LoadBalancerAccumulatedStatsResponse_MethodStats& a, LoadBalancerAccumulatedStatsResponse_MethodStats& b) { + a.Swap(&b); + } + inline void Swap(LoadBalancerAccumulatedStatsResponse_MethodStats* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(LoadBalancerAccumulatedStatsResponse_MethodStats* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + LoadBalancerAccumulatedStatsResponse_MethodStats* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const LoadBalancerAccumulatedStatsResponse_MethodStats& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const LoadBalancerAccumulatedStatsResponse_MethodStats& from) { + LoadBalancerAccumulatedStatsResponse_MethodStats::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + 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; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(LoadBalancerAccumulatedStatsResponse_MethodStats* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.MethodStats"; + } + protected: + explicit LoadBalancerAccumulatedStatsResponse_MethodStats(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + + // accessors ------------------------------------------------------- + + enum : int { + kResultFieldNumber = 2, + kRpcsStartedFieldNumber = 1, + }; + // map result = 2 [json_name = "result"]; + int result_size() const; + private: + int _internal_result_size() const; + + public: + void clear_result() ; + private: + const ::PROTOBUF_NAMESPACE_ID::Map< ::int32_t, ::int32_t >& + _internal_result() const; + ::PROTOBUF_NAMESPACE_ID::Map< ::int32_t, ::int32_t >* + _internal_mutable_result(); + public: + const ::PROTOBUF_NAMESPACE_ID::Map< ::int32_t, ::int32_t >& + result() const; + ::PROTOBUF_NAMESPACE_ID::Map< ::int32_t, ::int32_t >* + mutable_result(); + // int32 rpcs_started = 1 [json_name = "rpcsStarted"]; + void clear_rpcs_started() ; + ::int32_t rpcs_started() const; + void set_rpcs_started(::int32_t value); + + private: + ::int32_t _internal_rpcs_started() const; + void _internal_set_rpcs_started(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.MethodStats) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::MapField< + LoadBalancerAccumulatedStatsResponse_MethodStats_ResultEntry_DoNotUse, + ::int32_t, ::int32_t, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32> result_; + ::int32_t rpcs_started_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_connectrpc_2fconformance_2fmessages_2eproto; +};// ------------------------------------------------------------------- + +class LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse final : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry { +public: + typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry SuperType; + LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse(); + template + explicit PROTOBUF_CONSTEXPR LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + explicit LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void MergeFrom(const LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse& other); + static const LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse* internal_default_instance() { return reinterpret_cast(&_LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse_default_instance_); } + static bool ValidateKey(std::string* s) { + return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.StatsPerMethodEntry.key"); + } + static bool ValidateValue(void*) { return true; } + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + friend struct ::TableStruct_connectrpc_2fconformance_2fmessages_2eproto; +}; +// ------------------------------------------------------------------- + +class LoadBalancerAccumulatedStatsResponse final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse) */ { + public: + inline LoadBalancerAccumulatedStatsResponse() : LoadBalancerAccumulatedStatsResponse(nullptr) {} + ~LoadBalancerAccumulatedStatsResponse() override; + template + explicit PROTOBUF_CONSTEXPR LoadBalancerAccumulatedStatsResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + LoadBalancerAccumulatedStatsResponse(const LoadBalancerAccumulatedStatsResponse& from); + LoadBalancerAccumulatedStatsResponse(LoadBalancerAccumulatedStatsResponse&& from) noexcept + : LoadBalancerAccumulatedStatsResponse() { + *this = ::std::move(from); + } + + inline LoadBalancerAccumulatedStatsResponse& operator=(const LoadBalancerAccumulatedStatsResponse& from) { + CopyFrom(from); + return *this; + } + inline LoadBalancerAccumulatedStatsResponse& operator=(LoadBalancerAccumulatedStatsResponse&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const LoadBalancerAccumulatedStatsResponse& default_instance() { + return *internal_default_instance(); + } + static inline const LoadBalancerAccumulatedStatsResponse* internal_default_instance() { + return reinterpret_cast( + &_LoadBalancerAccumulatedStatsResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = + 24; + + friend void swap(LoadBalancerAccumulatedStatsResponse& a, LoadBalancerAccumulatedStatsResponse& b) { + a.Swap(&b); + } + inline void Swap(LoadBalancerAccumulatedStatsResponse* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(LoadBalancerAccumulatedStatsResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + LoadBalancerAccumulatedStatsResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const LoadBalancerAccumulatedStatsResponse& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const LoadBalancerAccumulatedStatsResponse& from) { + LoadBalancerAccumulatedStatsResponse::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + 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; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(LoadBalancerAccumulatedStatsResponse* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "connectrpc.conformance.LoadBalancerAccumulatedStatsResponse"; + } + protected: + explicit LoadBalancerAccumulatedStatsResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef LoadBalancerAccumulatedStatsResponse_MethodStats MethodStats; + + // accessors ------------------------------------------------------- + + enum : int { + kNumRpcsStartedByMethodFieldNumber = 1, + kNumRpcsSucceededByMethodFieldNumber = 2, + kNumRpcsFailedByMethodFieldNumber = 3, + kStatsPerMethodFieldNumber = 4, + }; + // map num_rpcs_started_by_method = 1 [json_name = "numRpcsStartedByMethod", deprecated = true]; + [[deprecated]] int num_rpcs_started_by_method_size() const; + private: + int _internal_num_rpcs_started_by_method_size() const; + + public: + [[deprecated]] void clear_num_rpcs_started_by_method() ; + private: + const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >& + _internal_num_rpcs_started_by_method() const; + ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >* + _internal_mutable_num_rpcs_started_by_method(); + public: + [[deprecated]] const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >& + num_rpcs_started_by_method() const; + [[deprecated]] ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >* + mutable_num_rpcs_started_by_method(); + // map num_rpcs_succeeded_by_method = 2 [json_name = "numRpcsSucceededByMethod", deprecated = true]; + [[deprecated]] int num_rpcs_succeeded_by_method_size() const; + private: + int _internal_num_rpcs_succeeded_by_method_size() const; + + public: + [[deprecated]] void clear_num_rpcs_succeeded_by_method() ; + private: + const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >& + _internal_num_rpcs_succeeded_by_method() const; + ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >* + _internal_mutable_num_rpcs_succeeded_by_method(); + public: + [[deprecated]] const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >& + num_rpcs_succeeded_by_method() const; + [[deprecated]] ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >* + mutable_num_rpcs_succeeded_by_method(); + // map num_rpcs_failed_by_method = 3 [json_name = "numRpcsFailedByMethod", deprecated = true]; + [[deprecated]] int num_rpcs_failed_by_method_size() const; + private: + int _internal_num_rpcs_failed_by_method_size() const; + + public: + [[deprecated]] void clear_num_rpcs_failed_by_method() ; + private: + const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >& + _internal_num_rpcs_failed_by_method() const; + ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >* + _internal_mutable_num_rpcs_failed_by_method(); + public: + [[deprecated]] const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >& + num_rpcs_failed_by_method() const; + [[deprecated]] ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >* + mutable_num_rpcs_failed_by_method(); + // map stats_per_method = 4 [json_name = "statsPerMethod"]; + int stats_per_method_size() const; + private: + int _internal_stats_per_method_size() const; + + public: + void clear_stats_per_method() ; + private: + const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_MethodStats >& + _internal_stats_per_method() const; + ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_MethodStats >* + _internal_mutable_stats_per_method(); + public: + const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_MethodStats >& + stats_per_method() const; + ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_MethodStats >* + mutable_stats_per_method(); + // @@protoc_insertion_point(class_scope:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::MapField< + LoadBalancerAccumulatedStatsResponse_NumRpcsStartedByMethodEntry_DoNotUse, + std::string, ::int32_t, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32> num_rpcs_started_by_method_; + ::PROTOBUF_NAMESPACE_ID::internal::MapField< + LoadBalancerAccumulatedStatsResponse_NumRpcsSucceededByMethodEntry_DoNotUse, + std::string, ::int32_t, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32> num_rpcs_succeeded_by_method_; + ::PROTOBUF_NAMESPACE_ID::internal::MapField< + LoadBalancerAccumulatedStatsResponse_NumRpcsFailedByMethodEntry_DoNotUse, + std::string, ::int32_t, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32> num_rpcs_failed_by_method_; + ::PROTOBUF_NAMESPACE_ID::internal::MapField< + LoadBalancerAccumulatedStatsResponse_StatsPerMethodEntry_DoNotUse, + std::string, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_MethodStats, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> stats_per_method_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_connectrpc_2fconformance_2fmessages_2eproto; +};// ------------------------------------------------------------------- + +class ClientConfigureRequest_Metadata final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:connectrpc.conformance.ClientConfigureRequest.Metadata) */ { + public: + inline ClientConfigureRequest_Metadata() : ClientConfigureRequest_Metadata(nullptr) {} + ~ClientConfigureRequest_Metadata() override; + template + explicit PROTOBUF_CONSTEXPR ClientConfigureRequest_Metadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ClientConfigureRequest_Metadata(const ClientConfigureRequest_Metadata& from); + ClientConfigureRequest_Metadata(ClientConfigureRequest_Metadata&& from) noexcept + : ClientConfigureRequest_Metadata() { + *this = ::std::move(from); + } + + inline ClientConfigureRequest_Metadata& operator=(const ClientConfigureRequest_Metadata& from) { + CopyFrom(from); + return *this; + } + inline ClientConfigureRequest_Metadata& operator=(ClientConfigureRequest_Metadata&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ClientConfigureRequest_Metadata& default_instance() { + return *internal_default_instance(); + } + static inline const ClientConfigureRequest_Metadata* internal_default_instance() { + return reinterpret_cast( + &_ClientConfigureRequest_Metadata_default_instance_); + } + static constexpr int kIndexInFileMessages = + 25; + + friend void swap(ClientConfigureRequest_Metadata& a, ClientConfigureRequest_Metadata& b) { + a.Swap(&b); + } + inline void Swap(ClientConfigureRequest_Metadata* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ClientConfigureRequest_Metadata* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ClientConfigureRequest_Metadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ClientConfigureRequest_Metadata& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const ClientConfigureRequest_Metadata& from) { + ClientConfigureRequest_Metadata::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + 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; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ClientConfigureRequest_Metadata* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "connectrpc.conformance.ClientConfigureRequest.Metadata"; + } + protected: + explicit ClientConfigureRequest_Metadata(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kKeyFieldNumber = 2, + kValueFieldNumber = 3, + kTypeFieldNumber = 1, + }; + // string key = 2 [json_name = "key"]; + void clear_key() ; + const std::string& key() const; + + + + + template + void set_key(Arg_&& arg, Args_... args); + std::string* mutable_key(); + PROTOBUF_NODISCARD std::string* release_key(); + void set_allocated_key(std::string* ptr); + + private: + const std::string& _internal_key() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_key( + const std::string& value); + std::string* _internal_mutable_key(); + + public: + // string value = 3 [json_name = "value"]; + void clear_value() ; + const std::string& value() const; + + + + + template + void set_value(Arg_&& arg, Args_... args); + std::string* mutable_value(); + PROTOBUF_NODISCARD std::string* release_value(); + void set_allocated_value(std::string* ptr); + + private: + const std::string& _internal_value() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_value( + const std::string& value); + std::string* _internal_mutable_value(); + + public: + // .connectrpc.conformance.ClientConfigureRequest.RpcType type = 1 [json_name = "type"]; + void clear_type() ; + ::connectrpc::conformance::ClientConfigureRequest_RpcType type() const; + void set_type(::connectrpc::conformance::ClientConfigureRequest_RpcType value); + + private: + ::connectrpc::conformance::ClientConfigureRequest_RpcType _internal_type() const; + void _internal_set_type(::connectrpc::conformance::ClientConfigureRequest_RpcType value); + + public: + // @@protoc_insertion_point(class_scope:connectrpc.conformance.ClientConfigureRequest.Metadata) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_; + int type_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_connectrpc_2fconformance_2fmessages_2eproto; +};// ------------------------------------------------------------------- + +class ClientConfigureRequest final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:connectrpc.conformance.ClientConfigureRequest) */ { + public: + inline ClientConfigureRequest() : ClientConfigureRequest(nullptr) {} + ~ClientConfigureRequest() override; + template + explicit PROTOBUF_CONSTEXPR ClientConfigureRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ClientConfigureRequest(const ClientConfigureRequest& from); + ClientConfigureRequest(ClientConfigureRequest&& from) noexcept + : ClientConfigureRequest() { + *this = ::std::move(from); + } + + inline ClientConfigureRequest& operator=(const ClientConfigureRequest& from) { + CopyFrom(from); + return *this; + } + inline ClientConfigureRequest& operator=(ClientConfigureRequest&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ClientConfigureRequest& default_instance() { + return *internal_default_instance(); + } + static inline const ClientConfigureRequest* internal_default_instance() { + return reinterpret_cast( + &_ClientConfigureRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = + 26; + + friend void swap(ClientConfigureRequest& a, ClientConfigureRequest& b) { + a.Swap(&b); + } + inline void Swap(ClientConfigureRequest* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ClientConfigureRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ClientConfigureRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ClientConfigureRequest& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const ClientConfigureRequest& from) { + ClientConfigureRequest::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + 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; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ClientConfigureRequest* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "connectrpc.conformance.ClientConfigureRequest"; + } + protected: + explicit ClientConfigureRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef ClientConfigureRequest_Metadata Metadata; + + using RpcType = ClientConfigureRequest_RpcType; + static constexpr RpcType EMPTY_CALL = ClientConfigureRequest_RpcType_EMPTY_CALL; + static constexpr RpcType UNARY_CALL = ClientConfigureRequest_RpcType_UNARY_CALL; + static inline bool RpcType_IsValid(int value) { + return ClientConfigureRequest_RpcType_IsValid(value); + } + static constexpr RpcType RpcType_MIN = ClientConfigureRequest_RpcType_RpcType_MIN; + static constexpr RpcType RpcType_MAX = ClientConfigureRequest_RpcType_RpcType_MAX; + static constexpr int RpcType_ARRAYSIZE = ClientConfigureRequest_RpcType_RpcType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* RpcType_descriptor() { + return ClientConfigureRequest_RpcType_descriptor(); + } + template + static inline const std::string& RpcType_Name(T value) { + return ClientConfigureRequest_RpcType_Name(value); + } + static inline bool RpcType_Parse(absl::string_view name, RpcType* value) { + return ClientConfigureRequest_RpcType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kTypesFieldNumber = 1, + kMetadataFieldNumber = 2, + kTimeoutSecFieldNumber = 3, + }; + // repeated .connectrpc.conformance.ClientConfigureRequest.RpcType types = 1 [json_name = "types"]; + int types_size() const; + private: + int _internal_types_size() const; + + public: + void clear_types() ; + public: + ::connectrpc::conformance::ClientConfigureRequest_RpcType types(int index) const; + void set_types(int index, ::connectrpc::conformance::ClientConfigureRequest_RpcType value); + void add_types(::connectrpc::conformance::ClientConfigureRequest_RpcType value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField& types() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField* mutable_types(); + + private: + ::connectrpc::conformance::ClientConfigureRequest_RpcType _internal_types(int index) const; + void _internal_add_types(::connectrpc::conformance::ClientConfigureRequest_RpcType value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField& _internal_types() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField* _internal_mutable_types(); + + public: + // repeated .connectrpc.conformance.ClientConfigureRequest.Metadata metadata = 2 [json_name = "metadata"]; + int metadata_size() const; + private: + int _internal_metadata_size() const; + + public: + void clear_metadata() ; + ::connectrpc::conformance::ClientConfigureRequest_Metadata* mutable_metadata(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::connectrpc::conformance::ClientConfigureRequest_Metadata >* + mutable_metadata(); + private: + const ::connectrpc::conformance::ClientConfigureRequest_Metadata& _internal_metadata(int index) const; + ::connectrpc::conformance::ClientConfigureRequest_Metadata* _internal_add_metadata(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::connectrpc::conformance::ClientConfigureRequest_Metadata>& _internal_metadata() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::connectrpc::conformance::ClientConfigureRequest_Metadata>* _internal_mutable_metadata(); + public: + const ::connectrpc::conformance::ClientConfigureRequest_Metadata& metadata(int index) const; + ::connectrpc::conformance::ClientConfigureRequest_Metadata* add_metadata(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::connectrpc::conformance::ClientConfigureRequest_Metadata >& + metadata() const; + // int32 timeout_sec = 3 [json_name = "timeoutSec"]; + void clear_timeout_sec() ; + ::int32_t timeout_sec() const; + void set_timeout_sec(::int32_t value); + + private: + ::int32_t _internal_timeout_sec() const; + void _internal_set_timeout_sec(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:connectrpc.conformance.ClientConfigureRequest) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::RepeatedField types_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _types_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::connectrpc::conformance::ClientConfigureRequest_Metadata > metadata_; + ::int32_t timeout_sec_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_connectrpc_2fconformance_2fmessages_2eproto; +};// ------------------------------------------------------------------- + +class ClientConfigureResponse final : + public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:connectrpc.conformance.ClientConfigureResponse) */ { + public: + inline ClientConfigureResponse() : ClientConfigureResponse(nullptr) {} + template + explicit PROTOBUF_CONSTEXPR ClientConfigureResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ClientConfigureResponse(const ClientConfigureResponse& from); + ClientConfigureResponse(ClientConfigureResponse&& from) noexcept + : ClientConfigureResponse() { + *this = ::std::move(from); + } + + inline ClientConfigureResponse& operator=(const ClientConfigureResponse& from) { + CopyFrom(from); + return *this; + } + inline ClientConfigureResponse& operator=(ClientConfigureResponse&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ClientConfigureResponse& default_instance() { + return *internal_default_instance(); + } + static inline const ClientConfigureResponse* internal_default_instance() { + return reinterpret_cast( + &_ClientConfigureResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = + 27; + + friend void swap(ClientConfigureResponse& a, ClientConfigureResponse& b) { + a.Swap(&b); + } + inline void Swap(ClientConfigureResponse* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ClientConfigureResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ClientConfigureResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const ClientConfigureResponse& from) { + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from); + } + using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const ClientConfigureResponse& from) { + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from); + } + public: + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "connectrpc.conformance.ClientConfigureResponse"; + } + protected: + explicit ClientConfigureResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // @@protoc_insertion_point(class_scope:connectrpc.conformance.ClientConfigureResponse) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + }; + friend struct ::TableStruct_connectrpc_2fconformance_2fmessages_2eproto; +};// ------------------------------------------------------------------- + +class ErrorDetail final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:connectrpc.conformance.ErrorDetail) */ { + public: + inline ErrorDetail() : ErrorDetail(nullptr) {} + ~ErrorDetail() override; + template + explicit PROTOBUF_CONSTEXPR ErrorDetail(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ErrorDetail(const ErrorDetail& from); + ErrorDetail(ErrorDetail&& from) noexcept + : ErrorDetail() { + *this = ::std::move(from); + } + + inline ErrorDetail& operator=(const ErrorDetail& from) { + CopyFrom(from); + return *this; + } + inline ErrorDetail& operator=(ErrorDetail&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ErrorDetail& default_instance() { + return *internal_default_instance(); + } + static inline const ErrorDetail* internal_default_instance() { + return reinterpret_cast( + &_ErrorDetail_default_instance_); + } + static constexpr int kIndexInFileMessages = + 28; + + friend void swap(ErrorDetail& a, ErrorDetail& b) { + a.Swap(&b); + } + inline void Swap(ErrorDetail* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ErrorDetail* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ErrorDetail* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ErrorDetail& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const ErrorDetail& from) { + ErrorDetail::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + 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; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ErrorDetail* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "connectrpc.conformance.ErrorDetail"; + } + protected: + explicit ErrorDetail(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kReasonFieldNumber = 1, + kDomainFieldNumber = 2, + }; + // string reason = 1 [json_name = "reason"]; + void clear_reason() ; + const std::string& reason() const; + + + + + template + void set_reason(Arg_&& arg, Args_... args); + std::string* mutable_reason(); + PROTOBUF_NODISCARD std::string* release_reason(); + void set_allocated_reason(std::string* ptr); + + private: + const std::string& _internal_reason() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_reason( + const std::string& value); + std::string* _internal_mutable_reason(); + + public: + // string domain = 2 [json_name = "domain"]; + void clear_domain() ; + const std::string& domain() const; + + + + + template + void set_domain(Arg_&& arg, Args_... args); + std::string* mutable_domain(); + PROTOBUF_NODISCARD std::string* release_domain(); + void set_allocated_domain(std::string* ptr); + + private: + const std::string& _internal_domain() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_domain( + const std::string& value); + std::string* _internal_mutable_domain(); + + public: + // @@protoc_insertion_point(class_scope:connectrpc.conformance.ErrorDetail) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr reason_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr domain_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_connectrpc_2fconformance_2fmessages_2eproto; +};// ------------------------------------------------------------------- + +class ErrorStatus final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:connectrpc.conformance.ErrorStatus) */ { + public: + inline ErrorStatus() : ErrorStatus(nullptr) {} + ~ErrorStatus() override; + template + explicit PROTOBUF_CONSTEXPR ErrorStatus(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ErrorStatus(const ErrorStatus& from); + ErrorStatus(ErrorStatus&& from) noexcept + : ErrorStatus() { + *this = ::std::move(from); + } + + inline ErrorStatus& operator=(const ErrorStatus& from) { + CopyFrom(from); + return *this; + } + inline ErrorStatus& operator=(ErrorStatus&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ErrorStatus& default_instance() { + return *internal_default_instance(); + } + static inline const ErrorStatus* internal_default_instance() { + return reinterpret_cast( + &_ErrorStatus_default_instance_); + } + static constexpr int kIndexInFileMessages = + 29; + + friend void swap(ErrorStatus& a, ErrorStatus& b) { + a.Swap(&b); + } + inline void Swap(ErrorStatus* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ErrorStatus* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ErrorStatus* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ErrorStatus& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const ErrorStatus& from) { + ErrorStatus::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + 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; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ErrorStatus* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "connectrpc.conformance.ErrorStatus"; + } + protected: + explicit ErrorStatus(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDetailsFieldNumber = 3, + kMessageFieldNumber = 2, + kCodeFieldNumber = 1, + }; + // repeated .google.protobuf.Any details = 3 [json_name = "details"]; + int details_size() const; + private: + int _internal_details_size() const; + + public: + void clear_details() ; + ::PROTOBUF_NAMESPACE_ID::Any* mutable_details(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Any >* + mutable_details(); + private: + const ::PROTOBUF_NAMESPACE_ID::Any& _internal_details(int index) const; + ::PROTOBUF_NAMESPACE_ID::Any* _internal_add_details(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Any>& _internal_details() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Any>* _internal_mutable_details(); + public: + const ::PROTOBUF_NAMESPACE_ID::Any& details(int index) const; + ::PROTOBUF_NAMESPACE_ID::Any* add_details(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Any >& + details() const; + // string message = 2 [json_name = "message"]; + void clear_message() ; + const std::string& message() const; + + + + + template + void set_message(Arg_&& arg, Args_... args); + std::string* mutable_message(); + PROTOBUF_NODISCARD std::string* release_message(); + void set_allocated_message(std::string* ptr); + + private: + const std::string& _internal_message() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_message( + const std::string& value); + std::string* _internal_mutable_message(); + + public: + // int32 code = 1 [json_name = "code"]; + void clear_code() ; + ::int32_t code() const; + void set_code(::int32_t value); + + private: + ::int32_t _internal_code() const; + void _internal_set_code(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:connectrpc.conformance.ErrorStatus) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Any > details_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_; + ::int32_t code_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_connectrpc_2fconformance_2fmessages_2eproto; +}; + +// =================================================================== + + + + +// =================================================================== + + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// Payload + +// .connectrpc.conformance.PayloadType type = 1 [json_name = "type"]; +inline void Payload::clear_type() { + _impl_.type_ = 0; +} +inline ::connectrpc::conformance::PayloadType Payload::type() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.Payload.type) + return _internal_type(); +} +inline void Payload::set_type(::connectrpc::conformance::PayloadType value) { + _internal_set_type(value); + // @@protoc_insertion_point(field_set:connectrpc.conformance.Payload.type) +} +inline ::connectrpc::conformance::PayloadType Payload::_internal_type() const { + return static_cast<::connectrpc::conformance::PayloadType>(_impl_.type_); +} +inline void Payload::_internal_set_type(::connectrpc::conformance::PayloadType value) { + ; + _impl_.type_ = value; +} + +// bytes body = 2 [json_name = "body"]; +inline void Payload::clear_body() { + _impl_.body_.ClearToEmpty(); +} +inline const std::string& Payload::body() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.Payload.body) + return _internal_body(); +} +template +inline PROTOBUF_ALWAYS_INLINE void Payload::set_body(Arg_&& arg, + Args_... args) { + ; + _impl_.body_.SetBytes(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:connectrpc.conformance.Payload.body) +} +inline std::string* Payload::mutable_body() { + std::string* _s = _internal_mutable_body(); + // @@protoc_insertion_point(field_mutable:connectrpc.conformance.Payload.body) + return _s; +} +inline const std::string& Payload::_internal_body() const { + return _impl_.body_.Get(); +} +inline void Payload::_internal_set_body(const std::string& value) { + ; + + + _impl_.body_.Set(value, GetArenaForAllocation()); +} +inline std::string* Payload::_internal_mutable_body() { + ; + return _impl_.body_.Mutable( GetArenaForAllocation()); +} +inline std::string* Payload::release_body() { + // @@protoc_insertion_point(field_release:connectrpc.conformance.Payload.body) + return _impl_.body_.Release(); +} +inline void Payload::set_allocated_body(std::string* value) { + _impl_.body_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.body_.IsDefault()) { + _impl_.body_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:connectrpc.conformance.Payload.body) +} + +// ------------------------------------------------------------------- + +// EchoStatus + +// int32 code = 1 [json_name = "code"]; +inline void EchoStatus::clear_code() { + _impl_.code_ = 0; +} +inline ::int32_t EchoStatus::code() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.EchoStatus.code) + return _internal_code(); +} +inline void EchoStatus::set_code(::int32_t value) { + _internal_set_code(value); + // @@protoc_insertion_point(field_set:connectrpc.conformance.EchoStatus.code) +} +inline ::int32_t EchoStatus::_internal_code() const { + return _impl_.code_; +} +inline void EchoStatus::_internal_set_code(::int32_t value) { + ; + _impl_.code_ = value; +} + +// string message = 2 [json_name = "message"]; +inline void EchoStatus::clear_message() { + _impl_.message_.ClearToEmpty(); +} +inline const std::string& EchoStatus::message() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.EchoStatus.message) + return _internal_message(); +} +template +inline PROTOBUF_ALWAYS_INLINE void EchoStatus::set_message(Arg_&& arg, + Args_... args) { + ; + _impl_.message_.Set(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:connectrpc.conformance.EchoStatus.message) +} +inline std::string* EchoStatus::mutable_message() { + std::string* _s = _internal_mutable_message(); + // @@protoc_insertion_point(field_mutable:connectrpc.conformance.EchoStatus.message) + return _s; +} +inline const std::string& EchoStatus::_internal_message() const { + return _impl_.message_.Get(); +} +inline void EchoStatus::_internal_set_message(const std::string& value) { + ; + + + _impl_.message_.Set(value, GetArenaForAllocation()); +} +inline std::string* EchoStatus::_internal_mutable_message() { + ; + return _impl_.message_.Mutable( GetArenaForAllocation()); +} +inline std::string* EchoStatus::release_message() { + // @@protoc_insertion_point(field_release:connectrpc.conformance.EchoStatus.message) + return _impl_.message_.Release(); +} +inline void EchoStatus::set_allocated_message(std::string* value) { + _impl_.message_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.message_.IsDefault()) { + _impl_.message_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:connectrpc.conformance.EchoStatus.message) +} + +// ------------------------------------------------------------------- + +// SimpleRequest + +// .connectrpc.conformance.PayloadType response_type = 1 [json_name = "responseType"]; +inline void SimpleRequest::clear_response_type() { + _impl_.response_type_ = 0; +} +inline ::connectrpc::conformance::PayloadType SimpleRequest::response_type() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.SimpleRequest.response_type) + return _internal_response_type(); +} +inline void SimpleRequest::set_response_type(::connectrpc::conformance::PayloadType value) { + _internal_set_response_type(value); + // @@protoc_insertion_point(field_set:connectrpc.conformance.SimpleRequest.response_type) +} +inline ::connectrpc::conformance::PayloadType SimpleRequest::_internal_response_type() const { + return static_cast<::connectrpc::conformance::PayloadType>(_impl_.response_type_); +} +inline void SimpleRequest::_internal_set_response_type(::connectrpc::conformance::PayloadType value) { + ; + _impl_.response_type_ = value; +} + +// int32 response_size = 2 [json_name = "responseSize"]; +inline void SimpleRequest::clear_response_size() { + _impl_.response_size_ = 0; +} +inline ::int32_t SimpleRequest::response_size() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.SimpleRequest.response_size) + return _internal_response_size(); +} +inline void SimpleRequest::set_response_size(::int32_t value) { + _internal_set_response_size(value); + // @@protoc_insertion_point(field_set:connectrpc.conformance.SimpleRequest.response_size) +} +inline ::int32_t SimpleRequest::_internal_response_size() const { + return _impl_.response_size_; +} +inline void SimpleRequest::_internal_set_response_size(::int32_t value) { + ; + _impl_.response_size_ = value; +} + +// .connectrpc.conformance.Payload payload = 3 [json_name = "payload"]; +inline bool SimpleRequest::has_payload() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.payload_ != nullptr); + return value; +} +inline void SimpleRequest::clear_payload() { + if (_impl_.payload_ != nullptr) _impl_.payload_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::connectrpc::conformance::Payload& SimpleRequest::_internal_payload() const { + const ::connectrpc::conformance::Payload* p = _impl_.payload_; + return p != nullptr ? *p : reinterpret_cast( + ::connectrpc::conformance::_Payload_default_instance_); +} +inline const ::connectrpc::conformance::Payload& SimpleRequest::payload() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.SimpleRequest.payload) + return _internal_payload(); +} +inline void SimpleRequest::unsafe_arena_set_allocated_payload( + ::connectrpc::conformance::Payload* payload) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.payload_); + } + _impl_.payload_ = payload; + if (payload) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:connectrpc.conformance.SimpleRequest.payload) +} +inline ::connectrpc::conformance::Payload* SimpleRequest::release_payload() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::connectrpc::conformance::Payload* temp = _impl_.payload_; + _impl_.payload_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::connectrpc::conformance::Payload* SimpleRequest::unsafe_arena_release_payload() { + // @@protoc_insertion_point(field_release:connectrpc.conformance.SimpleRequest.payload) + _impl_._has_bits_[0] &= ~0x00000001u; + ::connectrpc::conformance::Payload* temp = _impl_.payload_; + _impl_.payload_ = nullptr; + return temp; +} +inline ::connectrpc::conformance::Payload* SimpleRequest::_internal_mutable_payload() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.payload_ == nullptr) { + auto* p = CreateMaybeMessage<::connectrpc::conformance::Payload>(GetArenaForAllocation()); + _impl_.payload_ = p; + } + return _impl_.payload_; +} +inline ::connectrpc::conformance::Payload* SimpleRequest::mutable_payload() { + ::connectrpc::conformance::Payload* _msg = _internal_mutable_payload(); + // @@protoc_insertion_point(field_mutable:connectrpc.conformance.SimpleRequest.payload) + return _msg; +} +inline void SimpleRequest::set_allocated_payload(::connectrpc::conformance::Payload* payload) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.payload_; + } + if (payload) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(payload); + if (message_arena != submessage_arena) { + payload = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, payload, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.payload_ = payload; + // @@protoc_insertion_point(field_set_allocated:connectrpc.conformance.SimpleRequest.payload) +} + +// bool fill_username = 4 [json_name = "fillUsername"]; +inline void SimpleRequest::clear_fill_username() { + _impl_.fill_username_ = false; +} +inline bool SimpleRequest::fill_username() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.SimpleRequest.fill_username) + return _internal_fill_username(); +} +inline void SimpleRequest::set_fill_username(bool value) { + _internal_set_fill_username(value); + // @@protoc_insertion_point(field_set:connectrpc.conformance.SimpleRequest.fill_username) +} +inline bool SimpleRequest::_internal_fill_username() const { + return _impl_.fill_username_; +} +inline void SimpleRequest::_internal_set_fill_username(bool value) { + ; + _impl_.fill_username_ = value; +} + +// bool fill_oauth_scope = 5 [json_name = "fillOauthScope"]; +inline void SimpleRequest::clear_fill_oauth_scope() { + _impl_.fill_oauth_scope_ = false; +} +inline bool SimpleRequest::fill_oauth_scope() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.SimpleRequest.fill_oauth_scope) + return _internal_fill_oauth_scope(); +} +inline void SimpleRequest::set_fill_oauth_scope(bool value) { + _internal_set_fill_oauth_scope(value); + // @@protoc_insertion_point(field_set:connectrpc.conformance.SimpleRequest.fill_oauth_scope) +} +inline bool SimpleRequest::_internal_fill_oauth_scope() const { + return _impl_.fill_oauth_scope_; +} +inline void SimpleRequest::_internal_set_fill_oauth_scope(bool value) { + ; + _impl_.fill_oauth_scope_ = value; +} + +// .google.protobuf.BoolValue response_compressed = 6 [json_name = "responseCompressed"]; +inline bool SimpleRequest::has_response_compressed() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.response_compressed_ != nullptr); + return value; +} +inline const ::PROTOBUF_NAMESPACE_ID::BoolValue& SimpleRequest::_internal_response_compressed() const { + const ::PROTOBUF_NAMESPACE_ID::BoolValue* p = _impl_.response_compressed_; + return p != nullptr ? *p : reinterpret_cast( + ::PROTOBUF_NAMESPACE_ID::_BoolValue_default_instance_); +} +inline const ::PROTOBUF_NAMESPACE_ID::BoolValue& SimpleRequest::response_compressed() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.SimpleRequest.response_compressed) + return _internal_response_compressed(); +} +inline void SimpleRequest::unsafe_arena_set_allocated_response_compressed( + ::PROTOBUF_NAMESPACE_ID::BoolValue* response_compressed) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.response_compressed_); + } + _impl_.response_compressed_ = response_compressed; + if (response_compressed) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:connectrpc.conformance.SimpleRequest.response_compressed) +} +inline ::PROTOBUF_NAMESPACE_ID::BoolValue* SimpleRequest::release_response_compressed() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::PROTOBUF_NAMESPACE_ID::BoolValue* temp = _impl_.response_compressed_; + _impl_.response_compressed_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::PROTOBUF_NAMESPACE_ID::BoolValue* SimpleRequest::unsafe_arena_release_response_compressed() { + // @@protoc_insertion_point(field_release:connectrpc.conformance.SimpleRequest.response_compressed) + _impl_._has_bits_[0] &= ~0x00000002u; + ::PROTOBUF_NAMESPACE_ID::BoolValue* temp = _impl_.response_compressed_; + _impl_.response_compressed_ = nullptr; + return temp; +} +inline ::PROTOBUF_NAMESPACE_ID::BoolValue* SimpleRequest::_internal_mutable_response_compressed() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.response_compressed_ == nullptr) { + auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::BoolValue>(GetArenaForAllocation()); + _impl_.response_compressed_ = p; + } + return _impl_.response_compressed_; +} +inline ::PROTOBUF_NAMESPACE_ID::BoolValue* SimpleRequest::mutable_response_compressed() { + ::PROTOBUF_NAMESPACE_ID::BoolValue* _msg = _internal_mutable_response_compressed(); + // @@protoc_insertion_point(field_mutable:connectrpc.conformance.SimpleRequest.response_compressed) + return _msg; +} +inline void SimpleRequest::set_allocated_response_compressed(::PROTOBUF_NAMESPACE_ID::BoolValue* response_compressed) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.response_compressed_); + } + if (response_compressed) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(response_compressed)); + if (message_arena != submessage_arena) { + response_compressed = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, response_compressed, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.response_compressed_ = response_compressed; + // @@protoc_insertion_point(field_set_allocated:connectrpc.conformance.SimpleRequest.response_compressed) +} + +// .connectrpc.conformance.EchoStatus response_status = 7 [json_name = "responseStatus"]; +inline bool SimpleRequest::has_response_status() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.response_status_ != nullptr); + return value; +} +inline void SimpleRequest::clear_response_status() { + if (_impl_.response_status_ != nullptr) _impl_.response_status_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::connectrpc::conformance::EchoStatus& SimpleRequest::_internal_response_status() const { + const ::connectrpc::conformance::EchoStatus* p = _impl_.response_status_; + return p != nullptr ? *p : reinterpret_cast( + ::connectrpc::conformance::_EchoStatus_default_instance_); +} +inline const ::connectrpc::conformance::EchoStatus& SimpleRequest::response_status() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.SimpleRequest.response_status) + return _internal_response_status(); +} +inline void SimpleRequest::unsafe_arena_set_allocated_response_status( + ::connectrpc::conformance::EchoStatus* response_status) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.response_status_); + } + _impl_.response_status_ = response_status; + if (response_status) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:connectrpc.conformance.SimpleRequest.response_status) +} +inline ::connectrpc::conformance::EchoStatus* SimpleRequest::release_response_status() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::connectrpc::conformance::EchoStatus* temp = _impl_.response_status_; + _impl_.response_status_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::connectrpc::conformance::EchoStatus* SimpleRequest::unsafe_arena_release_response_status() { + // @@protoc_insertion_point(field_release:connectrpc.conformance.SimpleRequest.response_status) + _impl_._has_bits_[0] &= ~0x00000004u; + ::connectrpc::conformance::EchoStatus* temp = _impl_.response_status_; + _impl_.response_status_ = nullptr; + return temp; +} +inline ::connectrpc::conformance::EchoStatus* SimpleRequest::_internal_mutable_response_status() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.response_status_ == nullptr) { + auto* p = CreateMaybeMessage<::connectrpc::conformance::EchoStatus>(GetArenaForAllocation()); + _impl_.response_status_ = p; + } + return _impl_.response_status_; +} +inline ::connectrpc::conformance::EchoStatus* SimpleRequest::mutable_response_status() { + ::connectrpc::conformance::EchoStatus* _msg = _internal_mutable_response_status(); + // @@protoc_insertion_point(field_mutable:connectrpc.conformance.SimpleRequest.response_status) + return _msg; +} +inline void SimpleRequest::set_allocated_response_status(::connectrpc::conformance::EchoStatus* response_status) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.response_status_; + } + if (response_status) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(response_status); + if (message_arena != submessage_arena) { + response_status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, response_status, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.response_status_ = response_status; + // @@protoc_insertion_point(field_set_allocated:connectrpc.conformance.SimpleRequest.response_status) +} + +// .google.protobuf.BoolValue expect_compressed = 8 [json_name = "expectCompressed"]; +inline bool SimpleRequest::has_expect_compressed() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || _impl_.expect_compressed_ != nullptr); + return value; +} +inline const ::PROTOBUF_NAMESPACE_ID::BoolValue& SimpleRequest::_internal_expect_compressed() const { + const ::PROTOBUF_NAMESPACE_ID::BoolValue* p = _impl_.expect_compressed_; + return p != nullptr ? *p : reinterpret_cast( + ::PROTOBUF_NAMESPACE_ID::_BoolValue_default_instance_); +} +inline const ::PROTOBUF_NAMESPACE_ID::BoolValue& SimpleRequest::expect_compressed() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.SimpleRequest.expect_compressed) + return _internal_expect_compressed(); +} +inline void SimpleRequest::unsafe_arena_set_allocated_expect_compressed( + ::PROTOBUF_NAMESPACE_ID::BoolValue* expect_compressed) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.expect_compressed_); + } + _impl_.expect_compressed_ = expect_compressed; + if (expect_compressed) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:connectrpc.conformance.SimpleRequest.expect_compressed) +} +inline ::PROTOBUF_NAMESPACE_ID::BoolValue* SimpleRequest::release_expect_compressed() { + _impl_._has_bits_[0] &= ~0x00000008u; + ::PROTOBUF_NAMESPACE_ID::BoolValue* temp = _impl_.expect_compressed_; + _impl_.expect_compressed_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::PROTOBUF_NAMESPACE_ID::BoolValue* SimpleRequest::unsafe_arena_release_expect_compressed() { + // @@protoc_insertion_point(field_release:connectrpc.conformance.SimpleRequest.expect_compressed) + _impl_._has_bits_[0] &= ~0x00000008u; + ::PROTOBUF_NAMESPACE_ID::BoolValue* temp = _impl_.expect_compressed_; + _impl_.expect_compressed_ = nullptr; + return temp; +} +inline ::PROTOBUF_NAMESPACE_ID::BoolValue* SimpleRequest::_internal_mutable_expect_compressed() { + _impl_._has_bits_[0] |= 0x00000008u; + if (_impl_.expect_compressed_ == nullptr) { + auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::BoolValue>(GetArenaForAllocation()); + _impl_.expect_compressed_ = p; + } + return _impl_.expect_compressed_; +} +inline ::PROTOBUF_NAMESPACE_ID::BoolValue* SimpleRequest::mutable_expect_compressed() { + ::PROTOBUF_NAMESPACE_ID::BoolValue* _msg = _internal_mutable_expect_compressed(); + // @@protoc_insertion_point(field_mutable:connectrpc.conformance.SimpleRequest.expect_compressed) + return _msg; +} +inline void SimpleRequest::set_allocated_expect_compressed(::PROTOBUF_NAMESPACE_ID::BoolValue* expect_compressed) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.expect_compressed_); + } + if (expect_compressed) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expect_compressed)); + if (message_arena != submessage_arena) { + expect_compressed = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, expect_compressed, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.expect_compressed_ = expect_compressed; + // @@protoc_insertion_point(field_set_allocated:connectrpc.conformance.SimpleRequest.expect_compressed) +} + +// bool fill_server_id = 9 [json_name = "fillServerId"]; +inline void SimpleRequest::clear_fill_server_id() { + _impl_.fill_server_id_ = false; +} +inline bool SimpleRequest::fill_server_id() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.SimpleRequest.fill_server_id) + return _internal_fill_server_id(); +} +inline void SimpleRequest::set_fill_server_id(bool value) { + _internal_set_fill_server_id(value); + // @@protoc_insertion_point(field_set:connectrpc.conformance.SimpleRequest.fill_server_id) +} +inline bool SimpleRequest::_internal_fill_server_id() const { + return _impl_.fill_server_id_; +} +inline void SimpleRequest::_internal_set_fill_server_id(bool value) { + ; + _impl_.fill_server_id_ = value; +} + +// bool fill_grpclb_route_type = 10 [json_name = "fillGrpclbRouteType"]; +inline void SimpleRequest::clear_fill_grpclb_route_type() { + _impl_.fill_grpclb_route_type_ = false; +} +inline bool SimpleRequest::fill_grpclb_route_type() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.SimpleRequest.fill_grpclb_route_type) + return _internal_fill_grpclb_route_type(); +} +inline void SimpleRequest::set_fill_grpclb_route_type(bool value) { + _internal_set_fill_grpclb_route_type(value); + // @@protoc_insertion_point(field_set:connectrpc.conformance.SimpleRequest.fill_grpclb_route_type) +} +inline bool SimpleRequest::_internal_fill_grpclb_route_type() const { + return _impl_.fill_grpclb_route_type_; +} +inline void SimpleRequest::_internal_set_fill_grpclb_route_type(bool value) { + ; + _impl_.fill_grpclb_route_type_ = value; +} + +// ------------------------------------------------------------------- + +// SimpleResponse + +// .connectrpc.conformance.Payload payload = 1 [json_name = "payload"]; +inline bool SimpleResponse::has_payload() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.payload_ != nullptr); + return value; +} +inline void SimpleResponse::clear_payload() { + if (_impl_.payload_ != nullptr) _impl_.payload_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::connectrpc::conformance::Payload& SimpleResponse::_internal_payload() const { + const ::connectrpc::conformance::Payload* p = _impl_.payload_; + return p != nullptr ? *p : reinterpret_cast( + ::connectrpc::conformance::_Payload_default_instance_); +} +inline const ::connectrpc::conformance::Payload& SimpleResponse::payload() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.SimpleResponse.payload) + return _internal_payload(); +} +inline void SimpleResponse::unsafe_arena_set_allocated_payload( + ::connectrpc::conformance::Payload* payload) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.payload_); + } + _impl_.payload_ = payload; + if (payload) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:connectrpc.conformance.SimpleResponse.payload) +} +inline ::connectrpc::conformance::Payload* SimpleResponse::release_payload() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::connectrpc::conformance::Payload* temp = _impl_.payload_; + _impl_.payload_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::connectrpc::conformance::Payload* SimpleResponse::unsafe_arena_release_payload() { + // @@protoc_insertion_point(field_release:connectrpc.conformance.SimpleResponse.payload) + _impl_._has_bits_[0] &= ~0x00000001u; + ::connectrpc::conformance::Payload* temp = _impl_.payload_; + _impl_.payload_ = nullptr; + return temp; +} +inline ::connectrpc::conformance::Payload* SimpleResponse::_internal_mutable_payload() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.payload_ == nullptr) { + auto* p = CreateMaybeMessage<::connectrpc::conformance::Payload>(GetArenaForAllocation()); + _impl_.payload_ = p; + } + return _impl_.payload_; +} +inline ::connectrpc::conformance::Payload* SimpleResponse::mutable_payload() { + ::connectrpc::conformance::Payload* _msg = _internal_mutable_payload(); + // @@protoc_insertion_point(field_mutable:connectrpc.conformance.SimpleResponse.payload) + return _msg; +} +inline void SimpleResponse::set_allocated_payload(::connectrpc::conformance::Payload* payload) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.payload_; + } + if (payload) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(payload); + if (message_arena != submessage_arena) { + payload = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, payload, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.payload_ = payload; + // @@protoc_insertion_point(field_set_allocated:connectrpc.conformance.SimpleResponse.payload) +} + +// string username = 2 [json_name = "username"]; +inline void SimpleResponse::clear_username() { + _impl_.username_.ClearToEmpty(); +} +inline const std::string& SimpleResponse::username() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.SimpleResponse.username) + return _internal_username(); +} +template +inline PROTOBUF_ALWAYS_INLINE void SimpleResponse::set_username(Arg_&& arg, + Args_... args) { + ; + _impl_.username_.Set(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:connectrpc.conformance.SimpleResponse.username) +} +inline std::string* SimpleResponse::mutable_username() { + std::string* _s = _internal_mutable_username(); + // @@protoc_insertion_point(field_mutable:connectrpc.conformance.SimpleResponse.username) + return _s; +} +inline const std::string& SimpleResponse::_internal_username() const { + return _impl_.username_.Get(); +} +inline void SimpleResponse::_internal_set_username(const std::string& value) { + ; + + + _impl_.username_.Set(value, GetArenaForAllocation()); +} +inline std::string* SimpleResponse::_internal_mutable_username() { + ; + return _impl_.username_.Mutable( GetArenaForAllocation()); +} +inline std::string* SimpleResponse::release_username() { + // @@protoc_insertion_point(field_release:connectrpc.conformance.SimpleResponse.username) + return _impl_.username_.Release(); +} +inline void SimpleResponse::set_allocated_username(std::string* value) { + _impl_.username_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.username_.IsDefault()) { + _impl_.username_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:connectrpc.conformance.SimpleResponse.username) +} + +// string oauth_scope = 3 [json_name = "oauthScope"]; +inline void SimpleResponse::clear_oauth_scope() { + _impl_.oauth_scope_.ClearToEmpty(); +} +inline const std::string& SimpleResponse::oauth_scope() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.SimpleResponse.oauth_scope) + return _internal_oauth_scope(); +} +template +inline PROTOBUF_ALWAYS_INLINE void SimpleResponse::set_oauth_scope(Arg_&& arg, + Args_... args) { + ; + _impl_.oauth_scope_.Set(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:connectrpc.conformance.SimpleResponse.oauth_scope) +} +inline std::string* SimpleResponse::mutable_oauth_scope() { + std::string* _s = _internal_mutable_oauth_scope(); + // @@protoc_insertion_point(field_mutable:connectrpc.conformance.SimpleResponse.oauth_scope) + return _s; +} +inline const std::string& SimpleResponse::_internal_oauth_scope() const { + return _impl_.oauth_scope_.Get(); +} +inline void SimpleResponse::_internal_set_oauth_scope(const std::string& value) { + ; + + + _impl_.oauth_scope_.Set(value, GetArenaForAllocation()); +} +inline std::string* SimpleResponse::_internal_mutable_oauth_scope() { + ; + return _impl_.oauth_scope_.Mutable( GetArenaForAllocation()); +} +inline std::string* SimpleResponse::release_oauth_scope() { + // @@protoc_insertion_point(field_release:connectrpc.conformance.SimpleResponse.oauth_scope) + return _impl_.oauth_scope_.Release(); +} +inline void SimpleResponse::set_allocated_oauth_scope(std::string* value) { + _impl_.oauth_scope_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.oauth_scope_.IsDefault()) { + _impl_.oauth_scope_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:connectrpc.conformance.SimpleResponse.oauth_scope) +} + +// string server_id = 4 [json_name = "serverId"]; +inline void SimpleResponse::clear_server_id() { + _impl_.server_id_.ClearToEmpty(); +} +inline const std::string& SimpleResponse::server_id() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.SimpleResponse.server_id) + return _internal_server_id(); +} +template +inline PROTOBUF_ALWAYS_INLINE void SimpleResponse::set_server_id(Arg_&& arg, + Args_... args) { + ; + _impl_.server_id_.Set(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:connectrpc.conformance.SimpleResponse.server_id) +} +inline std::string* SimpleResponse::mutable_server_id() { + std::string* _s = _internal_mutable_server_id(); + // @@protoc_insertion_point(field_mutable:connectrpc.conformance.SimpleResponse.server_id) + return _s; +} +inline const std::string& SimpleResponse::_internal_server_id() const { + return _impl_.server_id_.Get(); +} +inline void SimpleResponse::_internal_set_server_id(const std::string& value) { + ; + + + _impl_.server_id_.Set(value, GetArenaForAllocation()); +} +inline std::string* SimpleResponse::_internal_mutable_server_id() { + ; + return _impl_.server_id_.Mutable( GetArenaForAllocation()); +} +inline std::string* SimpleResponse::release_server_id() { + // @@protoc_insertion_point(field_release:connectrpc.conformance.SimpleResponse.server_id) + return _impl_.server_id_.Release(); +} +inline void SimpleResponse::set_allocated_server_id(std::string* value) { + _impl_.server_id_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.server_id_.IsDefault()) { + _impl_.server_id_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:connectrpc.conformance.SimpleResponse.server_id) +} + +// .connectrpc.conformance.GrpclbRouteType grpclb_route_type = 5 [json_name = "grpclbRouteType"]; +inline void SimpleResponse::clear_grpclb_route_type() { + _impl_.grpclb_route_type_ = 0; +} +inline ::connectrpc::conformance::GrpclbRouteType SimpleResponse::grpclb_route_type() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.SimpleResponse.grpclb_route_type) + return _internal_grpclb_route_type(); +} +inline void SimpleResponse::set_grpclb_route_type(::connectrpc::conformance::GrpclbRouteType value) { + _internal_set_grpclb_route_type(value); + // @@protoc_insertion_point(field_set:connectrpc.conformance.SimpleResponse.grpclb_route_type) +} +inline ::connectrpc::conformance::GrpclbRouteType SimpleResponse::_internal_grpclb_route_type() const { + return static_cast<::connectrpc::conformance::GrpclbRouteType>(_impl_.grpclb_route_type_); +} +inline void SimpleResponse::_internal_set_grpclb_route_type(::connectrpc::conformance::GrpclbRouteType value) { + ; + _impl_.grpclb_route_type_ = value; +} + +// string hostname = 6 [json_name = "hostname"]; +inline void SimpleResponse::clear_hostname() { + _impl_.hostname_.ClearToEmpty(); +} +inline const std::string& SimpleResponse::hostname() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.SimpleResponse.hostname) + return _internal_hostname(); +} +template +inline PROTOBUF_ALWAYS_INLINE void SimpleResponse::set_hostname(Arg_&& arg, + Args_... args) { + ; + _impl_.hostname_.Set(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:connectrpc.conformance.SimpleResponse.hostname) +} +inline std::string* SimpleResponse::mutable_hostname() { + std::string* _s = _internal_mutable_hostname(); + // @@protoc_insertion_point(field_mutable:connectrpc.conformance.SimpleResponse.hostname) + return _s; +} +inline const std::string& SimpleResponse::_internal_hostname() const { + return _impl_.hostname_.Get(); +} +inline void SimpleResponse::_internal_set_hostname(const std::string& value) { + ; + + + _impl_.hostname_.Set(value, GetArenaForAllocation()); +} +inline std::string* SimpleResponse::_internal_mutable_hostname() { + ; + return _impl_.hostname_.Mutable( GetArenaForAllocation()); +} +inline std::string* SimpleResponse::release_hostname() { + // @@protoc_insertion_point(field_release:connectrpc.conformance.SimpleResponse.hostname) + return _impl_.hostname_.Release(); +} +inline void SimpleResponse::set_allocated_hostname(std::string* value) { + _impl_.hostname_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.hostname_.IsDefault()) { + _impl_.hostname_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:connectrpc.conformance.SimpleResponse.hostname) +} + +// ------------------------------------------------------------------- + +// StreamingInputCallRequest + +// .connectrpc.conformance.Payload payload = 1 [json_name = "payload"]; +inline bool StreamingInputCallRequest::has_payload() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.payload_ != nullptr); + return value; +} +inline void StreamingInputCallRequest::clear_payload() { + if (_impl_.payload_ != nullptr) _impl_.payload_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::connectrpc::conformance::Payload& StreamingInputCallRequest::_internal_payload() const { + const ::connectrpc::conformance::Payload* p = _impl_.payload_; + return p != nullptr ? *p : reinterpret_cast( + ::connectrpc::conformance::_Payload_default_instance_); +} +inline const ::connectrpc::conformance::Payload& StreamingInputCallRequest::payload() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.StreamingInputCallRequest.payload) + return _internal_payload(); +} +inline void StreamingInputCallRequest::unsafe_arena_set_allocated_payload( + ::connectrpc::conformance::Payload* payload) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.payload_); + } + _impl_.payload_ = payload; + if (payload) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:connectrpc.conformance.StreamingInputCallRequest.payload) +} +inline ::connectrpc::conformance::Payload* StreamingInputCallRequest::release_payload() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::connectrpc::conformance::Payload* temp = _impl_.payload_; + _impl_.payload_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::connectrpc::conformance::Payload* StreamingInputCallRequest::unsafe_arena_release_payload() { + // @@protoc_insertion_point(field_release:connectrpc.conformance.StreamingInputCallRequest.payload) + _impl_._has_bits_[0] &= ~0x00000001u; + ::connectrpc::conformance::Payload* temp = _impl_.payload_; + _impl_.payload_ = nullptr; + return temp; +} +inline ::connectrpc::conformance::Payload* StreamingInputCallRequest::_internal_mutable_payload() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.payload_ == nullptr) { + auto* p = CreateMaybeMessage<::connectrpc::conformance::Payload>(GetArenaForAllocation()); + _impl_.payload_ = p; + } + return _impl_.payload_; +} +inline ::connectrpc::conformance::Payload* StreamingInputCallRequest::mutable_payload() { + ::connectrpc::conformance::Payload* _msg = _internal_mutable_payload(); + // @@protoc_insertion_point(field_mutable:connectrpc.conformance.StreamingInputCallRequest.payload) + return _msg; +} +inline void StreamingInputCallRequest::set_allocated_payload(::connectrpc::conformance::Payload* payload) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.payload_; + } + if (payload) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(payload); + if (message_arena != submessage_arena) { + payload = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, payload, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.payload_ = payload; + // @@protoc_insertion_point(field_set_allocated:connectrpc.conformance.StreamingInputCallRequest.payload) +} + +// .google.protobuf.BoolValue expect_compressed = 2 [json_name = "expectCompressed"]; +inline bool StreamingInputCallRequest::has_expect_compressed() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.expect_compressed_ != nullptr); + return value; +} +inline const ::PROTOBUF_NAMESPACE_ID::BoolValue& StreamingInputCallRequest::_internal_expect_compressed() const { + const ::PROTOBUF_NAMESPACE_ID::BoolValue* p = _impl_.expect_compressed_; + return p != nullptr ? *p : reinterpret_cast( + ::PROTOBUF_NAMESPACE_ID::_BoolValue_default_instance_); +} +inline const ::PROTOBUF_NAMESPACE_ID::BoolValue& StreamingInputCallRequest::expect_compressed() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.StreamingInputCallRequest.expect_compressed) + return _internal_expect_compressed(); +} +inline void StreamingInputCallRequest::unsafe_arena_set_allocated_expect_compressed( + ::PROTOBUF_NAMESPACE_ID::BoolValue* expect_compressed) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.expect_compressed_); + } + _impl_.expect_compressed_ = expect_compressed; + if (expect_compressed) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:connectrpc.conformance.StreamingInputCallRequest.expect_compressed) +} +inline ::PROTOBUF_NAMESPACE_ID::BoolValue* StreamingInputCallRequest::release_expect_compressed() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::PROTOBUF_NAMESPACE_ID::BoolValue* temp = _impl_.expect_compressed_; + _impl_.expect_compressed_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::PROTOBUF_NAMESPACE_ID::BoolValue* StreamingInputCallRequest::unsafe_arena_release_expect_compressed() { + // @@protoc_insertion_point(field_release:connectrpc.conformance.StreamingInputCallRequest.expect_compressed) + _impl_._has_bits_[0] &= ~0x00000002u; + ::PROTOBUF_NAMESPACE_ID::BoolValue* temp = _impl_.expect_compressed_; + _impl_.expect_compressed_ = nullptr; + return temp; +} +inline ::PROTOBUF_NAMESPACE_ID::BoolValue* StreamingInputCallRequest::_internal_mutable_expect_compressed() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.expect_compressed_ == nullptr) { + auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::BoolValue>(GetArenaForAllocation()); + _impl_.expect_compressed_ = p; + } + return _impl_.expect_compressed_; +} +inline ::PROTOBUF_NAMESPACE_ID::BoolValue* StreamingInputCallRequest::mutable_expect_compressed() { + ::PROTOBUF_NAMESPACE_ID::BoolValue* _msg = _internal_mutable_expect_compressed(); + // @@protoc_insertion_point(field_mutable:connectrpc.conformance.StreamingInputCallRequest.expect_compressed) + return _msg; +} +inline void StreamingInputCallRequest::set_allocated_expect_compressed(::PROTOBUF_NAMESPACE_ID::BoolValue* expect_compressed) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.expect_compressed_); + } + if (expect_compressed) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expect_compressed)); + if (message_arena != submessage_arena) { + expect_compressed = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, expect_compressed, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.expect_compressed_ = expect_compressed; + // @@protoc_insertion_point(field_set_allocated:connectrpc.conformance.StreamingInputCallRequest.expect_compressed) +} + +// ------------------------------------------------------------------- + +// StreamingInputCallResponse + +// int32 aggregated_payload_size = 1 [json_name = "aggregatedPayloadSize"]; +inline void StreamingInputCallResponse::clear_aggregated_payload_size() { + _impl_.aggregated_payload_size_ = 0; +} +inline ::int32_t StreamingInputCallResponse::aggregated_payload_size() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.StreamingInputCallResponse.aggregated_payload_size) + return _internal_aggregated_payload_size(); +} +inline void StreamingInputCallResponse::set_aggregated_payload_size(::int32_t value) { + _internal_set_aggregated_payload_size(value); + // @@protoc_insertion_point(field_set:connectrpc.conformance.StreamingInputCallResponse.aggregated_payload_size) +} +inline ::int32_t StreamingInputCallResponse::_internal_aggregated_payload_size() const { + return _impl_.aggregated_payload_size_; +} +inline void StreamingInputCallResponse::_internal_set_aggregated_payload_size(::int32_t value) { + ; + _impl_.aggregated_payload_size_ = value; +} + +// ------------------------------------------------------------------- + +// ResponseParameters + +// int32 size = 1 [json_name = "size"]; +inline void ResponseParameters::clear_size() { + _impl_.size_ = 0; +} +inline ::int32_t ResponseParameters::size() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.ResponseParameters.size) + return _internal_size(); +} +inline void ResponseParameters::set_size(::int32_t value) { + _internal_set_size(value); + // @@protoc_insertion_point(field_set:connectrpc.conformance.ResponseParameters.size) +} +inline ::int32_t ResponseParameters::_internal_size() const { + return _impl_.size_; +} +inline void ResponseParameters::_internal_set_size(::int32_t value) { + ; + _impl_.size_ = value; +} + +// int32 interval_us = 2 [json_name = "intervalUs"]; +inline void ResponseParameters::clear_interval_us() { + _impl_.interval_us_ = 0; +} +inline ::int32_t ResponseParameters::interval_us() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.ResponseParameters.interval_us) + return _internal_interval_us(); +} +inline void ResponseParameters::set_interval_us(::int32_t value) { + _internal_set_interval_us(value); + // @@protoc_insertion_point(field_set:connectrpc.conformance.ResponseParameters.interval_us) +} +inline ::int32_t ResponseParameters::_internal_interval_us() const { + return _impl_.interval_us_; +} +inline void ResponseParameters::_internal_set_interval_us(::int32_t value) { + ; + _impl_.interval_us_ = value; +} + +// .google.protobuf.BoolValue compressed = 3 [json_name = "compressed"]; +inline bool ResponseParameters::has_compressed() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.compressed_ != nullptr); + return value; +} +inline const ::PROTOBUF_NAMESPACE_ID::BoolValue& ResponseParameters::_internal_compressed() const { + const ::PROTOBUF_NAMESPACE_ID::BoolValue* p = _impl_.compressed_; + return p != nullptr ? *p : reinterpret_cast( + ::PROTOBUF_NAMESPACE_ID::_BoolValue_default_instance_); +} +inline const ::PROTOBUF_NAMESPACE_ID::BoolValue& ResponseParameters::compressed() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.ResponseParameters.compressed) + return _internal_compressed(); +} +inline void ResponseParameters::unsafe_arena_set_allocated_compressed( + ::PROTOBUF_NAMESPACE_ID::BoolValue* compressed) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.compressed_); + } + _impl_.compressed_ = compressed; + if (compressed) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:connectrpc.conformance.ResponseParameters.compressed) +} +inline ::PROTOBUF_NAMESPACE_ID::BoolValue* ResponseParameters::release_compressed() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::PROTOBUF_NAMESPACE_ID::BoolValue* temp = _impl_.compressed_; + _impl_.compressed_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::PROTOBUF_NAMESPACE_ID::BoolValue* ResponseParameters::unsafe_arena_release_compressed() { + // @@protoc_insertion_point(field_release:connectrpc.conformance.ResponseParameters.compressed) + _impl_._has_bits_[0] &= ~0x00000001u; + ::PROTOBUF_NAMESPACE_ID::BoolValue* temp = _impl_.compressed_; + _impl_.compressed_ = nullptr; + return temp; +} +inline ::PROTOBUF_NAMESPACE_ID::BoolValue* ResponseParameters::_internal_mutable_compressed() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.compressed_ == nullptr) { + auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::BoolValue>(GetArenaForAllocation()); + _impl_.compressed_ = p; + } + return _impl_.compressed_; +} +inline ::PROTOBUF_NAMESPACE_ID::BoolValue* ResponseParameters::mutable_compressed() { + ::PROTOBUF_NAMESPACE_ID::BoolValue* _msg = _internal_mutable_compressed(); + // @@protoc_insertion_point(field_mutable:connectrpc.conformance.ResponseParameters.compressed) + return _msg; +} +inline void ResponseParameters::set_allocated_compressed(::PROTOBUF_NAMESPACE_ID::BoolValue* compressed) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.compressed_); + } + if (compressed) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(compressed)); + if (message_arena != submessage_arena) { + compressed = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, compressed, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.compressed_ = compressed; + // @@protoc_insertion_point(field_set_allocated:connectrpc.conformance.ResponseParameters.compressed) +} + +// ------------------------------------------------------------------- + +// StreamingOutputCallRequest + +// .connectrpc.conformance.PayloadType response_type = 1 [json_name = "responseType"]; +inline void StreamingOutputCallRequest::clear_response_type() { + _impl_.response_type_ = 0; +} +inline ::connectrpc::conformance::PayloadType StreamingOutputCallRequest::response_type() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.StreamingOutputCallRequest.response_type) + return _internal_response_type(); +} +inline void StreamingOutputCallRequest::set_response_type(::connectrpc::conformance::PayloadType value) { + _internal_set_response_type(value); + // @@protoc_insertion_point(field_set:connectrpc.conformance.StreamingOutputCallRequest.response_type) +} +inline ::connectrpc::conformance::PayloadType StreamingOutputCallRequest::_internal_response_type() const { + return static_cast<::connectrpc::conformance::PayloadType>(_impl_.response_type_); +} +inline void StreamingOutputCallRequest::_internal_set_response_type(::connectrpc::conformance::PayloadType value) { + ; + _impl_.response_type_ = value; +} + +// repeated .connectrpc.conformance.ResponseParameters response_parameters = 2 [json_name = "responseParameters"]; +inline int StreamingOutputCallRequest::_internal_response_parameters_size() const { + return _impl_.response_parameters_.size(); +} +inline int StreamingOutputCallRequest::response_parameters_size() const { + return _internal_response_parameters_size(); +} +inline void StreamingOutputCallRequest::clear_response_parameters() { + _internal_mutable_response_parameters()->Clear(); +} +inline ::connectrpc::conformance::ResponseParameters* StreamingOutputCallRequest::mutable_response_parameters(int index) { + // @@protoc_insertion_point(field_mutable:connectrpc.conformance.StreamingOutputCallRequest.response_parameters) + return _internal_mutable_response_parameters()->Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::connectrpc::conformance::ResponseParameters >* +StreamingOutputCallRequest::mutable_response_parameters() { + // @@protoc_insertion_point(field_mutable_list:connectrpc.conformance.StreamingOutputCallRequest.response_parameters) + return _internal_mutable_response_parameters(); +} +inline const ::connectrpc::conformance::ResponseParameters& StreamingOutputCallRequest::_internal_response_parameters(int index) const { + return _internal_response_parameters().Get(index); +} +inline const ::connectrpc::conformance::ResponseParameters& StreamingOutputCallRequest::response_parameters(int index) const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.StreamingOutputCallRequest.response_parameters) + return _internal_response_parameters(index); +} +inline ::connectrpc::conformance::ResponseParameters* StreamingOutputCallRequest::_internal_add_response_parameters() { + return _internal_mutable_response_parameters()->Add(); +} +inline ::connectrpc::conformance::ResponseParameters* StreamingOutputCallRequest::add_response_parameters() { + ::connectrpc::conformance::ResponseParameters* _add = _internal_add_response_parameters(); + // @@protoc_insertion_point(field_add:connectrpc.conformance.StreamingOutputCallRequest.response_parameters) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::connectrpc::conformance::ResponseParameters >& +StreamingOutputCallRequest::response_parameters() const { + // @@protoc_insertion_point(field_list:connectrpc.conformance.StreamingOutputCallRequest.response_parameters) + return _internal_response_parameters(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::connectrpc::conformance::ResponseParameters>& +StreamingOutputCallRequest::_internal_response_parameters() const { + return _impl_.response_parameters_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::connectrpc::conformance::ResponseParameters>* +StreamingOutputCallRequest::_internal_mutable_response_parameters() { + return &_impl_.response_parameters_; +} + +// .connectrpc.conformance.Payload payload = 3 [json_name = "payload"]; +inline bool StreamingOutputCallRequest::has_payload() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.payload_ != nullptr); + return value; +} +inline void StreamingOutputCallRequest::clear_payload() { + if (_impl_.payload_ != nullptr) _impl_.payload_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::connectrpc::conformance::Payload& StreamingOutputCallRequest::_internal_payload() const { + const ::connectrpc::conformance::Payload* p = _impl_.payload_; + return p != nullptr ? *p : reinterpret_cast( + ::connectrpc::conformance::_Payload_default_instance_); +} +inline const ::connectrpc::conformance::Payload& StreamingOutputCallRequest::payload() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.StreamingOutputCallRequest.payload) + return _internal_payload(); +} +inline void StreamingOutputCallRequest::unsafe_arena_set_allocated_payload( + ::connectrpc::conformance::Payload* payload) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.payload_); + } + _impl_.payload_ = payload; + if (payload) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:connectrpc.conformance.StreamingOutputCallRequest.payload) +} +inline ::connectrpc::conformance::Payload* StreamingOutputCallRequest::release_payload() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::connectrpc::conformance::Payload* temp = _impl_.payload_; + _impl_.payload_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::connectrpc::conformance::Payload* StreamingOutputCallRequest::unsafe_arena_release_payload() { + // @@protoc_insertion_point(field_release:connectrpc.conformance.StreamingOutputCallRequest.payload) + _impl_._has_bits_[0] &= ~0x00000001u; + ::connectrpc::conformance::Payload* temp = _impl_.payload_; + _impl_.payload_ = nullptr; + return temp; +} +inline ::connectrpc::conformance::Payload* StreamingOutputCallRequest::_internal_mutable_payload() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.payload_ == nullptr) { + auto* p = CreateMaybeMessage<::connectrpc::conformance::Payload>(GetArenaForAllocation()); + _impl_.payload_ = p; + } + return _impl_.payload_; +} +inline ::connectrpc::conformance::Payload* StreamingOutputCallRequest::mutable_payload() { + ::connectrpc::conformance::Payload* _msg = _internal_mutable_payload(); + // @@protoc_insertion_point(field_mutable:connectrpc.conformance.StreamingOutputCallRequest.payload) + return _msg; +} +inline void StreamingOutputCallRequest::set_allocated_payload(::connectrpc::conformance::Payload* payload) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.payload_; + } + if (payload) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(payload); + if (message_arena != submessage_arena) { + payload = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, payload, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.payload_ = payload; + // @@protoc_insertion_point(field_set_allocated:connectrpc.conformance.StreamingOutputCallRequest.payload) +} + +// .connectrpc.conformance.EchoStatus response_status = 7 [json_name = "responseStatus"]; +inline bool StreamingOutputCallRequest::has_response_status() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.response_status_ != nullptr); + return value; +} +inline void StreamingOutputCallRequest::clear_response_status() { + if (_impl_.response_status_ != nullptr) _impl_.response_status_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::connectrpc::conformance::EchoStatus& StreamingOutputCallRequest::_internal_response_status() const { + const ::connectrpc::conformance::EchoStatus* p = _impl_.response_status_; + return p != nullptr ? *p : reinterpret_cast( + ::connectrpc::conformance::_EchoStatus_default_instance_); +} +inline const ::connectrpc::conformance::EchoStatus& StreamingOutputCallRequest::response_status() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.StreamingOutputCallRequest.response_status) + return _internal_response_status(); +} +inline void StreamingOutputCallRequest::unsafe_arena_set_allocated_response_status( + ::connectrpc::conformance::EchoStatus* response_status) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.response_status_); + } + _impl_.response_status_ = response_status; + if (response_status) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:connectrpc.conformance.StreamingOutputCallRequest.response_status) +} +inline ::connectrpc::conformance::EchoStatus* StreamingOutputCallRequest::release_response_status() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::connectrpc::conformance::EchoStatus* temp = _impl_.response_status_; + _impl_.response_status_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::connectrpc::conformance::EchoStatus* StreamingOutputCallRequest::unsafe_arena_release_response_status() { + // @@protoc_insertion_point(field_release:connectrpc.conformance.StreamingOutputCallRequest.response_status) + _impl_._has_bits_[0] &= ~0x00000002u; + ::connectrpc::conformance::EchoStatus* temp = _impl_.response_status_; + _impl_.response_status_ = nullptr; + return temp; +} +inline ::connectrpc::conformance::EchoStatus* StreamingOutputCallRequest::_internal_mutable_response_status() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.response_status_ == nullptr) { + auto* p = CreateMaybeMessage<::connectrpc::conformance::EchoStatus>(GetArenaForAllocation()); + _impl_.response_status_ = p; + } + return _impl_.response_status_; +} +inline ::connectrpc::conformance::EchoStatus* StreamingOutputCallRequest::mutable_response_status() { + ::connectrpc::conformance::EchoStatus* _msg = _internal_mutable_response_status(); + // @@protoc_insertion_point(field_mutable:connectrpc.conformance.StreamingOutputCallRequest.response_status) + return _msg; +} +inline void StreamingOutputCallRequest::set_allocated_response_status(::connectrpc::conformance::EchoStatus* response_status) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.response_status_; + } + if (response_status) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(response_status); + if (message_arena != submessage_arena) { + response_status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, response_status, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.response_status_ = response_status; + // @@protoc_insertion_point(field_set_allocated:connectrpc.conformance.StreamingOutputCallRequest.response_status) +} + +// ------------------------------------------------------------------- + +// StreamingOutputCallResponse + +// .connectrpc.conformance.Payload payload = 1 [json_name = "payload"]; +inline bool StreamingOutputCallResponse::has_payload() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.payload_ != nullptr); + return value; +} +inline void StreamingOutputCallResponse::clear_payload() { + if (_impl_.payload_ != nullptr) _impl_.payload_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::connectrpc::conformance::Payload& StreamingOutputCallResponse::_internal_payload() const { + const ::connectrpc::conformance::Payload* p = _impl_.payload_; + return p != nullptr ? *p : reinterpret_cast( + ::connectrpc::conformance::_Payload_default_instance_); +} +inline const ::connectrpc::conformance::Payload& StreamingOutputCallResponse::payload() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.StreamingOutputCallResponse.payload) + return _internal_payload(); +} +inline void StreamingOutputCallResponse::unsafe_arena_set_allocated_payload( + ::connectrpc::conformance::Payload* payload) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.payload_); + } + _impl_.payload_ = payload; + if (payload) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:connectrpc.conformance.StreamingOutputCallResponse.payload) +} +inline ::connectrpc::conformance::Payload* StreamingOutputCallResponse::release_payload() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::connectrpc::conformance::Payload* temp = _impl_.payload_; + _impl_.payload_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::connectrpc::conformance::Payload* StreamingOutputCallResponse::unsafe_arena_release_payload() { + // @@protoc_insertion_point(field_release:connectrpc.conformance.StreamingOutputCallResponse.payload) + _impl_._has_bits_[0] &= ~0x00000001u; + ::connectrpc::conformance::Payload* temp = _impl_.payload_; + _impl_.payload_ = nullptr; + return temp; +} +inline ::connectrpc::conformance::Payload* StreamingOutputCallResponse::_internal_mutable_payload() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.payload_ == nullptr) { + auto* p = CreateMaybeMessage<::connectrpc::conformance::Payload>(GetArenaForAllocation()); + _impl_.payload_ = p; + } + return _impl_.payload_; +} +inline ::connectrpc::conformance::Payload* StreamingOutputCallResponse::mutable_payload() { + ::connectrpc::conformance::Payload* _msg = _internal_mutable_payload(); + // @@protoc_insertion_point(field_mutable:connectrpc.conformance.StreamingOutputCallResponse.payload) + return _msg; +} +inline void StreamingOutputCallResponse::set_allocated_payload(::connectrpc::conformance::Payload* payload) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.payload_; + } + if (payload) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(payload); + if (message_arena != submessage_arena) { + payload = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, payload, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.payload_ = payload; + // @@protoc_insertion_point(field_set_allocated:connectrpc.conformance.StreamingOutputCallResponse.payload) +} + +// ------------------------------------------------------------------- + +// ReconnectParams + +// int32 max_reconnect_backoff_ms = 1 [json_name = "maxReconnectBackoffMs"]; +inline void ReconnectParams::clear_max_reconnect_backoff_ms() { + _impl_.max_reconnect_backoff_ms_ = 0; +} +inline ::int32_t ReconnectParams::max_reconnect_backoff_ms() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.ReconnectParams.max_reconnect_backoff_ms) + return _internal_max_reconnect_backoff_ms(); +} +inline void ReconnectParams::set_max_reconnect_backoff_ms(::int32_t value) { + _internal_set_max_reconnect_backoff_ms(value); + // @@protoc_insertion_point(field_set:connectrpc.conformance.ReconnectParams.max_reconnect_backoff_ms) +} +inline ::int32_t ReconnectParams::_internal_max_reconnect_backoff_ms() const { + return _impl_.max_reconnect_backoff_ms_; +} +inline void ReconnectParams::_internal_set_max_reconnect_backoff_ms(::int32_t value) { + ; + _impl_.max_reconnect_backoff_ms_ = value; +} + +// ------------------------------------------------------------------- + +// ReconnectInfo + +// bool passed = 1 [json_name = "passed"]; +inline void ReconnectInfo::clear_passed() { + _impl_.passed_ = false; +} +inline bool ReconnectInfo::passed() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.ReconnectInfo.passed) + return _internal_passed(); +} +inline void ReconnectInfo::set_passed(bool value) { + _internal_set_passed(value); + // @@protoc_insertion_point(field_set:connectrpc.conformance.ReconnectInfo.passed) +} +inline bool ReconnectInfo::_internal_passed() const { + return _impl_.passed_; +} +inline void ReconnectInfo::_internal_set_passed(bool value) { + ; + _impl_.passed_ = value; +} + +// repeated int32 backoff_ms = 2 [json_name = "backoffMs"]; +inline int ReconnectInfo::_internal_backoff_ms_size() const { + return _impl_.backoff_ms_.size(); +} +inline int ReconnectInfo::backoff_ms_size() const { + return _internal_backoff_ms_size(); +} +inline void ReconnectInfo::clear_backoff_ms() { + _internal_mutable_backoff_ms()->Clear(); +} +inline ::int32_t ReconnectInfo::backoff_ms(int index) const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.ReconnectInfo.backoff_ms) + return _internal_backoff_ms(index); +} +inline void ReconnectInfo::set_backoff_ms(int index, ::int32_t value) { + _internal_mutable_backoff_ms()->Set(index, value); + // @@protoc_insertion_point(field_set:connectrpc.conformance.ReconnectInfo.backoff_ms) +} +inline void ReconnectInfo::add_backoff_ms(::int32_t value) { + _internal_add_backoff_ms(value); + // @@protoc_insertion_point(field_add:connectrpc.conformance.ReconnectInfo.backoff_ms) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& ReconnectInfo::backoff_ms() const { + // @@protoc_insertion_point(field_list:connectrpc.conformance.ReconnectInfo.backoff_ms) + return _internal_backoff_ms(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* ReconnectInfo::mutable_backoff_ms() { + // @@protoc_insertion_point(field_mutable_list:connectrpc.conformance.ReconnectInfo.backoff_ms) + return _internal_mutable_backoff_ms(); +} + +inline ::int32_t ReconnectInfo::_internal_backoff_ms(int index) const { + return _internal_backoff_ms().Get(index); +} +inline void ReconnectInfo::_internal_add_backoff_ms(::int32_t value) { + _internal_mutable_backoff_ms()->Add(value); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& ReconnectInfo::_internal_backoff_ms() const { + return _impl_.backoff_ms_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* ReconnectInfo::_internal_mutable_backoff_ms() { + return &_impl_.backoff_ms_; +} + +// ------------------------------------------------------------------- + +// LoadBalancerStatsRequest + +// int32 num_rpcs = 1 [json_name = "numRpcs"]; +inline void LoadBalancerStatsRequest::clear_num_rpcs() { + _impl_.num_rpcs_ = 0; +} +inline ::int32_t LoadBalancerStatsRequest::num_rpcs() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.LoadBalancerStatsRequest.num_rpcs) + return _internal_num_rpcs(); +} +inline void LoadBalancerStatsRequest::set_num_rpcs(::int32_t value) { + _internal_set_num_rpcs(value); + // @@protoc_insertion_point(field_set:connectrpc.conformance.LoadBalancerStatsRequest.num_rpcs) +} +inline ::int32_t LoadBalancerStatsRequest::_internal_num_rpcs() const { + return _impl_.num_rpcs_; +} +inline void LoadBalancerStatsRequest::_internal_set_num_rpcs(::int32_t value) { + ; + _impl_.num_rpcs_ = value; +} + +// int32 timeout_sec = 2 [json_name = "timeoutSec"]; +inline void LoadBalancerStatsRequest::clear_timeout_sec() { + _impl_.timeout_sec_ = 0; +} +inline ::int32_t LoadBalancerStatsRequest::timeout_sec() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.LoadBalancerStatsRequest.timeout_sec) + return _internal_timeout_sec(); +} +inline void LoadBalancerStatsRequest::set_timeout_sec(::int32_t value) { + _internal_set_timeout_sec(value); + // @@protoc_insertion_point(field_set:connectrpc.conformance.LoadBalancerStatsRequest.timeout_sec) +} +inline ::int32_t LoadBalancerStatsRequest::_internal_timeout_sec() const { + return _impl_.timeout_sec_; +} +inline void LoadBalancerStatsRequest::_internal_set_timeout_sec(::int32_t value) { + ; + _impl_.timeout_sec_ = value; +} + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// LoadBalancerStatsResponse_RpcsByPeer + +// map rpcs_by_peer = 1 [json_name = "rpcsByPeer"]; +inline int LoadBalancerStatsResponse_RpcsByPeer::_internal_rpcs_by_peer_size() const { + return _impl_.rpcs_by_peer_.size(); +} +inline int LoadBalancerStatsResponse_RpcsByPeer::rpcs_by_peer_size() const { + return _internal_rpcs_by_peer_size(); +} +inline void LoadBalancerStatsResponse_RpcsByPeer::clear_rpcs_by_peer() { + _impl_.rpcs_by_peer_.Clear(); +} +inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >& +LoadBalancerStatsResponse_RpcsByPeer::_internal_rpcs_by_peer() const { + return _impl_.rpcs_by_peer_.GetMap(); +} +inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >& +LoadBalancerStatsResponse_RpcsByPeer::rpcs_by_peer() const { + // @@protoc_insertion_point(field_map:connectrpc.conformance.LoadBalancerStatsResponse.RpcsByPeer.rpcs_by_peer) + return _internal_rpcs_by_peer(); +} +inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >* +LoadBalancerStatsResponse_RpcsByPeer::_internal_mutable_rpcs_by_peer() { + return _impl_.rpcs_by_peer_.MutableMap(); +} +inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >* +LoadBalancerStatsResponse_RpcsByPeer::mutable_rpcs_by_peer() { + // @@protoc_insertion_point(field_mutable_map:connectrpc.conformance.LoadBalancerStatsResponse.RpcsByPeer.rpcs_by_peer) + return _internal_mutable_rpcs_by_peer(); +} + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// LoadBalancerStatsResponse + +// map rpcs_by_peer = 1 [json_name = "rpcsByPeer"]; +inline int LoadBalancerStatsResponse::_internal_rpcs_by_peer_size() const { + return _impl_.rpcs_by_peer_.size(); +} +inline int LoadBalancerStatsResponse::rpcs_by_peer_size() const { + return _internal_rpcs_by_peer_size(); +} +inline void LoadBalancerStatsResponse::clear_rpcs_by_peer() { + _impl_.rpcs_by_peer_.Clear(); +} +inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >& +LoadBalancerStatsResponse::_internal_rpcs_by_peer() const { + return _impl_.rpcs_by_peer_.GetMap(); +} +inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >& +LoadBalancerStatsResponse::rpcs_by_peer() const { + // @@protoc_insertion_point(field_map:connectrpc.conformance.LoadBalancerStatsResponse.rpcs_by_peer) + return _internal_rpcs_by_peer(); +} +inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >* +LoadBalancerStatsResponse::_internal_mutable_rpcs_by_peer() { + return _impl_.rpcs_by_peer_.MutableMap(); +} +inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >* +LoadBalancerStatsResponse::mutable_rpcs_by_peer() { + // @@protoc_insertion_point(field_mutable_map:connectrpc.conformance.LoadBalancerStatsResponse.rpcs_by_peer) + return _internal_mutable_rpcs_by_peer(); +} + +// int32 num_failures = 2 [json_name = "numFailures"]; +inline void LoadBalancerStatsResponse::clear_num_failures() { + _impl_.num_failures_ = 0; +} +inline ::int32_t LoadBalancerStatsResponse::num_failures() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.LoadBalancerStatsResponse.num_failures) + return _internal_num_failures(); +} +inline void LoadBalancerStatsResponse::set_num_failures(::int32_t value) { + _internal_set_num_failures(value); + // @@protoc_insertion_point(field_set:connectrpc.conformance.LoadBalancerStatsResponse.num_failures) +} +inline ::int32_t LoadBalancerStatsResponse::_internal_num_failures() const { + return _impl_.num_failures_; +} +inline void LoadBalancerStatsResponse::_internal_set_num_failures(::int32_t value) { + ; + _impl_.num_failures_ = value; +} + +// map rpcs_by_method = 3 [json_name = "rpcsByMethod"]; +inline int LoadBalancerStatsResponse::_internal_rpcs_by_method_size() const { + return _impl_.rpcs_by_method_.size(); +} +inline int LoadBalancerStatsResponse::rpcs_by_method_size() const { + return _internal_rpcs_by_method_size(); +} +inline void LoadBalancerStatsResponse::clear_rpcs_by_method() { + _impl_.rpcs_by_method_.Clear(); +} +inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeer >& +LoadBalancerStatsResponse::_internal_rpcs_by_method() const { + return _impl_.rpcs_by_method_.GetMap(); +} +inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeer >& +LoadBalancerStatsResponse::rpcs_by_method() const { + // @@protoc_insertion_point(field_map:connectrpc.conformance.LoadBalancerStatsResponse.rpcs_by_method) + return _internal_rpcs_by_method(); +} +inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeer >* +LoadBalancerStatsResponse::_internal_mutable_rpcs_by_method() { + return _impl_.rpcs_by_method_.MutableMap(); +} +inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::connectrpc::conformance::LoadBalancerStatsResponse_RpcsByPeer >* +LoadBalancerStatsResponse::mutable_rpcs_by_method() { + // @@protoc_insertion_point(field_mutable_map:connectrpc.conformance.LoadBalancerStatsResponse.rpcs_by_method) + return _internal_mutable_rpcs_by_method(); +} + +// ------------------------------------------------------------------- + +// LoadBalancerAccumulatedStatsRequest + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// LoadBalancerAccumulatedStatsResponse_MethodStats + +// int32 rpcs_started = 1 [json_name = "rpcsStarted"]; +inline void LoadBalancerAccumulatedStatsResponse_MethodStats::clear_rpcs_started() { + _impl_.rpcs_started_ = 0; +} +inline ::int32_t LoadBalancerAccumulatedStatsResponse_MethodStats::rpcs_started() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.MethodStats.rpcs_started) + return _internal_rpcs_started(); +} +inline void LoadBalancerAccumulatedStatsResponse_MethodStats::set_rpcs_started(::int32_t value) { + _internal_set_rpcs_started(value); + // @@protoc_insertion_point(field_set:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.MethodStats.rpcs_started) +} +inline ::int32_t LoadBalancerAccumulatedStatsResponse_MethodStats::_internal_rpcs_started() const { + return _impl_.rpcs_started_; +} +inline void LoadBalancerAccumulatedStatsResponse_MethodStats::_internal_set_rpcs_started(::int32_t value) { + ; + _impl_.rpcs_started_ = value; +} + +// map result = 2 [json_name = "result"]; +inline int LoadBalancerAccumulatedStatsResponse_MethodStats::_internal_result_size() const { + return _impl_.result_.size(); +} +inline int LoadBalancerAccumulatedStatsResponse_MethodStats::result_size() const { + return _internal_result_size(); +} +inline void LoadBalancerAccumulatedStatsResponse_MethodStats::clear_result() { + _impl_.result_.Clear(); +} +inline const ::PROTOBUF_NAMESPACE_ID::Map< ::int32_t, ::int32_t >& +LoadBalancerAccumulatedStatsResponse_MethodStats::_internal_result() const { + return _impl_.result_.GetMap(); +} +inline const ::PROTOBUF_NAMESPACE_ID::Map< ::int32_t, ::int32_t >& +LoadBalancerAccumulatedStatsResponse_MethodStats::result() const { + // @@protoc_insertion_point(field_map:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.MethodStats.result) + return _internal_result(); +} +inline ::PROTOBUF_NAMESPACE_ID::Map< ::int32_t, ::int32_t >* +LoadBalancerAccumulatedStatsResponse_MethodStats::_internal_mutable_result() { + return _impl_.result_.MutableMap(); +} +inline ::PROTOBUF_NAMESPACE_ID::Map< ::int32_t, ::int32_t >* +LoadBalancerAccumulatedStatsResponse_MethodStats::mutable_result() { + // @@protoc_insertion_point(field_mutable_map:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.MethodStats.result) + return _internal_mutable_result(); +} + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// LoadBalancerAccumulatedStatsResponse + +// map num_rpcs_started_by_method = 1 [json_name = "numRpcsStartedByMethod", deprecated = true]; +inline int LoadBalancerAccumulatedStatsResponse::_internal_num_rpcs_started_by_method_size() const { + return _impl_.num_rpcs_started_by_method_.size(); +} +inline int LoadBalancerAccumulatedStatsResponse::num_rpcs_started_by_method_size() const { + return _internal_num_rpcs_started_by_method_size(); +} +inline void LoadBalancerAccumulatedStatsResponse::clear_num_rpcs_started_by_method() { + _impl_.num_rpcs_started_by_method_.Clear(); +} +inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >& +LoadBalancerAccumulatedStatsResponse::_internal_num_rpcs_started_by_method() const { + return _impl_.num_rpcs_started_by_method_.GetMap(); +} +inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >& +LoadBalancerAccumulatedStatsResponse::num_rpcs_started_by_method() const { + // @@protoc_insertion_point(field_map:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.num_rpcs_started_by_method) + return _internal_num_rpcs_started_by_method(); +} +inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >* +LoadBalancerAccumulatedStatsResponse::_internal_mutable_num_rpcs_started_by_method() { + return _impl_.num_rpcs_started_by_method_.MutableMap(); +} +inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >* +LoadBalancerAccumulatedStatsResponse::mutable_num_rpcs_started_by_method() { + // @@protoc_insertion_point(field_mutable_map:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.num_rpcs_started_by_method) + return _internal_mutable_num_rpcs_started_by_method(); +} + +// map num_rpcs_succeeded_by_method = 2 [json_name = "numRpcsSucceededByMethod", deprecated = true]; +inline int LoadBalancerAccumulatedStatsResponse::_internal_num_rpcs_succeeded_by_method_size() const { + return _impl_.num_rpcs_succeeded_by_method_.size(); +} +inline int LoadBalancerAccumulatedStatsResponse::num_rpcs_succeeded_by_method_size() const { + return _internal_num_rpcs_succeeded_by_method_size(); +} +inline void LoadBalancerAccumulatedStatsResponse::clear_num_rpcs_succeeded_by_method() { + _impl_.num_rpcs_succeeded_by_method_.Clear(); +} +inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >& +LoadBalancerAccumulatedStatsResponse::_internal_num_rpcs_succeeded_by_method() const { + return _impl_.num_rpcs_succeeded_by_method_.GetMap(); +} +inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >& +LoadBalancerAccumulatedStatsResponse::num_rpcs_succeeded_by_method() const { + // @@protoc_insertion_point(field_map:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.num_rpcs_succeeded_by_method) + return _internal_num_rpcs_succeeded_by_method(); +} +inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >* +LoadBalancerAccumulatedStatsResponse::_internal_mutable_num_rpcs_succeeded_by_method() { + return _impl_.num_rpcs_succeeded_by_method_.MutableMap(); +} +inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >* +LoadBalancerAccumulatedStatsResponse::mutable_num_rpcs_succeeded_by_method() { + // @@protoc_insertion_point(field_mutable_map:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.num_rpcs_succeeded_by_method) + return _internal_mutable_num_rpcs_succeeded_by_method(); +} + +// map num_rpcs_failed_by_method = 3 [json_name = "numRpcsFailedByMethod", deprecated = true]; +inline int LoadBalancerAccumulatedStatsResponse::_internal_num_rpcs_failed_by_method_size() const { + return _impl_.num_rpcs_failed_by_method_.size(); +} +inline int LoadBalancerAccumulatedStatsResponse::num_rpcs_failed_by_method_size() const { + return _internal_num_rpcs_failed_by_method_size(); +} +inline void LoadBalancerAccumulatedStatsResponse::clear_num_rpcs_failed_by_method() { + _impl_.num_rpcs_failed_by_method_.Clear(); +} +inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >& +LoadBalancerAccumulatedStatsResponse::_internal_num_rpcs_failed_by_method() const { + return _impl_.num_rpcs_failed_by_method_.GetMap(); +} +inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >& +LoadBalancerAccumulatedStatsResponse::num_rpcs_failed_by_method() const { + // @@protoc_insertion_point(field_map:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.num_rpcs_failed_by_method) + return _internal_num_rpcs_failed_by_method(); +} +inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >* +LoadBalancerAccumulatedStatsResponse::_internal_mutable_num_rpcs_failed_by_method() { + return _impl_.num_rpcs_failed_by_method_.MutableMap(); +} +inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::int32_t >* +LoadBalancerAccumulatedStatsResponse::mutable_num_rpcs_failed_by_method() { + // @@protoc_insertion_point(field_mutable_map:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.num_rpcs_failed_by_method) + return _internal_mutable_num_rpcs_failed_by_method(); +} + +// map stats_per_method = 4 [json_name = "statsPerMethod"]; +inline int LoadBalancerAccumulatedStatsResponse::_internal_stats_per_method_size() const { + return _impl_.stats_per_method_.size(); +} +inline int LoadBalancerAccumulatedStatsResponse::stats_per_method_size() const { + return _internal_stats_per_method_size(); +} +inline void LoadBalancerAccumulatedStatsResponse::clear_stats_per_method() { + _impl_.stats_per_method_.Clear(); +} +inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_MethodStats >& +LoadBalancerAccumulatedStatsResponse::_internal_stats_per_method() const { + return _impl_.stats_per_method_.GetMap(); +} +inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_MethodStats >& +LoadBalancerAccumulatedStatsResponse::stats_per_method() const { + // @@protoc_insertion_point(field_map:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.stats_per_method) + return _internal_stats_per_method(); +} +inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_MethodStats >* +LoadBalancerAccumulatedStatsResponse::_internal_mutable_stats_per_method() { + return _impl_.stats_per_method_.MutableMap(); +} +inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse_MethodStats >* +LoadBalancerAccumulatedStatsResponse::mutable_stats_per_method() { + // @@protoc_insertion_point(field_mutable_map:connectrpc.conformance.LoadBalancerAccumulatedStatsResponse.stats_per_method) + return _internal_mutable_stats_per_method(); +} + +// ------------------------------------------------------------------- + +// ClientConfigureRequest_Metadata + +// .connectrpc.conformance.ClientConfigureRequest.RpcType type = 1 [json_name = "type"]; +inline void ClientConfigureRequest_Metadata::clear_type() { + _impl_.type_ = 0; +} +inline ::connectrpc::conformance::ClientConfigureRequest_RpcType ClientConfigureRequest_Metadata::type() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.ClientConfigureRequest.Metadata.type) + return _internal_type(); +} +inline void ClientConfigureRequest_Metadata::set_type(::connectrpc::conformance::ClientConfigureRequest_RpcType value) { + _internal_set_type(value); + // @@protoc_insertion_point(field_set:connectrpc.conformance.ClientConfigureRequest.Metadata.type) +} +inline ::connectrpc::conformance::ClientConfigureRequest_RpcType ClientConfigureRequest_Metadata::_internal_type() const { + return static_cast<::connectrpc::conformance::ClientConfigureRequest_RpcType>(_impl_.type_); +} +inline void ClientConfigureRequest_Metadata::_internal_set_type(::connectrpc::conformance::ClientConfigureRequest_RpcType value) { + ; + _impl_.type_ = value; +} + +// string key = 2 [json_name = "key"]; +inline void ClientConfigureRequest_Metadata::clear_key() { + _impl_.key_.ClearToEmpty(); +} +inline const std::string& ClientConfigureRequest_Metadata::key() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.ClientConfigureRequest.Metadata.key) + return _internal_key(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ClientConfigureRequest_Metadata::set_key(Arg_&& arg, + Args_... args) { + ; + _impl_.key_.Set(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:connectrpc.conformance.ClientConfigureRequest.Metadata.key) +} +inline std::string* ClientConfigureRequest_Metadata::mutable_key() { + std::string* _s = _internal_mutable_key(); + // @@protoc_insertion_point(field_mutable:connectrpc.conformance.ClientConfigureRequest.Metadata.key) + return _s; +} +inline const std::string& ClientConfigureRequest_Metadata::_internal_key() const { + return _impl_.key_.Get(); +} +inline void ClientConfigureRequest_Metadata::_internal_set_key(const std::string& value) { + ; + + + _impl_.key_.Set(value, GetArenaForAllocation()); +} +inline std::string* ClientConfigureRequest_Metadata::_internal_mutable_key() { + ; + return _impl_.key_.Mutable( GetArenaForAllocation()); +} +inline std::string* ClientConfigureRequest_Metadata::release_key() { + // @@protoc_insertion_point(field_release:connectrpc.conformance.ClientConfigureRequest.Metadata.key) + return _impl_.key_.Release(); +} +inline void ClientConfigureRequest_Metadata::set_allocated_key(std::string* value) { + _impl_.key_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.key_.IsDefault()) { + _impl_.key_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:connectrpc.conformance.ClientConfigureRequest.Metadata.key) +} + +// string value = 3 [json_name = "value"]; +inline void ClientConfigureRequest_Metadata::clear_value() { + _impl_.value_.ClearToEmpty(); +} +inline const std::string& ClientConfigureRequest_Metadata::value() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.ClientConfigureRequest.Metadata.value) + return _internal_value(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ClientConfigureRequest_Metadata::set_value(Arg_&& arg, + Args_... args) { + ; + _impl_.value_.Set(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:connectrpc.conformance.ClientConfigureRequest.Metadata.value) +} +inline std::string* ClientConfigureRequest_Metadata::mutable_value() { + std::string* _s = _internal_mutable_value(); + // @@protoc_insertion_point(field_mutable:connectrpc.conformance.ClientConfigureRequest.Metadata.value) + return _s; +} +inline const std::string& ClientConfigureRequest_Metadata::_internal_value() const { + return _impl_.value_.Get(); +} +inline void ClientConfigureRequest_Metadata::_internal_set_value(const std::string& value) { + ; + + + _impl_.value_.Set(value, GetArenaForAllocation()); +} +inline std::string* ClientConfigureRequest_Metadata::_internal_mutable_value() { + ; + return _impl_.value_.Mutable( GetArenaForAllocation()); +} +inline std::string* ClientConfigureRequest_Metadata::release_value() { + // @@protoc_insertion_point(field_release:connectrpc.conformance.ClientConfigureRequest.Metadata.value) + return _impl_.value_.Release(); +} +inline void ClientConfigureRequest_Metadata::set_allocated_value(std::string* value) { + _impl_.value_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.value_.IsDefault()) { + _impl_.value_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:connectrpc.conformance.ClientConfigureRequest.Metadata.value) +} + +// ------------------------------------------------------------------- + +// ClientConfigureRequest + +// repeated .connectrpc.conformance.ClientConfigureRequest.RpcType types = 1 [json_name = "types"]; +inline int ClientConfigureRequest::_internal_types_size() const { + return _impl_.types_.size(); +} +inline int ClientConfigureRequest::types_size() const { + return _internal_types_size(); +} +inline void ClientConfigureRequest::clear_types() { + _internal_mutable_types()->Clear(); +} +inline ::connectrpc::conformance::ClientConfigureRequest_RpcType ClientConfigureRequest::types(int index) const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.ClientConfigureRequest.types) + return _internal_types(index); +} +inline void ClientConfigureRequest::set_types(int index, ::connectrpc::conformance::ClientConfigureRequest_RpcType value) { + _internal_mutable_types()->Set(index, value); + // @@protoc_insertion_point(field_set:connectrpc.conformance.ClientConfigureRequest.types) +} +inline void ClientConfigureRequest::add_types(::connectrpc::conformance::ClientConfigureRequest_RpcType value) { + _internal_add_types(value); + // @@protoc_insertion_point(field_add:connectrpc.conformance.ClientConfigureRequest.types) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField& ClientConfigureRequest::types() const { + // @@protoc_insertion_point(field_list:connectrpc.conformance.ClientConfigureRequest.types) + return _internal_types(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* ClientConfigureRequest::mutable_types() { + // @@protoc_insertion_point(field_mutable_list:connectrpc.conformance.ClientConfigureRequest.types) + return _internal_mutable_types(); +} +inline ::connectrpc::conformance::ClientConfigureRequest_RpcType ClientConfigureRequest::_internal_types(int index) const { + return static_cast<::connectrpc::conformance::ClientConfigureRequest_RpcType>(_internal_types().Get(index)); +} +inline void ClientConfigureRequest::_internal_add_types(::connectrpc::conformance::ClientConfigureRequest_RpcType value) { + _internal_mutable_types()->Add(value); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField& ClientConfigureRequest::_internal_types() const { + return _impl_.types_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* ClientConfigureRequest::_internal_mutable_types() { + return &_impl_.types_; +} + +// repeated .connectrpc.conformance.ClientConfigureRequest.Metadata metadata = 2 [json_name = "metadata"]; +inline int ClientConfigureRequest::_internal_metadata_size() const { + return _impl_.metadata_.size(); +} +inline int ClientConfigureRequest::metadata_size() const { + return _internal_metadata_size(); +} +inline void ClientConfigureRequest::clear_metadata() { + _internal_mutable_metadata()->Clear(); +} +inline ::connectrpc::conformance::ClientConfigureRequest_Metadata* ClientConfigureRequest::mutable_metadata(int index) { + // @@protoc_insertion_point(field_mutable:connectrpc.conformance.ClientConfigureRequest.metadata) + return _internal_mutable_metadata()->Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::connectrpc::conformance::ClientConfigureRequest_Metadata >* +ClientConfigureRequest::mutable_metadata() { + // @@protoc_insertion_point(field_mutable_list:connectrpc.conformance.ClientConfigureRequest.metadata) + return _internal_mutable_metadata(); +} +inline const ::connectrpc::conformance::ClientConfigureRequest_Metadata& ClientConfigureRequest::_internal_metadata(int index) const { + return _internal_metadata().Get(index); +} +inline const ::connectrpc::conformance::ClientConfigureRequest_Metadata& ClientConfigureRequest::metadata(int index) const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.ClientConfigureRequest.metadata) + return _internal_metadata(index); +} +inline ::connectrpc::conformance::ClientConfigureRequest_Metadata* ClientConfigureRequest::_internal_add_metadata() { + return _internal_mutable_metadata()->Add(); +} +inline ::connectrpc::conformance::ClientConfigureRequest_Metadata* ClientConfigureRequest::add_metadata() { + ::connectrpc::conformance::ClientConfigureRequest_Metadata* _add = _internal_add_metadata(); + // @@protoc_insertion_point(field_add:connectrpc.conformance.ClientConfigureRequest.metadata) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::connectrpc::conformance::ClientConfigureRequest_Metadata >& +ClientConfigureRequest::metadata() const { + // @@protoc_insertion_point(field_list:connectrpc.conformance.ClientConfigureRequest.metadata) + return _internal_metadata(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::connectrpc::conformance::ClientConfigureRequest_Metadata>& +ClientConfigureRequest::_internal_metadata() const { + return _impl_.metadata_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::connectrpc::conformance::ClientConfigureRequest_Metadata>* +ClientConfigureRequest::_internal_mutable_metadata() { + return &_impl_.metadata_; +} + +// int32 timeout_sec = 3 [json_name = "timeoutSec"]; +inline void ClientConfigureRequest::clear_timeout_sec() { + _impl_.timeout_sec_ = 0; +} +inline ::int32_t ClientConfigureRequest::timeout_sec() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.ClientConfigureRequest.timeout_sec) + return _internal_timeout_sec(); +} +inline void ClientConfigureRequest::set_timeout_sec(::int32_t value) { + _internal_set_timeout_sec(value); + // @@protoc_insertion_point(field_set:connectrpc.conformance.ClientConfigureRequest.timeout_sec) +} +inline ::int32_t ClientConfigureRequest::_internal_timeout_sec() const { + return _impl_.timeout_sec_; +} +inline void ClientConfigureRequest::_internal_set_timeout_sec(::int32_t value) { + ; + _impl_.timeout_sec_ = value; +} + +// ------------------------------------------------------------------- + +// ClientConfigureResponse + +// ------------------------------------------------------------------- + +// ErrorDetail + +// string reason = 1 [json_name = "reason"]; +inline void ErrorDetail::clear_reason() { + _impl_.reason_.ClearToEmpty(); +} +inline const std::string& ErrorDetail::reason() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.ErrorDetail.reason) + return _internal_reason(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ErrorDetail::set_reason(Arg_&& arg, + Args_... args) { + ; + _impl_.reason_.Set(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:connectrpc.conformance.ErrorDetail.reason) +} +inline std::string* ErrorDetail::mutable_reason() { + std::string* _s = _internal_mutable_reason(); + // @@protoc_insertion_point(field_mutable:connectrpc.conformance.ErrorDetail.reason) + return _s; +} +inline const std::string& ErrorDetail::_internal_reason() const { + return _impl_.reason_.Get(); +} +inline void ErrorDetail::_internal_set_reason(const std::string& value) { + ; + + + _impl_.reason_.Set(value, GetArenaForAllocation()); +} +inline std::string* ErrorDetail::_internal_mutable_reason() { + ; + return _impl_.reason_.Mutable( GetArenaForAllocation()); +} +inline std::string* ErrorDetail::release_reason() { + // @@protoc_insertion_point(field_release:connectrpc.conformance.ErrorDetail.reason) + return _impl_.reason_.Release(); +} +inline void ErrorDetail::set_allocated_reason(std::string* value) { + _impl_.reason_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.reason_.IsDefault()) { + _impl_.reason_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:connectrpc.conformance.ErrorDetail.reason) +} + +// string domain = 2 [json_name = "domain"]; +inline void ErrorDetail::clear_domain() { + _impl_.domain_.ClearToEmpty(); +} +inline const std::string& ErrorDetail::domain() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.ErrorDetail.domain) + return _internal_domain(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ErrorDetail::set_domain(Arg_&& arg, + Args_... args) { + ; + _impl_.domain_.Set(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:connectrpc.conformance.ErrorDetail.domain) +} +inline std::string* ErrorDetail::mutable_domain() { + std::string* _s = _internal_mutable_domain(); + // @@protoc_insertion_point(field_mutable:connectrpc.conformance.ErrorDetail.domain) + return _s; +} +inline const std::string& ErrorDetail::_internal_domain() const { + return _impl_.domain_.Get(); +} +inline void ErrorDetail::_internal_set_domain(const std::string& value) { + ; + + + _impl_.domain_.Set(value, GetArenaForAllocation()); +} +inline std::string* ErrorDetail::_internal_mutable_domain() { + ; + return _impl_.domain_.Mutable( GetArenaForAllocation()); +} +inline std::string* ErrorDetail::release_domain() { + // @@protoc_insertion_point(field_release:connectrpc.conformance.ErrorDetail.domain) + return _impl_.domain_.Release(); +} +inline void ErrorDetail::set_allocated_domain(std::string* value) { + _impl_.domain_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.domain_.IsDefault()) { + _impl_.domain_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:connectrpc.conformance.ErrorDetail.domain) +} + +// ------------------------------------------------------------------- + +// ErrorStatus + +// int32 code = 1 [json_name = "code"]; +inline void ErrorStatus::clear_code() { + _impl_.code_ = 0; +} +inline ::int32_t ErrorStatus::code() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.ErrorStatus.code) + return _internal_code(); +} +inline void ErrorStatus::set_code(::int32_t value) { + _internal_set_code(value); + // @@protoc_insertion_point(field_set:connectrpc.conformance.ErrorStatus.code) +} +inline ::int32_t ErrorStatus::_internal_code() const { + return _impl_.code_; +} +inline void ErrorStatus::_internal_set_code(::int32_t value) { + ; + _impl_.code_ = value; +} + +// string message = 2 [json_name = "message"]; +inline void ErrorStatus::clear_message() { + _impl_.message_.ClearToEmpty(); +} +inline const std::string& ErrorStatus::message() const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.ErrorStatus.message) + return _internal_message(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ErrorStatus::set_message(Arg_&& arg, + Args_... args) { + ; + _impl_.message_.Set(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:connectrpc.conformance.ErrorStatus.message) +} +inline std::string* ErrorStatus::mutable_message() { + std::string* _s = _internal_mutable_message(); + // @@protoc_insertion_point(field_mutable:connectrpc.conformance.ErrorStatus.message) + return _s; +} +inline const std::string& ErrorStatus::_internal_message() const { + return _impl_.message_.Get(); +} +inline void ErrorStatus::_internal_set_message(const std::string& value) { + ; + + + _impl_.message_.Set(value, GetArenaForAllocation()); +} +inline std::string* ErrorStatus::_internal_mutable_message() { + ; + return _impl_.message_.Mutable( GetArenaForAllocation()); +} +inline std::string* ErrorStatus::release_message() { + // @@protoc_insertion_point(field_release:connectrpc.conformance.ErrorStatus.message) + return _impl_.message_.Release(); +} +inline void ErrorStatus::set_allocated_message(std::string* value) { + _impl_.message_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.message_.IsDefault()) { + _impl_.message_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:connectrpc.conformance.ErrorStatus.message) +} + +// repeated .google.protobuf.Any details = 3 [json_name = "details"]; +inline int ErrorStatus::_internal_details_size() const { + return _impl_.details_.size(); +} +inline int ErrorStatus::details_size() const { + return _internal_details_size(); +} +inline ::PROTOBUF_NAMESPACE_ID::Any* ErrorStatus::mutable_details(int index) { + // @@protoc_insertion_point(field_mutable:connectrpc.conformance.ErrorStatus.details) + return _internal_mutable_details()->Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Any >* +ErrorStatus::mutable_details() { + // @@protoc_insertion_point(field_mutable_list:connectrpc.conformance.ErrorStatus.details) + return _internal_mutable_details(); +} +inline const ::PROTOBUF_NAMESPACE_ID::Any& ErrorStatus::_internal_details(int index) const { + return _internal_details().Get(index); +} +inline const ::PROTOBUF_NAMESPACE_ID::Any& ErrorStatus::details(int index) const { + // @@protoc_insertion_point(field_get:connectrpc.conformance.ErrorStatus.details) + return _internal_details(index); +} +inline ::PROTOBUF_NAMESPACE_ID::Any* ErrorStatus::_internal_add_details() { + return _internal_mutable_details()->Add(); +} +inline ::PROTOBUF_NAMESPACE_ID::Any* ErrorStatus::add_details() { + ::PROTOBUF_NAMESPACE_ID::Any* _add = _internal_add_details(); + // @@protoc_insertion_point(field_add:connectrpc.conformance.ErrorStatus.details) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Any >& +ErrorStatus::details() const { + // @@protoc_insertion_point(field_list:connectrpc.conformance.ErrorStatus.details) + return _internal_details(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Any>& +ErrorStatus::_internal_details() const { + return _impl_.details_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Any>* +ErrorStatus::_internal_mutable_details() { + return &_impl_.details_; +} + +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif // __GNUC__ + +// @@protoc_insertion_point(namespace_scope) +} // namespace conformance +} // namespace connectrpc + + +PROTOBUF_NAMESPACE_OPEN + +template <> +struct is_proto_enum<::connectrpc::conformance::ClientConfigureRequest_RpcType> : std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor<::connectrpc::conformance::ClientConfigureRequest_RpcType>() { + return ::connectrpc::conformance::ClientConfigureRequest_RpcType_descriptor(); +} +template <> +struct is_proto_enum<::connectrpc::conformance::PayloadType> : std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor<::connectrpc::conformance::PayloadType>() { + return ::connectrpc::conformance::PayloadType_descriptor(); +} +template <> +struct is_proto_enum<::connectrpc::conformance::GrpclbRouteType> : std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor<::connectrpc::conformance::GrpclbRouteType>() { + return ::connectrpc::conformance::GrpclbRouteType_descriptor(); +} + +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) + +#include "google/protobuf/port_undef.inc" + +#endif // GOOGLE_PROTOBUF_INCLUDED_connectrpc_2fconformance_2fmessages_2eproto_2epb_2eh diff --git a/cc/gen/connectrpc/conformance/test.grpc.pb.cc b/cc/gen/connectrpc/conformance/test.grpc.pb.cc new file mode 100644 index 00000000..af7e7456 --- /dev/null +++ b/cc/gen/connectrpc/conformance/test.grpc.pb.cc @@ -0,0 +1,944 @@ +// Copyright 2022 Buf Technologies, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Generated by the gRPC C++ plugin. +// If you make any local change, they will be lost. +// source: connectrpc/conformance/test.proto + +#include "connectrpc/conformance/test.pb.h" +#include "connectrpc/conformance/test.grpc.pb.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +namespace connectrpc { +namespace conformance { + +static const char* TestService_method_names[] = { + "/connectrpc.conformance.TestService/EmptyCall", + "/connectrpc.conformance.TestService/UnaryCall", + "/connectrpc.conformance.TestService/FailUnaryCall", + "/connectrpc.conformance.TestService/CacheableUnaryCall", + "/connectrpc.conformance.TestService/StreamingOutputCall", + "/connectrpc.conformance.TestService/FailStreamingOutputCall", + "/connectrpc.conformance.TestService/StreamingInputCall", + "/connectrpc.conformance.TestService/FullDuplexCall", + "/connectrpc.conformance.TestService/HalfDuplexCall", + "/connectrpc.conformance.TestService/UnimplementedCall", + "/connectrpc.conformance.TestService/UnimplementedStreamingOutputCall", +}; + +std::unique_ptr< TestService::Stub> TestService::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) { + (void)options; + std::unique_ptr< TestService::Stub> stub(new TestService::Stub(channel, options)); + return stub; +} + +TestService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) + : channel_(channel), rpcmethod_EmptyCall_(TestService_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_UnaryCall_(TestService_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_FailUnaryCall_(TestService_method_names[2], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_CacheableUnaryCall_(TestService_method_names[3], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_StreamingOutputCall_(TestService_method_names[4], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel) + , rpcmethod_FailStreamingOutputCall_(TestService_method_names[5], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel) + , rpcmethod_StreamingInputCall_(TestService_method_names[6], options.suffix_for_stats(),::grpc::internal::RpcMethod::CLIENT_STREAMING, channel) + , rpcmethod_FullDuplexCall_(TestService_method_names[7], options.suffix_for_stats(),::grpc::internal::RpcMethod::BIDI_STREAMING, channel) + , rpcmethod_HalfDuplexCall_(TestService_method_names[8], options.suffix_for_stats(),::grpc::internal::RpcMethod::BIDI_STREAMING, channel) + , rpcmethod_UnimplementedCall_(TestService_method_names[9], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_UnimplementedStreamingOutputCall_(TestService_method_names[10], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel) + {} + +::grpc::Status TestService::Stub::EmptyCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::google::protobuf::Empty* response) { + return ::grpc::internal::BlockingUnaryCall< ::google::protobuf::Empty, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_EmptyCall_, context, request, response); +} + +void TestService::Stub::async::EmptyCall(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::google::protobuf::Empty, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_EmptyCall_, context, request, response, std::move(f)); +} + +void TestService::Stub::async::EmptyCall(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_EmptyCall_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* TestService::Stub::PrepareAsyncEmptyCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_EmptyCall_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* TestService::Stub::AsyncEmptyCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncEmptyCallRaw(context, request, cq); + result->StartCall(); + return result; +} + +::grpc::Status TestService::Stub::UnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::connectrpc::conformance::SimpleResponse* response) { + return ::grpc::internal::BlockingUnaryCall< ::connectrpc::conformance::SimpleRequest, ::connectrpc::conformance::SimpleResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_UnaryCall_, context, request, response); +} + +void TestService::Stub::async::UnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest* request, ::connectrpc::conformance::SimpleResponse* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::connectrpc::conformance::SimpleRequest, ::connectrpc::conformance::SimpleResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_UnaryCall_, context, request, response, std::move(f)); +} + +void TestService::Stub::async::UnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest* request, ::connectrpc::conformance::SimpleResponse* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_UnaryCall_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::SimpleResponse>* TestService::Stub::PrepareAsyncUnaryCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::connectrpc::conformance::SimpleResponse, ::connectrpc::conformance::SimpleRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_UnaryCall_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::SimpleResponse>* TestService::Stub::AsyncUnaryCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncUnaryCallRaw(context, request, cq); + result->StartCall(); + return result; +} + +::grpc::Status TestService::Stub::FailUnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::connectrpc::conformance::SimpleResponse* response) { + return ::grpc::internal::BlockingUnaryCall< ::connectrpc::conformance::SimpleRequest, ::connectrpc::conformance::SimpleResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_FailUnaryCall_, context, request, response); +} + +void TestService::Stub::async::FailUnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest* request, ::connectrpc::conformance::SimpleResponse* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::connectrpc::conformance::SimpleRequest, ::connectrpc::conformance::SimpleResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_FailUnaryCall_, context, request, response, std::move(f)); +} + +void TestService::Stub::async::FailUnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest* request, ::connectrpc::conformance::SimpleResponse* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_FailUnaryCall_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::SimpleResponse>* TestService::Stub::PrepareAsyncFailUnaryCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::connectrpc::conformance::SimpleResponse, ::connectrpc::conformance::SimpleRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_FailUnaryCall_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::SimpleResponse>* TestService::Stub::AsyncFailUnaryCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncFailUnaryCallRaw(context, request, cq); + result->StartCall(); + return result; +} + +::grpc::Status TestService::Stub::CacheableUnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::connectrpc::conformance::SimpleResponse* response) { + return ::grpc::internal::BlockingUnaryCall< ::connectrpc::conformance::SimpleRequest, ::connectrpc::conformance::SimpleResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_CacheableUnaryCall_, context, request, response); +} + +void TestService::Stub::async::CacheableUnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest* request, ::connectrpc::conformance::SimpleResponse* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::connectrpc::conformance::SimpleRequest, ::connectrpc::conformance::SimpleResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_CacheableUnaryCall_, context, request, response, std::move(f)); +} + +void TestService::Stub::async::CacheableUnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest* request, ::connectrpc::conformance::SimpleResponse* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_CacheableUnaryCall_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::SimpleResponse>* TestService::Stub::PrepareAsyncCacheableUnaryCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::connectrpc::conformance::SimpleResponse, ::connectrpc::conformance::SimpleRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_CacheableUnaryCall_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::SimpleResponse>* TestService::Stub::AsyncCacheableUnaryCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncCacheableUnaryCallRaw(context, request, cq); + result->StartCall(); + return result; +} + +::grpc::ClientReader< ::connectrpc::conformance::StreamingOutputCallResponse>* TestService::Stub::StreamingOutputCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest& request) { + return ::grpc::internal::ClientReaderFactory< ::connectrpc::conformance::StreamingOutputCallResponse>::Create(channel_.get(), rpcmethod_StreamingOutputCall_, context, request); +} + +void TestService::Stub::async::StreamingOutputCall(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest* request, ::grpc::ClientReadReactor< ::connectrpc::conformance::StreamingOutputCallResponse>* reactor) { + ::grpc::internal::ClientCallbackReaderFactory< ::connectrpc::conformance::StreamingOutputCallResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_StreamingOutputCall_, context, request, reactor); +} + +::grpc::ClientAsyncReader< ::connectrpc::conformance::StreamingOutputCallResponse>* TestService::Stub::AsyncStreamingOutputCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest& request, ::grpc::CompletionQueue* cq, void* tag) { + return ::grpc::internal::ClientAsyncReaderFactory< ::connectrpc::conformance::StreamingOutputCallResponse>::Create(channel_.get(), cq, rpcmethod_StreamingOutputCall_, context, request, true, tag); +} + +::grpc::ClientAsyncReader< ::connectrpc::conformance::StreamingOutputCallResponse>* TestService::Stub::PrepareAsyncStreamingOutputCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncReaderFactory< ::connectrpc::conformance::StreamingOutputCallResponse>::Create(channel_.get(), cq, rpcmethod_StreamingOutputCall_, context, request, false, nullptr); +} + +::grpc::ClientReader< ::connectrpc::conformance::StreamingOutputCallResponse>* TestService::Stub::FailStreamingOutputCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest& request) { + return ::grpc::internal::ClientReaderFactory< ::connectrpc::conformance::StreamingOutputCallResponse>::Create(channel_.get(), rpcmethod_FailStreamingOutputCall_, context, request); +} + +void TestService::Stub::async::FailStreamingOutputCall(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest* request, ::grpc::ClientReadReactor< ::connectrpc::conformance::StreamingOutputCallResponse>* reactor) { + ::grpc::internal::ClientCallbackReaderFactory< ::connectrpc::conformance::StreamingOutputCallResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_FailStreamingOutputCall_, context, request, reactor); +} + +::grpc::ClientAsyncReader< ::connectrpc::conformance::StreamingOutputCallResponse>* TestService::Stub::AsyncFailStreamingOutputCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest& request, ::grpc::CompletionQueue* cq, void* tag) { + return ::grpc::internal::ClientAsyncReaderFactory< ::connectrpc::conformance::StreamingOutputCallResponse>::Create(channel_.get(), cq, rpcmethod_FailStreamingOutputCall_, context, request, true, tag); +} + +::grpc::ClientAsyncReader< ::connectrpc::conformance::StreamingOutputCallResponse>* TestService::Stub::PrepareAsyncFailStreamingOutputCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncReaderFactory< ::connectrpc::conformance::StreamingOutputCallResponse>::Create(channel_.get(), cq, rpcmethod_FailStreamingOutputCall_, context, request, false, nullptr); +} + +::grpc::ClientWriter< ::connectrpc::conformance::StreamingInputCallRequest>* TestService::Stub::StreamingInputCallRaw(::grpc::ClientContext* context, ::connectrpc::conformance::StreamingInputCallResponse* response) { + return ::grpc::internal::ClientWriterFactory< ::connectrpc::conformance::StreamingInputCallRequest>::Create(channel_.get(), rpcmethod_StreamingInputCall_, context, response); +} + +void TestService::Stub::async::StreamingInputCall(::grpc::ClientContext* context, ::connectrpc::conformance::StreamingInputCallResponse* response, ::grpc::ClientWriteReactor< ::connectrpc::conformance::StreamingInputCallRequest>* reactor) { + ::grpc::internal::ClientCallbackWriterFactory< ::connectrpc::conformance::StreamingInputCallRequest>::Create(stub_->channel_.get(), stub_->rpcmethod_StreamingInputCall_, context, response, reactor); +} + +::grpc::ClientAsyncWriter< ::connectrpc::conformance::StreamingInputCallRequest>* TestService::Stub::AsyncStreamingInputCallRaw(::grpc::ClientContext* context, ::connectrpc::conformance::StreamingInputCallResponse* response, ::grpc::CompletionQueue* cq, void* tag) { + return ::grpc::internal::ClientAsyncWriterFactory< ::connectrpc::conformance::StreamingInputCallRequest>::Create(channel_.get(), cq, rpcmethod_StreamingInputCall_, context, response, true, tag); +} + +::grpc::ClientAsyncWriter< ::connectrpc::conformance::StreamingInputCallRequest>* TestService::Stub::PrepareAsyncStreamingInputCallRaw(::grpc::ClientContext* context, ::connectrpc::conformance::StreamingInputCallResponse* response, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncWriterFactory< ::connectrpc::conformance::StreamingInputCallRequest>::Create(channel_.get(), cq, rpcmethod_StreamingInputCall_, context, response, false, nullptr); +} + +::grpc::ClientReaderWriter< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>* TestService::Stub::FullDuplexCallRaw(::grpc::ClientContext* context) { + return ::grpc::internal::ClientReaderWriterFactory< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>::Create(channel_.get(), rpcmethod_FullDuplexCall_, context); +} + +void TestService::Stub::async::FullDuplexCall(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::connectrpc::conformance::StreamingOutputCallRequest,::connectrpc::conformance::StreamingOutputCallResponse>* reactor) { + ::grpc::internal::ClientCallbackReaderWriterFactory< ::connectrpc::conformance::StreamingOutputCallRequest,::connectrpc::conformance::StreamingOutputCallResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_FullDuplexCall_, context, reactor); +} + +::grpc::ClientAsyncReaderWriter< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>* TestService::Stub::AsyncFullDuplexCallRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { + return ::grpc::internal::ClientAsyncReaderWriterFactory< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>::Create(channel_.get(), cq, rpcmethod_FullDuplexCall_, context, true, tag); +} + +::grpc::ClientAsyncReaderWriter< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>* TestService::Stub::PrepareAsyncFullDuplexCallRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncReaderWriterFactory< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>::Create(channel_.get(), cq, rpcmethod_FullDuplexCall_, context, false, nullptr); +} + +::grpc::ClientReaderWriter< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>* TestService::Stub::HalfDuplexCallRaw(::grpc::ClientContext* context) { + return ::grpc::internal::ClientReaderWriterFactory< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>::Create(channel_.get(), rpcmethod_HalfDuplexCall_, context); +} + +void TestService::Stub::async::HalfDuplexCall(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::connectrpc::conformance::StreamingOutputCallRequest,::connectrpc::conformance::StreamingOutputCallResponse>* reactor) { + ::grpc::internal::ClientCallbackReaderWriterFactory< ::connectrpc::conformance::StreamingOutputCallRequest,::connectrpc::conformance::StreamingOutputCallResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_HalfDuplexCall_, context, reactor); +} + +::grpc::ClientAsyncReaderWriter< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>* TestService::Stub::AsyncHalfDuplexCallRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { + return ::grpc::internal::ClientAsyncReaderWriterFactory< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>::Create(channel_.get(), cq, rpcmethod_HalfDuplexCall_, context, true, tag); +} + +::grpc::ClientAsyncReaderWriter< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>* TestService::Stub::PrepareAsyncHalfDuplexCallRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncReaderWriterFactory< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>::Create(channel_.get(), cq, rpcmethod_HalfDuplexCall_, context, false, nullptr); +} + +::grpc::Status TestService::Stub::UnimplementedCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::google::protobuf::Empty* response) { + return ::grpc::internal::BlockingUnaryCall< ::google::protobuf::Empty, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_UnimplementedCall_, context, request, response); +} + +void TestService::Stub::async::UnimplementedCall(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::google::protobuf::Empty, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_UnimplementedCall_, context, request, response, std::move(f)); +} + +void TestService::Stub::async::UnimplementedCall(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_UnimplementedCall_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* TestService::Stub::PrepareAsyncUnimplementedCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_UnimplementedCall_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* TestService::Stub::AsyncUnimplementedCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncUnimplementedCallRaw(context, request, cq); + result->StartCall(); + return result; +} + +::grpc::ClientReader< ::google::protobuf::Empty>* TestService::Stub::UnimplementedStreamingOutputCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request) { + return ::grpc::internal::ClientReaderFactory< ::google::protobuf::Empty>::Create(channel_.get(), rpcmethod_UnimplementedStreamingOutputCall_, context, request); +} + +void TestService::Stub::async::UnimplementedStreamingOutputCall(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::grpc::ClientReadReactor< ::google::protobuf::Empty>* reactor) { + ::grpc::internal::ClientCallbackReaderFactory< ::google::protobuf::Empty>::Create(stub_->channel_.get(), stub_->rpcmethod_UnimplementedStreamingOutputCall_, context, request, reactor); +} + +::grpc::ClientAsyncReader< ::google::protobuf::Empty>* TestService::Stub::AsyncUnimplementedStreamingOutputCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq, void* tag) { + return ::grpc::internal::ClientAsyncReaderFactory< ::google::protobuf::Empty>::Create(channel_.get(), cq, rpcmethod_UnimplementedStreamingOutputCall_, context, request, true, tag); +} + +::grpc::ClientAsyncReader< ::google::protobuf::Empty>* TestService::Stub::PrepareAsyncUnimplementedStreamingOutputCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncReaderFactory< ::google::protobuf::Empty>::Create(channel_.get(), cq, rpcmethod_UnimplementedStreamingOutputCall_, context, request, false, nullptr); +} + +TestService::Service::Service() { + AddMethod(new ::grpc::internal::RpcServiceMethod( + TestService_method_names[0], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< TestService::Service, ::google::protobuf::Empty, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](TestService::Service* service, + ::grpc::ServerContext* ctx, + const ::google::protobuf::Empty* req, + ::google::protobuf::Empty* resp) { + return service->EmptyCall(ctx, req, resp); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + TestService_method_names[1], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< TestService::Service, ::connectrpc::conformance::SimpleRequest, ::connectrpc::conformance::SimpleResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](TestService::Service* service, + ::grpc::ServerContext* ctx, + const ::connectrpc::conformance::SimpleRequest* req, + ::connectrpc::conformance::SimpleResponse* resp) { + return service->UnaryCall(ctx, req, resp); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + TestService_method_names[2], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< TestService::Service, ::connectrpc::conformance::SimpleRequest, ::connectrpc::conformance::SimpleResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](TestService::Service* service, + ::grpc::ServerContext* ctx, + const ::connectrpc::conformance::SimpleRequest* req, + ::connectrpc::conformance::SimpleResponse* resp) { + return service->FailUnaryCall(ctx, req, resp); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + TestService_method_names[3], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< TestService::Service, ::connectrpc::conformance::SimpleRequest, ::connectrpc::conformance::SimpleResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](TestService::Service* service, + ::grpc::ServerContext* ctx, + const ::connectrpc::conformance::SimpleRequest* req, + ::connectrpc::conformance::SimpleResponse* resp) { + return service->CacheableUnaryCall(ctx, req, resp); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + TestService_method_names[4], + ::grpc::internal::RpcMethod::SERVER_STREAMING, + new ::grpc::internal::ServerStreamingHandler< TestService::Service, ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>( + [](TestService::Service* service, + ::grpc::ServerContext* ctx, + const ::connectrpc::conformance::StreamingOutputCallRequest* req, + ::grpc::ServerWriter<::connectrpc::conformance::StreamingOutputCallResponse>* writer) { + return service->StreamingOutputCall(ctx, req, writer); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + TestService_method_names[5], + ::grpc::internal::RpcMethod::SERVER_STREAMING, + new ::grpc::internal::ServerStreamingHandler< TestService::Service, ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>( + [](TestService::Service* service, + ::grpc::ServerContext* ctx, + const ::connectrpc::conformance::StreamingOutputCallRequest* req, + ::grpc::ServerWriter<::connectrpc::conformance::StreamingOutputCallResponse>* writer) { + return service->FailStreamingOutputCall(ctx, req, writer); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + TestService_method_names[6], + ::grpc::internal::RpcMethod::CLIENT_STREAMING, + new ::grpc::internal::ClientStreamingHandler< TestService::Service, ::connectrpc::conformance::StreamingInputCallRequest, ::connectrpc::conformance::StreamingInputCallResponse>( + [](TestService::Service* service, + ::grpc::ServerContext* ctx, + ::grpc::ServerReader<::connectrpc::conformance::StreamingInputCallRequest>* reader, + ::connectrpc::conformance::StreamingInputCallResponse* resp) { + return service->StreamingInputCall(ctx, reader, resp); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + TestService_method_names[7], + ::grpc::internal::RpcMethod::BIDI_STREAMING, + new ::grpc::internal::BidiStreamingHandler< TestService::Service, ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>( + [](TestService::Service* service, + ::grpc::ServerContext* ctx, + ::grpc::ServerReaderWriter<::connectrpc::conformance::StreamingOutputCallResponse, + ::connectrpc::conformance::StreamingOutputCallRequest>* stream) { + return service->FullDuplexCall(ctx, stream); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + TestService_method_names[8], + ::grpc::internal::RpcMethod::BIDI_STREAMING, + new ::grpc::internal::BidiStreamingHandler< TestService::Service, ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>( + [](TestService::Service* service, + ::grpc::ServerContext* ctx, + ::grpc::ServerReaderWriter<::connectrpc::conformance::StreamingOutputCallResponse, + ::connectrpc::conformance::StreamingOutputCallRequest>* stream) { + return service->HalfDuplexCall(ctx, stream); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + TestService_method_names[9], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< TestService::Service, ::google::protobuf::Empty, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](TestService::Service* service, + ::grpc::ServerContext* ctx, + const ::google::protobuf::Empty* req, + ::google::protobuf::Empty* resp) { + return service->UnimplementedCall(ctx, req, resp); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + TestService_method_names[10], + ::grpc::internal::RpcMethod::SERVER_STREAMING, + new ::grpc::internal::ServerStreamingHandler< TestService::Service, ::google::protobuf::Empty, ::google::protobuf::Empty>( + [](TestService::Service* service, + ::grpc::ServerContext* ctx, + const ::google::protobuf::Empty* req, + ::grpc::ServerWriter<::google::protobuf::Empty>* writer) { + return service->UnimplementedStreamingOutputCall(ctx, req, writer); + }, this))); +} + +TestService::Service::~Service() { +} + +::grpc::Status TestService::Service::EmptyCall(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status TestService::Service::UnaryCall(::grpc::ServerContext* context, const ::connectrpc::conformance::SimpleRequest* request, ::connectrpc::conformance::SimpleResponse* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status TestService::Service::FailUnaryCall(::grpc::ServerContext* context, const ::connectrpc::conformance::SimpleRequest* request, ::connectrpc::conformance::SimpleResponse* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status TestService::Service::CacheableUnaryCall(::grpc::ServerContext* context, const ::connectrpc::conformance::SimpleRequest* request, ::connectrpc::conformance::SimpleResponse* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status TestService::Service::StreamingOutputCall(::grpc::ServerContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest* request, ::grpc::ServerWriter< ::connectrpc::conformance::StreamingOutputCallResponse>* writer) { + (void) context; + (void) request; + (void) writer; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status TestService::Service::FailStreamingOutputCall(::grpc::ServerContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest* request, ::grpc::ServerWriter< ::connectrpc::conformance::StreamingOutputCallResponse>* writer) { + (void) context; + (void) request; + (void) writer; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status TestService::Service::StreamingInputCall(::grpc::ServerContext* context, ::grpc::ServerReader< ::connectrpc::conformance::StreamingInputCallRequest>* reader, ::connectrpc::conformance::StreamingInputCallResponse* response) { + (void) context; + (void) reader; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status TestService::Service::FullDuplexCall(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::connectrpc::conformance::StreamingOutputCallResponse, ::connectrpc::conformance::StreamingOutputCallRequest>* stream) { + (void) context; + (void) stream; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status TestService::Service::HalfDuplexCall(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::connectrpc::conformance::StreamingOutputCallResponse, ::connectrpc::conformance::StreamingOutputCallRequest>* stream) { + (void) context; + (void) stream; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status TestService::Service::UnimplementedCall(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status TestService::Service::UnimplementedStreamingOutputCall(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::grpc::ServerWriter< ::google::protobuf::Empty>* writer) { + (void) context; + (void) request; + (void) writer; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + + +static const char* UnimplementedService_method_names[] = { + "/connectrpc.conformance.UnimplementedService/UnimplementedCall", + "/connectrpc.conformance.UnimplementedService/UnimplementedStreamingOutputCall", +}; + +std::unique_ptr< UnimplementedService::Stub> UnimplementedService::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) { + (void)options; + std::unique_ptr< UnimplementedService::Stub> stub(new UnimplementedService::Stub(channel, options)); + return stub; +} + +UnimplementedService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) + : channel_(channel), rpcmethod_UnimplementedCall_(UnimplementedService_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_UnimplementedStreamingOutputCall_(UnimplementedService_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel) + {} + +::grpc::Status UnimplementedService::Stub::UnimplementedCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::google::protobuf::Empty* response) { + return ::grpc::internal::BlockingUnaryCall< ::google::protobuf::Empty, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_UnimplementedCall_, context, request, response); +} + +void UnimplementedService::Stub::async::UnimplementedCall(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::google::protobuf::Empty, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_UnimplementedCall_, context, request, response, std::move(f)); +} + +void UnimplementedService::Stub::async::UnimplementedCall(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_UnimplementedCall_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* UnimplementedService::Stub::PrepareAsyncUnimplementedCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_UnimplementedCall_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* UnimplementedService::Stub::AsyncUnimplementedCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncUnimplementedCallRaw(context, request, cq); + result->StartCall(); + return result; +} + +::grpc::ClientReader< ::google::protobuf::Empty>* UnimplementedService::Stub::UnimplementedStreamingOutputCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request) { + return ::grpc::internal::ClientReaderFactory< ::google::protobuf::Empty>::Create(channel_.get(), rpcmethod_UnimplementedStreamingOutputCall_, context, request); +} + +void UnimplementedService::Stub::async::UnimplementedStreamingOutputCall(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::grpc::ClientReadReactor< ::google::protobuf::Empty>* reactor) { + ::grpc::internal::ClientCallbackReaderFactory< ::google::protobuf::Empty>::Create(stub_->channel_.get(), stub_->rpcmethod_UnimplementedStreamingOutputCall_, context, request, reactor); +} + +::grpc::ClientAsyncReader< ::google::protobuf::Empty>* UnimplementedService::Stub::AsyncUnimplementedStreamingOutputCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq, void* tag) { + return ::grpc::internal::ClientAsyncReaderFactory< ::google::protobuf::Empty>::Create(channel_.get(), cq, rpcmethod_UnimplementedStreamingOutputCall_, context, request, true, tag); +} + +::grpc::ClientAsyncReader< ::google::protobuf::Empty>* UnimplementedService::Stub::PrepareAsyncUnimplementedStreamingOutputCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncReaderFactory< ::google::protobuf::Empty>::Create(channel_.get(), cq, rpcmethod_UnimplementedStreamingOutputCall_, context, request, false, nullptr); +} + +UnimplementedService::Service::Service() { + AddMethod(new ::grpc::internal::RpcServiceMethod( + UnimplementedService_method_names[0], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< UnimplementedService::Service, ::google::protobuf::Empty, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](UnimplementedService::Service* service, + ::grpc::ServerContext* ctx, + const ::google::protobuf::Empty* req, + ::google::protobuf::Empty* resp) { + return service->UnimplementedCall(ctx, req, resp); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + UnimplementedService_method_names[1], + ::grpc::internal::RpcMethod::SERVER_STREAMING, + new ::grpc::internal::ServerStreamingHandler< UnimplementedService::Service, ::google::protobuf::Empty, ::google::protobuf::Empty>( + [](UnimplementedService::Service* service, + ::grpc::ServerContext* ctx, + const ::google::protobuf::Empty* req, + ::grpc::ServerWriter<::google::protobuf::Empty>* writer) { + return service->UnimplementedStreamingOutputCall(ctx, req, writer); + }, this))); +} + +UnimplementedService::Service::~Service() { +} + +::grpc::Status UnimplementedService::Service::UnimplementedCall(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status UnimplementedService::Service::UnimplementedStreamingOutputCall(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::grpc::ServerWriter< ::google::protobuf::Empty>* writer) { + (void) context; + (void) request; + (void) writer; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + + +static const char* ReconnectService_method_names[] = { + "/connectrpc.conformance.ReconnectService/Start", + "/connectrpc.conformance.ReconnectService/Stop", +}; + +std::unique_ptr< ReconnectService::Stub> ReconnectService::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) { + (void)options; + std::unique_ptr< ReconnectService::Stub> stub(new ReconnectService::Stub(channel, options)); + return stub; +} + +ReconnectService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) + : channel_(channel), rpcmethod_Start_(ReconnectService_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_Stop_(ReconnectService_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + {} + +::grpc::Status ReconnectService::Stub::Start(::grpc::ClientContext* context, const ::connectrpc::conformance::ReconnectParams& request, ::google::protobuf::Empty* response) { + return ::grpc::internal::BlockingUnaryCall< ::connectrpc::conformance::ReconnectParams, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Start_, context, request, response); +} + +void ReconnectService::Stub::async::Start(::grpc::ClientContext* context, const ::connectrpc::conformance::ReconnectParams* request, ::google::protobuf::Empty* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::connectrpc::conformance::ReconnectParams, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Start_, context, request, response, std::move(f)); +} + +void ReconnectService::Stub::async::Start(::grpc::ClientContext* context, const ::connectrpc::conformance::ReconnectParams* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Start_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* ReconnectService::Stub::PrepareAsyncStartRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::ReconnectParams& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::connectrpc::conformance::ReconnectParams, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Start_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* ReconnectService::Stub::AsyncStartRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::ReconnectParams& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncStartRaw(context, request, cq); + result->StartCall(); + return result; +} + +::grpc::Status ReconnectService::Stub::Stop(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::connectrpc::conformance::ReconnectInfo* response) { + return ::grpc::internal::BlockingUnaryCall< ::google::protobuf::Empty, ::connectrpc::conformance::ReconnectInfo, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Stop_, context, request, response); +} + +void ReconnectService::Stub::async::Stop(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::connectrpc::conformance::ReconnectInfo* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::google::protobuf::Empty, ::connectrpc::conformance::ReconnectInfo, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Stop_, context, request, response, std::move(f)); +} + +void ReconnectService::Stub::async::Stop(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::connectrpc::conformance::ReconnectInfo* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Stop_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::ReconnectInfo>* ReconnectService::Stub::PrepareAsyncStopRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::connectrpc::conformance::ReconnectInfo, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Stop_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::ReconnectInfo>* ReconnectService::Stub::AsyncStopRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncStopRaw(context, request, cq); + result->StartCall(); + return result; +} + +ReconnectService::Service::Service() { + AddMethod(new ::grpc::internal::RpcServiceMethod( + ReconnectService_method_names[0], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< ReconnectService::Service, ::connectrpc::conformance::ReconnectParams, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](ReconnectService::Service* service, + ::grpc::ServerContext* ctx, + const ::connectrpc::conformance::ReconnectParams* req, + ::google::protobuf::Empty* resp) { + return service->Start(ctx, req, resp); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + ReconnectService_method_names[1], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< ReconnectService::Service, ::google::protobuf::Empty, ::connectrpc::conformance::ReconnectInfo, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](ReconnectService::Service* service, + ::grpc::ServerContext* ctx, + const ::google::protobuf::Empty* req, + ::connectrpc::conformance::ReconnectInfo* resp) { + return service->Stop(ctx, req, resp); + }, this))); +} + +ReconnectService::Service::~Service() { +} + +::grpc::Status ReconnectService::Service::Start(::grpc::ServerContext* context, const ::connectrpc::conformance::ReconnectParams* request, ::google::protobuf::Empty* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status ReconnectService::Service::Stop(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::connectrpc::conformance::ReconnectInfo* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + + +static const char* LoadBalancerStatsService_method_names[] = { + "/connectrpc.conformance.LoadBalancerStatsService/GetClientStats", + "/connectrpc.conformance.LoadBalancerStatsService/GetClientAccumulatedStats", +}; + +std::unique_ptr< LoadBalancerStatsService::Stub> LoadBalancerStatsService::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) { + (void)options; + std::unique_ptr< LoadBalancerStatsService::Stub> stub(new LoadBalancerStatsService::Stub(channel, options)); + return stub; +} + +LoadBalancerStatsService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) + : channel_(channel), rpcmethod_GetClientStats_(LoadBalancerStatsService_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_GetClientAccumulatedStats_(LoadBalancerStatsService_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + {} + +::grpc::Status LoadBalancerStatsService::Stub::GetClientStats(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerStatsRequest& request, ::connectrpc::conformance::LoadBalancerStatsResponse* response) { + return ::grpc::internal::BlockingUnaryCall< ::connectrpc::conformance::LoadBalancerStatsRequest, ::connectrpc::conformance::LoadBalancerStatsResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetClientStats_, context, request, response); +} + +void LoadBalancerStatsService::Stub::async::GetClientStats(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerStatsRequest* request, ::connectrpc::conformance::LoadBalancerStatsResponse* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::connectrpc::conformance::LoadBalancerStatsRequest, ::connectrpc::conformance::LoadBalancerStatsResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetClientStats_, context, request, response, std::move(f)); +} + +void LoadBalancerStatsService::Stub::async::GetClientStats(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerStatsRequest* request, ::connectrpc::conformance::LoadBalancerStatsResponse* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetClientStats_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::LoadBalancerStatsResponse>* LoadBalancerStatsService::Stub::PrepareAsyncGetClientStatsRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerStatsRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::connectrpc::conformance::LoadBalancerStatsResponse, ::connectrpc::conformance::LoadBalancerStatsRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetClientStats_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::LoadBalancerStatsResponse>* LoadBalancerStatsService::Stub::AsyncGetClientStatsRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerStatsRequest& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncGetClientStatsRaw(context, request, cq); + result->StartCall(); + return result; +} + +::grpc::Status LoadBalancerStatsService::Stub::GetClientAccumulatedStats(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest& request, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse* response) { + return ::grpc::internal::BlockingUnaryCall< ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetClientAccumulatedStats_, context, request, response); +} + +void LoadBalancerStatsService::Stub::async::GetClientAccumulatedStats(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest* request, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetClientAccumulatedStats_, context, request, response, std::move(f)); +} + +void LoadBalancerStatsService::Stub::async::GetClientAccumulatedStats(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest* request, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetClientAccumulatedStats_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse>* LoadBalancerStatsService::Stub::PrepareAsyncGetClientAccumulatedStatsRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse, ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetClientAccumulatedStats_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse>* LoadBalancerStatsService::Stub::AsyncGetClientAccumulatedStatsRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncGetClientAccumulatedStatsRaw(context, request, cq); + result->StartCall(); + return result; +} + +LoadBalancerStatsService::Service::Service() { + AddMethod(new ::grpc::internal::RpcServiceMethod( + LoadBalancerStatsService_method_names[0], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< LoadBalancerStatsService::Service, ::connectrpc::conformance::LoadBalancerStatsRequest, ::connectrpc::conformance::LoadBalancerStatsResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](LoadBalancerStatsService::Service* service, + ::grpc::ServerContext* ctx, + const ::connectrpc::conformance::LoadBalancerStatsRequest* req, + ::connectrpc::conformance::LoadBalancerStatsResponse* resp) { + return service->GetClientStats(ctx, req, resp); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + LoadBalancerStatsService_method_names[1], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< LoadBalancerStatsService::Service, ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](LoadBalancerStatsService::Service* service, + ::grpc::ServerContext* ctx, + const ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest* req, + ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse* resp) { + return service->GetClientAccumulatedStats(ctx, req, resp); + }, this))); +} + +LoadBalancerStatsService::Service::~Service() { +} + +::grpc::Status LoadBalancerStatsService::Service::GetClientStats(::grpc::ServerContext* context, const ::connectrpc::conformance::LoadBalancerStatsRequest* request, ::connectrpc::conformance::LoadBalancerStatsResponse* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status LoadBalancerStatsService::Service::GetClientAccumulatedStats(::grpc::ServerContext* context, const ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest* request, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + + +static const char* XdsUpdateHealthService_method_names[] = { + "/connectrpc.conformance.XdsUpdateHealthService/SetServing", + "/connectrpc.conformance.XdsUpdateHealthService/SetNotServing", +}; + +std::unique_ptr< XdsUpdateHealthService::Stub> XdsUpdateHealthService::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) { + (void)options; + std::unique_ptr< XdsUpdateHealthService::Stub> stub(new XdsUpdateHealthService::Stub(channel, options)); + return stub; +} + +XdsUpdateHealthService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) + : channel_(channel), rpcmethod_SetServing_(XdsUpdateHealthService_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_SetNotServing_(XdsUpdateHealthService_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + {} + +::grpc::Status XdsUpdateHealthService::Stub::SetServing(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::google::protobuf::Empty* response) { + return ::grpc::internal::BlockingUnaryCall< ::google::protobuf::Empty, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_SetServing_, context, request, response); +} + +void XdsUpdateHealthService::Stub::async::SetServing(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::google::protobuf::Empty, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SetServing_, context, request, response, std::move(f)); +} + +void XdsUpdateHealthService::Stub::async::SetServing(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SetServing_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* XdsUpdateHealthService::Stub::PrepareAsyncSetServingRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_SetServing_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* XdsUpdateHealthService::Stub::AsyncSetServingRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncSetServingRaw(context, request, cq); + result->StartCall(); + return result; +} + +::grpc::Status XdsUpdateHealthService::Stub::SetNotServing(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::google::protobuf::Empty* response) { + return ::grpc::internal::BlockingUnaryCall< ::google::protobuf::Empty, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_SetNotServing_, context, request, response); +} + +void XdsUpdateHealthService::Stub::async::SetNotServing(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::google::protobuf::Empty, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SetNotServing_, context, request, response, std::move(f)); +} + +void XdsUpdateHealthService::Stub::async::SetNotServing(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SetNotServing_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* XdsUpdateHealthService::Stub::PrepareAsyncSetNotServingRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_SetNotServing_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* XdsUpdateHealthService::Stub::AsyncSetNotServingRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncSetNotServingRaw(context, request, cq); + result->StartCall(); + return result; +} + +XdsUpdateHealthService::Service::Service() { + AddMethod(new ::grpc::internal::RpcServiceMethod( + XdsUpdateHealthService_method_names[0], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< XdsUpdateHealthService::Service, ::google::protobuf::Empty, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](XdsUpdateHealthService::Service* service, + ::grpc::ServerContext* ctx, + const ::google::protobuf::Empty* req, + ::google::protobuf::Empty* resp) { + return service->SetServing(ctx, req, resp); + }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + XdsUpdateHealthService_method_names[1], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< XdsUpdateHealthService::Service, ::google::protobuf::Empty, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](XdsUpdateHealthService::Service* service, + ::grpc::ServerContext* ctx, + const ::google::protobuf::Empty* req, + ::google::protobuf::Empty* resp) { + return service->SetNotServing(ctx, req, resp); + }, this))); +} + +XdsUpdateHealthService::Service::~Service() { +} + +::grpc::Status XdsUpdateHealthService::Service::SetServing(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status XdsUpdateHealthService::Service::SetNotServing(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + + +static const char* XdsUpdateClientConfigureService_method_names[] = { + "/connectrpc.conformance.XdsUpdateClientConfigureService/Configure", +}; + +std::unique_ptr< XdsUpdateClientConfigureService::Stub> XdsUpdateClientConfigureService::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) { + (void)options; + std::unique_ptr< XdsUpdateClientConfigureService::Stub> stub(new XdsUpdateClientConfigureService::Stub(channel, options)); + return stub; +} + +XdsUpdateClientConfigureService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) + : channel_(channel), rpcmethod_Configure_(XdsUpdateClientConfigureService_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) + {} + +::grpc::Status XdsUpdateClientConfigureService::Stub::Configure(::grpc::ClientContext* context, const ::connectrpc::conformance::ClientConfigureRequest& request, ::connectrpc::conformance::ClientConfigureResponse* response) { + return ::grpc::internal::BlockingUnaryCall< ::connectrpc::conformance::ClientConfigureRequest, ::connectrpc::conformance::ClientConfigureResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Configure_, context, request, response); +} + +void XdsUpdateClientConfigureService::Stub::async::Configure(::grpc::ClientContext* context, const ::connectrpc::conformance::ClientConfigureRequest* request, ::connectrpc::conformance::ClientConfigureResponse* response, std::function f) { + ::grpc::internal::CallbackUnaryCall< ::connectrpc::conformance::ClientConfigureRequest, ::connectrpc::conformance::ClientConfigureResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Configure_, context, request, response, std::move(f)); +} + +void XdsUpdateClientConfigureService::Stub::async::Configure(::grpc::ClientContext* context, const ::connectrpc::conformance::ClientConfigureRequest* request, ::connectrpc::conformance::ClientConfigureResponse* response, ::grpc::ClientUnaryReactor* reactor) { + ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Configure_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::ClientConfigureResponse>* XdsUpdateClientConfigureService::Stub::PrepareAsyncConfigureRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::ClientConfigureRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::connectrpc::conformance::ClientConfigureResponse, ::connectrpc::conformance::ClientConfigureRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Configure_, context, request); +} + +::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::ClientConfigureResponse>* XdsUpdateClientConfigureService::Stub::AsyncConfigureRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::ClientConfigureRequest& request, ::grpc::CompletionQueue* cq) { + auto* result = + this->PrepareAsyncConfigureRaw(context, request, cq); + result->StartCall(); + return result; +} + +XdsUpdateClientConfigureService::Service::Service() { + AddMethod(new ::grpc::internal::RpcServiceMethod( + XdsUpdateClientConfigureService_method_names[0], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< XdsUpdateClientConfigureService::Service, ::connectrpc::conformance::ClientConfigureRequest, ::connectrpc::conformance::ClientConfigureResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + [](XdsUpdateClientConfigureService::Service* service, + ::grpc::ServerContext* ctx, + const ::connectrpc::conformance::ClientConfigureRequest* req, + ::connectrpc::conformance::ClientConfigureResponse* resp) { + return service->Configure(ctx, req, resp); + }, this))); +} + +XdsUpdateClientConfigureService::Service::~Service() { +} + +::grpc::Status XdsUpdateClientConfigureService::Service::Configure(::grpc::ServerContext* context, const ::connectrpc::conformance::ClientConfigureRequest* request, ::connectrpc::conformance::ClientConfigureResponse* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + + +} // namespace connectrpc +} // namespace conformance + diff --git a/cc/gen/connectrpc/conformance/test.grpc.pb.h b/cc/gen/connectrpc/conformance/test.grpc.pb.h new file mode 100644 index 00000000..7f7b3173 --- /dev/null +++ b/cc/gen/connectrpc/conformance/test.grpc.pb.h @@ -0,0 +1,3497 @@ +// Copyright 2022 Buf Technologies, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef GRPC_connectrpc_2fconformance_2ftest_2eproto__INCLUDED +#define GRPC_connectrpc_2fconformance_2ftest_2eproto__INCLUDED + +#include "connectrpc/conformance/test.pb.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace connectrpc { +namespace conformance { + +// A simple service to test the various types of RPCs and experiment with +// performance with various types of payload. +class TestService final { + public: + static constexpr char const* service_full_name() { + return "connectrpc.conformance.TestService"; + } + class StubInterface { + public: + virtual ~StubInterface() {} + // One empty request followed by one empty response. + virtual ::grpc::Status EmptyCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::google::protobuf::Empty* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>> AsyncEmptyCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>>(AsyncEmptyCallRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>> PrepareAsyncEmptyCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>>(PrepareAsyncEmptyCallRaw(context, request, cq)); + } + // One request followed by one response. + virtual ::grpc::Status UnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::connectrpc::conformance::SimpleResponse* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::SimpleResponse>> AsyncUnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::SimpleResponse>>(AsyncUnaryCallRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::SimpleResponse>> PrepareAsyncUnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::SimpleResponse>>(PrepareAsyncUnaryCallRaw(context, request, cq)); + } + // One request followed by one response. This RPC always fails. + virtual ::grpc::Status FailUnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::connectrpc::conformance::SimpleResponse* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::SimpleResponse>> AsyncFailUnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::SimpleResponse>>(AsyncFailUnaryCallRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::SimpleResponse>> PrepareAsyncFailUnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::SimpleResponse>>(PrepareAsyncFailUnaryCallRaw(context, request, cq)); + } + // One request followed by one response. Response has cache control + // headers set such that a caching HTTP proxy (such as GFE) can + // satisfy subsequent requests. + virtual ::grpc::Status CacheableUnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::connectrpc::conformance::SimpleResponse* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::SimpleResponse>> AsyncCacheableUnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::SimpleResponse>>(AsyncCacheableUnaryCallRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::SimpleResponse>> PrepareAsyncCacheableUnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::SimpleResponse>>(PrepareAsyncCacheableUnaryCallRaw(context, request, cq)); + } + // One request followed by a sequence of responses (streamed download). + // The server returns the payload with client desired type and sizes. + std::unique_ptr< ::grpc::ClientReaderInterface< ::connectrpc::conformance::StreamingOutputCallResponse>> StreamingOutputCall(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest& request) { + return std::unique_ptr< ::grpc::ClientReaderInterface< ::connectrpc::conformance::StreamingOutputCallResponse>>(StreamingOutputCallRaw(context, request)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::connectrpc::conformance::StreamingOutputCallResponse>> AsyncStreamingOutputCall(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest& request, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::connectrpc::conformance::StreamingOutputCallResponse>>(AsyncStreamingOutputCallRaw(context, request, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::connectrpc::conformance::StreamingOutputCallResponse>> PrepareAsyncStreamingOutputCall(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::connectrpc::conformance::StreamingOutputCallResponse>>(PrepareAsyncStreamingOutputCallRaw(context, request, cq)); + } + // One request followed by a sequence of responses (streamed download). + // The server returns the payload with client desired type and sizes. + // This RPC always responds with an error status. + std::unique_ptr< ::grpc::ClientReaderInterface< ::connectrpc::conformance::StreamingOutputCallResponse>> FailStreamingOutputCall(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest& request) { + return std::unique_ptr< ::grpc::ClientReaderInterface< ::connectrpc::conformance::StreamingOutputCallResponse>>(FailStreamingOutputCallRaw(context, request)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::connectrpc::conformance::StreamingOutputCallResponse>> AsyncFailStreamingOutputCall(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest& request, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::connectrpc::conformance::StreamingOutputCallResponse>>(AsyncFailStreamingOutputCallRaw(context, request, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::connectrpc::conformance::StreamingOutputCallResponse>> PrepareAsyncFailStreamingOutputCall(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::connectrpc::conformance::StreamingOutputCallResponse>>(PrepareAsyncFailStreamingOutputCallRaw(context, request, cq)); + } + // A sequence of requests followed by one response (streamed upload). + // The server returns the aggregated size of client payload as the result. + std::unique_ptr< ::grpc::ClientWriterInterface< ::connectrpc::conformance::StreamingInputCallRequest>> StreamingInputCall(::grpc::ClientContext* context, ::connectrpc::conformance::StreamingInputCallResponse* response) { + return std::unique_ptr< ::grpc::ClientWriterInterface< ::connectrpc::conformance::StreamingInputCallRequest>>(StreamingInputCallRaw(context, response)); + } + std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::connectrpc::conformance::StreamingInputCallRequest>> AsyncStreamingInputCall(::grpc::ClientContext* context, ::connectrpc::conformance::StreamingInputCallResponse* response, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::connectrpc::conformance::StreamingInputCallRequest>>(AsyncStreamingInputCallRaw(context, response, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::connectrpc::conformance::StreamingInputCallRequest>> PrepareAsyncStreamingInputCall(::grpc::ClientContext* context, ::connectrpc::conformance::StreamingInputCallResponse* response, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::connectrpc::conformance::StreamingInputCallRequest>>(PrepareAsyncStreamingInputCallRaw(context, response, cq)); + } + // A sequence of requests with each request served by the server immediately. + // As one request could lead to multiple responses, this interface + // demonstrates the idea of full duplexing. + std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>> FullDuplexCall(::grpc::ClientContext* context) { + return std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>>(FullDuplexCallRaw(context)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>> AsyncFullDuplexCall(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>>(AsyncFullDuplexCallRaw(context, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>> PrepareAsyncFullDuplexCall(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>>(PrepareAsyncFullDuplexCallRaw(context, cq)); + } + // A sequence of requests followed by a sequence of responses. + // The server buffers all the client requests and then serves them in order. A + // stream of responses are returned to the client when the server starts with + // first request. + std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>> HalfDuplexCall(::grpc::ClientContext* context) { + return std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>>(HalfDuplexCallRaw(context)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>> AsyncHalfDuplexCall(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>>(AsyncHalfDuplexCallRaw(context, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>> PrepareAsyncHalfDuplexCall(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>>(PrepareAsyncHalfDuplexCallRaw(context, cq)); + } + // The test server will not implement this method. It will be used + // to test the behavior when clients call unimplemented methods. + virtual ::grpc::Status UnimplementedCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::google::protobuf::Empty* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>> AsyncUnimplementedCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>>(AsyncUnimplementedCallRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>> PrepareAsyncUnimplementedCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>>(PrepareAsyncUnimplementedCallRaw(context, request, cq)); + } + // The test server will not implement this method. It will be used + // to test the behavior when clients call unimplemented streaming output methods. + std::unique_ptr< ::grpc::ClientReaderInterface< ::google::protobuf::Empty>> UnimplementedStreamingOutputCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request) { + return std::unique_ptr< ::grpc::ClientReaderInterface< ::google::protobuf::Empty>>(UnimplementedStreamingOutputCallRaw(context, request)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::google::protobuf::Empty>> AsyncUnimplementedStreamingOutputCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::google::protobuf::Empty>>(AsyncUnimplementedStreamingOutputCallRaw(context, request, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::google::protobuf::Empty>> PrepareAsyncUnimplementedStreamingOutputCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::google::protobuf::Empty>>(PrepareAsyncUnimplementedStreamingOutputCallRaw(context, request, cq)); + } + class async_interface { + public: + virtual ~async_interface() {} + // One empty request followed by one empty response. + virtual void EmptyCall(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response, std::function) = 0; + virtual void EmptyCall(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) = 0; + // One request followed by one response. + virtual void UnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest* request, ::connectrpc::conformance::SimpleResponse* response, std::function) = 0; + virtual void UnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest* request, ::connectrpc::conformance::SimpleResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; + // One request followed by one response. This RPC always fails. + virtual void FailUnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest* request, ::connectrpc::conformance::SimpleResponse* response, std::function) = 0; + virtual void FailUnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest* request, ::connectrpc::conformance::SimpleResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; + // One request followed by one response. Response has cache control + // headers set such that a caching HTTP proxy (such as GFE) can + // satisfy subsequent requests. + virtual void CacheableUnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest* request, ::connectrpc::conformance::SimpleResponse* response, std::function) = 0; + virtual void CacheableUnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest* request, ::connectrpc::conformance::SimpleResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; + // One request followed by a sequence of responses (streamed download). + // The server returns the payload with client desired type and sizes. + virtual void StreamingOutputCall(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest* request, ::grpc::ClientReadReactor< ::connectrpc::conformance::StreamingOutputCallResponse>* reactor) = 0; + // One request followed by a sequence of responses (streamed download). + // The server returns the payload with client desired type and sizes. + // This RPC always responds with an error status. + virtual void FailStreamingOutputCall(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest* request, ::grpc::ClientReadReactor< ::connectrpc::conformance::StreamingOutputCallResponse>* reactor) = 0; + // A sequence of requests followed by one response (streamed upload). + // The server returns the aggregated size of client payload as the result. + virtual void StreamingInputCall(::grpc::ClientContext* context, ::connectrpc::conformance::StreamingInputCallResponse* response, ::grpc::ClientWriteReactor< ::connectrpc::conformance::StreamingInputCallRequest>* reactor) = 0; + // A sequence of requests with each request served by the server immediately. + // As one request could lead to multiple responses, this interface + // demonstrates the idea of full duplexing. + virtual void FullDuplexCall(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::connectrpc::conformance::StreamingOutputCallRequest,::connectrpc::conformance::StreamingOutputCallResponse>* reactor) = 0; + // A sequence of requests followed by a sequence of responses. + // The server buffers all the client requests and then serves them in order. A + // stream of responses are returned to the client when the server starts with + // first request. + virtual void HalfDuplexCall(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::connectrpc::conformance::StreamingOutputCallRequest,::connectrpc::conformance::StreamingOutputCallResponse>* reactor) = 0; + // The test server will not implement this method. It will be used + // to test the behavior when clients call unimplemented methods. + virtual void UnimplementedCall(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response, std::function) = 0; + virtual void UnimplementedCall(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) = 0; + // The test server will not implement this method. It will be used + // to test the behavior when clients call unimplemented streaming output methods. + virtual void UnimplementedStreamingOutputCall(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::grpc::ClientReadReactor< ::google::protobuf::Empty>* reactor) = 0; + }; + typedef class async_interface experimental_async_interface; + virtual class async_interface* async() { return nullptr; } + class async_interface* experimental_async() { return async(); } + private: + virtual ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>* AsyncEmptyCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>* PrepareAsyncEmptyCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::SimpleResponse>* AsyncUnaryCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::SimpleResponse>* PrepareAsyncUnaryCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::SimpleResponse>* AsyncFailUnaryCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::SimpleResponse>* PrepareAsyncFailUnaryCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::SimpleResponse>* AsyncCacheableUnaryCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::SimpleResponse>* PrepareAsyncCacheableUnaryCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientReaderInterface< ::connectrpc::conformance::StreamingOutputCallResponse>* StreamingOutputCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest& request) = 0; + virtual ::grpc::ClientAsyncReaderInterface< ::connectrpc::conformance::StreamingOutputCallResponse>* AsyncStreamingOutputCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest& request, ::grpc::CompletionQueue* cq, void* tag) = 0; + virtual ::grpc::ClientAsyncReaderInterface< ::connectrpc::conformance::StreamingOutputCallResponse>* PrepareAsyncStreamingOutputCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientReaderInterface< ::connectrpc::conformance::StreamingOutputCallResponse>* FailStreamingOutputCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest& request) = 0; + virtual ::grpc::ClientAsyncReaderInterface< ::connectrpc::conformance::StreamingOutputCallResponse>* AsyncFailStreamingOutputCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest& request, ::grpc::CompletionQueue* cq, void* tag) = 0; + virtual ::grpc::ClientAsyncReaderInterface< ::connectrpc::conformance::StreamingOutputCallResponse>* PrepareAsyncFailStreamingOutputCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientWriterInterface< ::connectrpc::conformance::StreamingInputCallRequest>* StreamingInputCallRaw(::grpc::ClientContext* context, ::connectrpc::conformance::StreamingInputCallResponse* response) = 0; + virtual ::grpc::ClientAsyncWriterInterface< ::connectrpc::conformance::StreamingInputCallRequest>* AsyncStreamingInputCallRaw(::grpc::ClientContext* context, ::connectrpc::conformance::StreamingInputCallResponse* response, ::grpc::CompletionQueue* cq, void* tag) = 0; + virtual ::grpc::ClientAsyncWriterInterface< ::connectrpc::conformance::StreamingInputCallRequest>* PrepareAsyncStreamingInputCallRaw(::grpc::ClientContext* context, ::connectrpc::conformance::StreamingInputCallResponse* response, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientReaderWriterInterface< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>* FullDuplexCallRaw(::grpc::ClientContext* context) = 0; + virtual ::grpc::ClientAsyncReaderWriterInterface< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>* AsyncFullDuplexCallRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0; + virtual ::grpc::ClientAsyncReaderWriterInterface< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>* PrepareAsyncFullDuplexCallRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientReaderWriterInterface< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>* HalfDuplexCallRaw(::grpc::ClientContext* context) = 0; + virtual ::grpc::ClientAsyncReaderWriterInterface< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>* AsyncHalfDuplexCallRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0; + virtual ::grpc::ClientAsyncReaderWriterInterface< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>* PrepareAsyncHalfDuplexCallRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>* AsyncUnimplementedCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>* PrepareAsyncUnimplementedCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientReaderInterface< ::google::protobuf::Empty>* UnimplementedStreamingOutputCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request) = 0; + virtual ::grpc::ClientAsyncReaderInterface< ::google::protobuf::Empty>* AsyncUnimplementedStreamingOutputCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq, void* tag) = 0; + virtual ::grpc::ClientAsyncReaderInterface< ::google::protobuf::Empty>* PrepareAsyncUnimplementedStreamingOutputCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; + }; + class Stub final : public StubInterface { + public: + Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); + ::grpc::Status EmptyCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::google::protobuf::Empty* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>> AsyncEmptyCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>>(AsyncEmptyCallRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>> PrepareAsyncEmptyCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>>(PrepareAsyncEmptyCallRaw(context, request, cq)); + } + ::grpc::Status UnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::connectrpc::conformance::SimpleResponse* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::SimpleResponse>> AsyncUnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::SimpleResponse>>(AsyncUnaryCallRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::SimpleResponse>> PrepareAsyncUnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::SimpleResponse>>(PrepareAsyncUnaryCallRaw(context, request, cq)); + } + ::grpc::Status FailUnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::connectrpc::conformance::SimpleResponse* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::SimpleResponse>> AsyncFailUnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::SimpleResponse>>(AsyncFailUnaryCallRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::SimpleResponse>> PrepareAsyncFailUnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::SimpleResponse>>(PrepareAsyncFailUnaryCallRaw(context, request, cq)); + } + ::grpc::Status CacheableUnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::connectrpc::conformance::SimpleResponse* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::SimpleResponse>> AsyncCacheableUnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::SimpleResponse>>(AsyncCacheableUnaryCallRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::SimpleResponse>> PrepareAsyncCacheableUnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::SimpleResponse>>(PrepareAsyncCacheableUnaryCallRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientReader< ::connectrpc::conformance::StreamingOutputCallResponse>> StreamingOutputCall(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest& request) { + return std::unique_ptr< ::grpc::ClientReader< ::connectrpc::conformance::StreamingOutputCallResponse>>(StreamingOutputCallRaw(context, request)); + } + std::unique_ptr< ::grpc::ClientAsyncReader< ::connectrpc::conformance::StreamingOutputCallResponse>> AsyncStreamingOutputCall(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest& request, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReader< ::connectrpc::conformance::StreamingOutputCallResponse>>(AsyncStreamingOutputCallRaw(context, request, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncReader< ::connectrpc::conformance::StreamingOutputCallResponse>> PrepareAsyncStreamingOutputCall(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReader< ::connectrpc::conformance::StreamingOutputCallResponse>>(PrepareAsyncStreamingOutputCallRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientReader< ::connectrpc::conformance::StreamingOutputCallResponse>> FailStreamingOutputCall(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest& request) { + return std::unique_ptr< ::grpc::ClientReader< ::connectrpc::conformance::StreamingOutputCallResponse>>(FailStreamingOutputCallRaw(context, request)); + } + std::unique_ptr< ::grpc::ClientAsyncReader< ::connectrpc::conformance::StreamingOutputCallResponse>> AsyncFailStreamingOutputCall(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest& request, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReader< ::connectrpc::conformance::StreamingOutputCallResponse>>(AsyncFailStreamingOutputCallRaw(context, request, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncReader< ::connectrpc::conformance::StreamingOutputCallResponse>> PrepareAsyncFailStreamingOutputCall(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReader< ::connectrpc::conformance::StreamingOutputCallResponse>>(PrepareAsyncFailStreamingOutputCallRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientWriter< ::connectrpc::conformance::StreamingInputCallRequest>> StreamingInputCall(::grpc::ClientContext* context, ::connectrpc::conformance::StreamingInputCallResponse* response) { + return std::unique_ptr< ::grpc::ClientWriter< ::connectrpc::conformance::StreamingInputCallRequest>>(StreamingInputCallRaw(context, response)); + } + std::unique_ptr< ::grpc::ClientAsyncWriter< ::connectrpc::conformance::StreamingInputCallRequest>> AsyncStreamingInputCall(::grpc::ClientContext* context, ::connectrpc::conformance::StreamingInputCallResponse* response, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncWriter< ::connectrpc::conformance::StreamingInputCallRequest>>(AsyncStreamingInputCallRaw(context, response, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncWriter< ::connectrpc::conformance::StreamingInputCallRequest>> PrepareAsyncStreamingInputCall(::grpc::ClientContext* context, ::connectrpc::conformance::StreamingInputCallResponse* response, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncWriter< ::connectrpc::conformance::StreamingInputCallRequest>>(PrepareAsyncStreamingInputCallRaw(context, response, cq)); + } + std::unique_ptr< ::grpc::ClientReaderWriter< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>> FullDuplexCall(::grpc::ClientContext* context) { + return std::unique_ptr< ::grpc::ClientReaderWriter< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>>(FullDuplexCallRaw(context)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>> AsyncFullDuplexCall(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>>(AsyncFullDuplexCallRaw(context, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>> PrepareAsyncFullDuplexCall(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>>(PrepareAsyncFullDuplexCallRaw(context, cq)); + } + std::unique_ptr< ::grpc::ClientReaderWriter< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>> HalfDuplexCall(::grpc::ClientContext* context) { + return std::unique_ptr< ::grpc::ClientReaderWriter< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>>(HalfDuplexCallRaw(context)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>> AsyncHalfDuplexCall(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>>(AsyncHalfDuplexCallRaw(context, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>> PrepareAsyncHalfDuplexCall(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>>(PrepareAsyncHalfDuplexCallRaw(context, cq)); + } + ::grpc::Status UnimplementedCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::google::protobuf::Empty* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>> AsyncUnimplementedCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>>(AsyncUnimplementedCallRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>> PrepareAsyncUnimplementedCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>>(PrepareAsyncUnimplementedCallRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientReader< ::google::protobuf::Empty>> UnimplementedStreamingOutputCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request) { + return std::unique_ptr< ::grpc::ClientReader< ::google::protobuf::Empty>>(UnimplementedStreamingOutputCallRaw(context, request)); + } + std::unique_ptr< ::grpc::ClientAsyncReader< ::google::protobuf::Empty>> AsyncUnimplementedStreamingOutputCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReader< ::google::protobuf::Empty>>(AsyncUnimplementedStreamingOutputCallRaw(context, request, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncReader< ::google::protobuf::Empty>> PrepareAsyncUnimplementedStreamingOutputCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReader< ::google::protobuf::Empty>>(PrepareAsyncUnimplementedStreamingOutputCallRaw(context, request, cq)); + } + class async final : + public StubInterface::async_interface { + public: + void EmptyCall(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response, std::function) override; + void EmptyCall(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) override; + void UnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest* request, ::connectrpc::conformance::SimpleResponse* response, std::function) override; + void UnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest* request, ::connectrpc::conformance::SimpleResponse* response, ::grpc::ClientUnaryReactor* reactor) override; + void FailUnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest* request, ::connectrpc::conformance::SimpleResponse* response, std::function) override; + void FailUnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest* request, ::connectrpc::conformance::SimpleResponse* response, ::grpc::ClientUnaryReactor* reactor) override; + void CacheableUnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest* request, ::connectrpc::conformance::SimpleResponse* response, std::function) override; + void CacheableUnaryCall(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest* request, ::connectrpc::conformance::SimpleResponse* response, ::grpc::ClientUnaryReactor* reactor) override; + void StreamingOutputCall(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest* request, ::grpc::ClientReadReactor< ::connectrpc::conformance::StreamingOutputCallResponse>* reactor) override; + void FailStreamingOutputCall(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest* request, ::grpc::ClientReadReactor< ::connectrpc::conformance::StreamingOutputCallResponse>* reactor) override; + void StreamingInputCall(::grpc::ClientContext* context, ::connectrpc::conformance::StreamingInputCallResponse* response, ::grpc::ClientWriteReactor< ::connectrpc::conformance::StreamingInputCallRequest>* reactor) override; + void FullDuplexCall(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::connectrpc::conformance::StreamingOutputCallRequest,::connectrpc::conformance::StreamingOutputCallResponse>* reactor) override; + void HalfDuplexCall(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::connectrpc::conformance::StreamingOutputCallRequest,::connectrpc::conformance::StreamingOutputCallResponse>* reactor) override; + void UnimplementedCall(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response, std::function) override; + void UnimplementedCall(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) override; + void UnimplementedStreamingOutputCall(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::grpc::ClientReadReactor< ::google::protobuf::Empty>* reactor) override; + private: + friend class Stub; + explicit async(Stub* stub): stub_(stub) { } + Stub* stub() { return stub_; } + Stub* stub_; + }; + class async* async() override { return &async_stub_; } + + private: + std::shared_ptr< ::grpc::ChannelInterface> channel_; + class async async_stub_{this}; + ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* AsyncEmptyCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* PrepareAsyncEmptyCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::SimpleResponse>* AsyncUnaryCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::SimpleResponse>* PrepareAsyncUnaryCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::SimpleResponse>* AsyncFailUnaryCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::SimpleResponse>* PrepareAsyncFailUnaryCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::SimpleResponse>* AsyncCacheableUnaryCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::SimpleResponse>* PrepareAsyncCacheableUnaryCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::SimpleRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientReader< ::connectrpc::conformance::StreamingOutputCallResponse>* StreamingOutputCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest& request) override; + ::grpc::ClientAsyncReader< ::connectrpc::conformance::StreamingOutputCallResponse>* AsyncStreamingOutputCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest& request, ::grpc::CompletionQueue* cq, void* tag) override; + ::grpc::ClientAsyncReader< ::connectrpc::conformance::StreamingOutputCallResponse>* PrepareAsyncStreamingOutputCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientReader< ::connectrpc::conformance::StreamingOutputCallResponse>* FailStreamingOutputCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest& request) override; + ::grpc::ClientAsyncReader< ::connectrpc::conformance::StreamingOutputCallResponse>* AsyncFailStreamingOutputCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest& request, ::grpc::CompletionQueue* cq, void* tag) override; + ::grpc::ClientAsyncReader< ::connectrpc::conformance::StreamingOutputCallResponse>* PrepareAsyncFailStreamingOutputCallRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientWriter< ::connectrpc::conformance::StreamingInputCallRequest>* StreamingInputCallRaw(::grpc::ClientContext* context, ::connectrpc::conformance::StreamingInputCallResponse* response) override; + ::grpc::ClientAsyncWriter< ::connectrpc::conformance::StreamingInputCallRequest>* AsyncStreamingInputCallRaw(::grpc::ClientContext* context, ::connectrpc::conformance::StreamingInputCallResponse* response, ::grpc::CompletionQueue* cq, void* tag) override; + ::grpc::ClientAsyncWriter< ::connectrpc::conformance::StreamingInputCallRequest>* PrepareAsyncStreamingInputCallRaw(::grpc::ClientContext* context, ::connectrpc::conformance::StreamingInputCallResponse* response, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientReaderWriter< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>* FullDuplexCallRaw(::grpc::ClientContext* context) override; + ::grpc::ClientAsyncReaderWriter< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>* AsyncFullDuplexCallRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override; + ::grpc::ClientAsyncReaderWriter< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>* PrepareAsyncFullDuplexCallRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientReaderWriter< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>* HalfDuplexCallRaw(::grpc::ClientContext* context) override; + ::grpc::ClientAsyncReaderWriter< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>* AsyncHalfDuplexCallRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override; + ::grpc::ClientAsyncReaderWriter< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>* PrepareAsyncHalfDuplexCallRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* AsyncUnimplementedCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* PrepareAsyncUnimplementedCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientReader< ::google::protobuf::Empty>* UnimplementedStreamingOutputCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request) override; + ::grpc::ClientAsyncReader< ::google::protobuf::Empty>* AsyncUnimplementedStreamingOutputCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq, void* tag) override; + ::grpc::ClientAsyncReader< ::google::protobuf::Empty>* PrepareAsyncUnimplementedStreamingOutputCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; + const ::grpc::internal::RpcMethod rpcmethod_EmptyCall_; + const ::grpc::internal::RpcMethod rpcmethod_UnaryCall_; + const ::grpc::internal::RpcMethod rpcmethod_FailUnaryCall_; + const ::grpc::internal::RpcMethod rpcmethod_CacheableUnaryCall_; + const ::grpc::internal::RpcMethod rpcmethod_StreamingOutputCall_; + const ::grpc::internal::RpcMethod rpcmethod_FailStreamingOutputCall_; + const ::grpc::internal::RpcMethod rpcmethod_StreamingInputCall_; + const ::grpc::internal::RpcMethod rpcmethod_FullDuplexCall_; + const ::grpc::internal::RpcMethod rpcmethod_HalfDuplexCall_; + const ::grpc::internal::RpcMethod rpcmethod_UnimplementedCall_; + const ::grpc::internal::RpcMethod rpcmethod_UnimplementedStreamingOutputCall_; + }; + static std::unique_ptr NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); + + class Service : public ::grpc::Service { + public: + Service(); + virtual ~Service(); + // One empty request followed by one empty response. + virtual ::grpc::Status EmptyCall(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response); + // One request followed by one response. + virtual ::grpc::Status UnaryCall(::grpc::ServerContext* context, const ::connectrpc::conformance::SimpleRequest* request, ::connectrpc::conformance::SimpleResponse* response); + // One request followed by one response. This RPC always fails. + virtual ::grpc::Status FailUnaryCall(::grpc::ServerContext* context, const ::connectrpc::conformance::SimpleRequest* request, ::connectrpc::conformance::SimpleResponse* response); + // One request followed by one response. Response has cache control + // headers set such that a caching HTTP proxy (such as GFE) can + // satisfy subsequent requests. + virtual ::grpc::Status CacheableUnaryCall(::grpc::ServerContext* context, const ::connectrpc::conformance::SimpleRequest* request, ::connectrpc::conformance::SimpleResponse* response); + // One request followed by a sequence of responses (streamed download). + // The server returns the payload with client desired type and sizes. + virtual ::grpc::Status StreamingOutputCall(::grpc::ServerContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest* request, ::grpc::ServerWriter< ::connectrpc::conformance::StreamingOutputCallResponse>* writer); + // One request followed by a sequence of responses (streamed download). + // The server returns the payload with client desired type and sizes. + // This RPC always responds with an error status. + virtual ::grpc::Status FailStreamingOutputCall(::grpc::ServerContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest* request, ::grpc::ServerWriter< ::connectrpc::conformance::StreamingOutputCallResponse>* writer); + // A sequence of requests followed by one response (streamed upload). + // The server returns the aggregated size of client payload as the result. + virtual ::grpc::Status StreamingInputCall(::grpc::ServerContext* context, ::grpc::ServerReader< ::connectrpc::conformance::StreamingInputCallRequest>* reader, ::connectrpc::conformance::StreamingInputCallResponse* response); + // A sequence of requests with each request served by the server immediately. + // As one request could lead to multiple responses, this interface + // demonstrates the idea of full duplexing. + virtual ::grpc::Status FullDuplexCall(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::connectrpc::conformance::StreamingOutputCallResponse, ::connectrpc::conformance::StreamingOutputCallRequest>* stream); + // A sequence of requests followed by a sequence of responses. + // The server buffers all the client requests and then serves them in order. A + // stream of responses are returned to the client when the server starts with + // first request. + virtual ::grpc::Status HalfDuplexCall(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::connectrpc::conformance::StreamingOutputCallResponse, ::connectrpc::conformance::StreamingOutputCallRequest>* stream); + // The test server will not implement this method. It will be used + // to test the behavior when clients call unimplemented methods. + virtual ::grpc::Status UnimplementedCall(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response); + // The test server will not implement this method. It will be used + // to test the behavior when clients call unimplemented streaming output methods. + virtual ::grpc::Status UnimplementedStreamingOutputCall(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::grpc::ServerWriter< ::google::protobuf::Empty>* writer); + }; + template + class WithAsyncMethod_EmptyCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_EmptyCall() { + ::grpc::Service::MarkMethodAsync(0); + } + ~WithAsyncMethod_EmptyCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status EmptyCall(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestEmptyCall(::grpc::ServerContext* context, ::google::protobuf::Empty* request, ::grpc::ServerAsyncResponseWriter< ::google::protobuf::Empty>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_UnaryCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_UnaryCall() { + ::grpc::Service::MarkMethodAsync(1); + } + ~WithAsyncMethod_UnaryCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status UnaryCall(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::SimpleRequest* /*request*/, ::connectrpc::conformance::SimpleResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestUnaryCall(::grpc::ServerContext* context, ::connectrpc::conformance::SimpleRequest* request, ::grpc::ServerAsyncResponseWriter< ::connectrpc::conformance::SimpleResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_FailUnaryCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_FailUnaryCall() { + ::grpc::Service::MarkMethodAsync(2); + } + ~WithAsyncMethod_FailUnaryCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status FailUnaryCall(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::SimpleRequest* /*request*/, ::connectrpc::conformance::SimpleResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestFailUnaryCall(::grpc::ServerContext* context, ::connectrpc::conformance::SimpleRequest* request, ::grpc::ServerAsyncResponseWriter< ::connectrpc::conformance::SimpleResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_CacheableUnaryCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_CacheableUnaryCall() { + ::grpc::Service::MarkMethodAsync(3); + } + ~WithAsyncMethod_CacheableUnaryCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status CacheableUnaryCall(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::SimpleRequest* /*request*/, ::connectrpc::conformance::SimpleResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestCacheableUnaryCall(::grpc::ServerContext* context, ::connectrpc::conformance::SimpleRequest* request, ::grpc::ServerAsyncResponseWriter< ::connectrpc::conformance::SimpleResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_StreamingOutputCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_StreamingOutputCall() { + ::grpc::Service::MarkMethodAsync(4); + } + ~WithAsyncMethod_StreamingOutputCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StreamingOutputCall(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::StreamingOutputCallRequest* /*request*/, ::grpc::ServerWriter< ::connectrpc::conformance::StreamingOutputCallResponse>* /*writer*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestStreamingOutputCall(::grpc::ServerContext* context, ::connectrpc::conformance::StreamingOutputCallRequest* request, ::grpc::ServerAsyncWriter< ::connectrpc::conformance::StreamingOutputCallResponse>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncServerStreaming(4, context, request, writer, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_FailStreamingOutputCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_FailStreamingOutputCall() { + ::grpc::Service::MarkMethodAsync(5); + } + ~WithAsyncMethod_FailStreamingOutputCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status FailStreamingOutputCall(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::StreamingOutputCallRequest* /*request*/, ::grpc::ServerWriter< ::connectrpc::conformance::StreamingOutputCallResponse>* /*writer*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestFailStreamingOutputCall(::grpc::ServerContext* context, ::connectrpc::conformance::StreamingOutputCallRequest* request, ::grpc::ServerAsyncWriter< ::connectrpc::conformance::StreamingOutputCallResponse>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncServerStreaming(5, context, request, writer, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_StreamingInputCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_StreamingInputCall() { + ::grpc::Service::MarkMethodAsync(6); + } + ~WithAsyncMethod_StreamingInputCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StreamingInputCall(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::connectrpc::conformance::StreamingInputCallRequest>* /*reader*/, ::connectrpc::conformance::StreamingInputCallResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestStreamingInputCall(::grpc::ServerContext* context, ::grpc::ServerAsyncReader< ::connectrpc::conformance::StreamingInputCallResponse, ::connectrpc::conformance::StreamingInputCallRequest>* reader, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncClientStreaming(6, context, reader, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_FullDuplexCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_FullDuplexCall() { + ::grpc::Service::MarkMethodAsync(7); + } + ~WithAsyncMethod_FullDuplexCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status FullDuplexCall(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::connectrpc::conformance::StreamingOutputCallResponse, ::connectrpc::conformance::StreamingOutputCallRequest>* /*stream*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestFullDuplexCall(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::connectrpc::conformance::StreamingOutputCallResponse, ::connectrpc::conformance::StreamingOutputCallRequest>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncBidiStreaming(7, context, stream, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_HalfDuplexCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_HalfDuplexCall() { + ::grpc::Service::MarkMethodAsync(8); + } + ~WithAsyncMethod_HalfDuplexCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HalfDuplexCall(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::connectrpc::conformance::StreamingOutputCallResponse, ::connectrpc::conformance::StreamingOutputCallRequest>* /*stream*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestHalfDuplexCall(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::connectrpc::conformance::StreamingOutputCallResponse, ::connectrpc::conformance::StreamingOutputCallRequest>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncBidiStreaming(8, context, stream, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_UnimplementedCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_UnimplementedCall() { + ::grpc::Service::MarkMethodAsync(9); + } + ~WithAsyncMethod_UnimplementedCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status UnimplementedCall(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestUnimplementedCall(::grpc::ServerContext* context, ::google::protobuf::Empty* request, ::grpc::ServerAsyncResponseWriter< ::google::protobuf::Empty>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(9, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_UnimplementedStreamingOutputCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_UnimplementedStreamingOutputCall() { + ::grpc::Service::MarkMethodAsync(10); + } + ~WithAsyncMethod_UnimplementedStreamingOutputCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status UnimplementedStreamingOutputCall(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::grpc::ServerWriter< ::google::protobuf::Empty>* /*writer*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestUnimplementedStreamingOutputCall(::grpc::ServerContext* context, ::google::protobuf::Empty* request, ::grpc::ServerAsyncWriter< ::google::protobuf::Empty>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncServerStreaming(10, context, request, writer, new_call_cq, notification_cq, tag); + } + }; + typedef WithAsyncMethod_EmptyCall > > > > > > > > > > AsyncService; + template + class WithCallbackMethod_EmptyCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_EmptyCall() { + ::grpc::Service::MarkMethodCallback(0, + new ::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::google::protobuf::Empty>( + [this]( + ::grpc::CallbackServerContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response) { return this->EmptyCall(context, request, response); }));} + void SetMessageAllocatorFor_EmptyCall( + ::grpc::MessageAllocator< ::google::protobuf::Empty, ::google::protobuf::Empty>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0); + static_cast<::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::google::protobuf::Empty>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_EmptyCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status EmptyCall(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* EmptyCall( + ::grpc::CallbackServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) { return nullptr; } + }; + template + class WithCallbackMethod_UnaryCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_UnaryCall() { + ::grpc::Service::MarkMethodCallback(1, + new ::grpc::internal::CallbackUnaryHandler< ::connectrpc::conformance::SimpleRequest, ::connectrpc::conformance::SimpleResponse>( + [this]( + ::grpc::CallbackServerContext* context, const ::connectrpc::conformance::SimpleRequest* request, ::connectrpc::conformance::SimpleResponse* response) { return this->UnaryCall(context, request, response); }));} + void SetMessageAllocatorFor_UnaryCall( + ::grpc::MessageAllocator< ::connectrpc::conformance::SimpleRequest, ::connectrpc::conformance::SimpleResponse>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1); + static_cast<::grpc::internal::CallbackUnaryHandler< ::connectrpc::conformance::SimpleRequest, ::connectrpc::conformance::SimpleResponse>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_UnaryCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status UnaryCall(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::SimpleRequest* /*request*/, ::connectrpc::conformance::SimpleResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* UnaryCall( + ::grpc::CallbackServerContext* /*context*/, const ::connectrpc::conformance::SimpleRequest* /*request*/, ::connectrpc::conformance::SimpleResponse* /*response*/) { return nullptr; } + }; + template + class WithCallbackMethod_FailUnaryCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_FailUnaryCall() { + ::grpc::Service::MarkMethodCallback(2, + new ::grpc::internal::CallbackUnaryHandler< ::connectrpc::conformance::SimpleRequest, ::connectrpc::conformance::SimpleResponse>( + [this]( + ::grpc::CallbackServerContext* context, const ::connectrpc::conformance::SimpleRequest* request, ::connectrpc::conformance::SimpleResponse* response) { return this->FailUnaryCall(context, request, response); }));} + void SetMessageAllocatorFor_FailUnaryCall( + ::grpc::MessageAllocator< ::connectrpc::conformance::SimpleRequest, ::connectrpc::conformance::SimpleResponse>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(2); + static_cast<::grpc::internal::CallbackUnaryHandler< ::connectrpc::conformance::SimpleRequest, ::connectrpc::conformance::SimpleResponse>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_FailUnaryCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status FailUnaryCall(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::SimpleRequest* /*request*/, ::connectrpc::conformance::SimpleResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* FailUnaryCall( + ::grpc::CallbackServerContext* /*context*/, const ::connectrpc::conformance::SimpleRequest* /*request*/, ::connectrpc::conformance::SimpleResponse* /*response*/) { return nullptr; } + }; + template + class WithCallbackMethod_CacheableUnaryCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_CacheableUnaryCall() { + ::grpc::Service::MarkMethodCallback(3, + new ::grpc::internal::CallbackUnaryHandler< ::connectrpc::conformance::SimpleRequest, ::connectrpc::conformance::SimpleResponse>( + [this]( + ::grpc::CallbackServerContext* context, const ::connectrpc::conformance::SimpleRequest* request, ::connectrpc::conformance::SimpleResponse* response) { return this->CacheableUnaryCall(context, request, response); }));} + void SetMessageAllocatorFor_CacheableUnaryCall( + ::grpc::MessageAllocator< ::connectrpc::conformance::SimpleRequest, ::connectrpc::conformance::SimpleResponse>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(3); + static_cast<::grpc::internal::CallbackUnaryHandler< ::connectrpc::conformance::SimpleRequest, ::connectrpc::conformance::SimpleResponse>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_CacheableUnaryCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status CacheableUnaryCall(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::SimpleRequest* /*request*/, ::connectrpc::conformance::SimpleResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* CacheableUnaryCall( + ::grpc::CallbackServerContext* /*context*/, const ::connectrpc::conformance::SimpleRequest* /*request*/, ::connectrpc::conformance::SimpleResponse* /*response*/) { return nullptr; } + }; + template + class WithCallbackMethod_StreamingOutputCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_StreamingOutputCall() { + ::grpc::Service::MarkMethodCallback(4, + new ::grpc::internal::CallbackServerStreamingHandler< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>( + [this]( + ::grpc::CallbackServerContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest* request) { return this->StreamingOutputCall(context, request); })); + } + ~WithCallbackMethod_StreamingOutputCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StreamingOutputCall(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::StreamingOutputCallRequest* /*request*/, ::grpc::ServerWriter< ::connectrpc::conformance::StreamingOutputCallResponse>* /*writer*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerWriteReactor< ::connectrpc::conformance::StreamingOutputCallResponse>* StreamingOutputCall( + ::grpc::CallbackServerContext* /*context*/, const ::connectrpc::conformance::StreamingOutputCallRequest* /*request*/) { return nullptr; } + }; + template + class WithCallbackMethod_FailStreamingOutputCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_FailStreamingOutputCall() { + ::grpc::Service::MarkMethodCallback(5, + new ::grpc::internal::CallbackServerStreamingHandler< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>( + [this]( + ::grpc::CallbackServerContext* context, const ::connectrpc::conformance::StreamingOutputCallRequest* request) { return this->FailStreamingOutputCall(context, request); })); + } + ~WithCallbackMethod_FailStreamingOutputCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status FailStreamingOutputCall(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::StreamingOutputCallRequest* /*request*/, ::grpc::ServerWriter< ::connectrpc::conformance::StreamingOutputCallResponse>* /*writer*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerWriteReactor< ::connectrpc::conformance::StreamingOutputCallResponse>* FailStreamingOutputCall( + ::grpc::CallbackServerContext* /*context*/, const ::connectrpc::conformance::StreamingOutputCallRequest* /*request*/) { return nullptr; } + }; + template + class WithCallbackMethod_StreamingInputCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_StreamingInputCall() { + ::grpc::Service::MarkMethodCallback(6, + new ::grpc::internal::CallbackClientStreamingHandler< ::connectrpc::conformance::StreamingInputCallRequest, ::connectrpc::conformance::StreamingInputCallResponse>( + [this]( + ::grpc::CallbackServerContext* context, ::connectrpc::conformance::StreamingInputCallResponse* response) { return this->StreamingInputCall(context, response); })); + } + ~WithCallbackMethod_StreamingInputCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StreamingInputCall(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::connectrpc::conformance::StreamingInputCallRequest>* /*reader*/, ::connectrpc::conformance::StreamingInputCallResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerReadReactor< ::connectrpc::conformance::StreamingInputCallRequest>* StreamingInputCall( + ::grpc::CallbackServerContext* /*context*/, ::connectrpc::conformance::StreamingInputCallResponse* /*response*/) { return nullptr; } + }; + template + class WithCallbackMethod_FullDuplexCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_FullDuplexCall() { + ::grpc::Service::MarkMethodCallback(7, + new ::grpc::internal::CallbackBidiHandler< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>( + [this]( + ::grpc::CallbackServerContext* context) { return this->FullDuplexCall(context); })); + } + ~WithCallbackMethod_FullDuplexCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status FullDuplexCall(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::connectrpc::conformance::StreamingOutputCallResponse, ::connectrpc::conformance::StreamingOutputCallRequest>* /*stream*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerBidiReactor< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>* FullDuplexCall( + ::grpc::CallbackServerContext* /*context*/) + { return nullptr; } + }; + template + class WithCallbackMethod_HalfDuplexCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_HalfDuplexCall() { + ::grpc::Service::MarkMethodCallback(8, + new ::grpc::internal::CallbackBidiHandler< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>( + [this]( + ::grpc::CallbackServerContext* context) { return this->HalfDuplexCall(context); })); + } + ~WithCallbackMethod_HalfDuplexCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HalfDuplexCall(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::connectrpc::conformance::StreamingOutputCallResponse, ::connectrpc::conformance::StreamingOutputCallRequest>* /*stream*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerBidiReactor< ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>* HalfDuplexCall( + ::grpc::CallbackServerContext* /*context*/) + { return nullptr; } + }; + template + class WithCallbackMethod_UnimplementedCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_UnimplementedCall() { + ::grpc::Service::MarkMethodCallback(9, + new ::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::google::protobuf::Empty>( + [this]( + ::grpc::CallbackServerContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response) { return this->UnimplementedCall(context, request, response); }));} + void SetMessageAllocatorFor_UnimplementedCall( + ::grpc::MessageAllocator< ::google::protobuf::Empty, ::google::protobuf::Empty>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(9); + static_cast<::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::google::protobuf::Empty>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_UnimplementedCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status UnimplementedCall(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* UnimplementedCall( + ::grpc::CallbackServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) { return nullptr; } + }; + template + class WithCallbackMethod_UnimplementedStreamingOutputCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_UnimplementedStreamingOutputCall() { + ::grpc::Service::MarkMethodCallback(10, + new ::grpc::internal::CallbackServerStreamingHandler< ::google::protobuf::Empty, ::google::protobuf::Empty>( + [this]( + ::grpc::CallbackServerContext* context, const ::google::protobuf::Empty* request) { return this->UnimplementedStreamingOutputCall(context, request); })); + } + ~WithCallbackMethod_UnimplementedStreamingOutputCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status UnimplementedStreamingOutputCall(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::grpc::ServerWriter< ::google::protobuf::Empty>* /*writer*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerWriteReactor< ::google::protobuf::Empty>* UnimplementedStreamingOutputCall( + ::grpc::CallbackServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/) { return nullptr; } + }; + typedef WithCallbackMethod_EmptyCall > > > > > > > > > > CallbackService; + typedef CallbackService ExperimentalCallbackService; + template + class WithGenericMethod_EmptyCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_EmptyCall() { + ::grpc::Service::MarkMethodGeneric(0); + } + ~WithGenericMethod_EmptyCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status EmptyCall(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_UnaryCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_UnaryCall() { + ::grpc::Service::MarkMethodGeneric(1); + } + ~WithGenericMethod_UnaryCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status UnaryCall(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::SimpleRequest* /*request*/, ::connectrpc::conformance::SimpleResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_FailUnaryCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_FailUnaryCall() { + ::grpc::Service::MarkMethodGeneric(2); + } + ~WithGenericMethod_FailUnaryCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status FailUnaryCall(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::SimpleRequest* /*request*/, ::connectrpc::conformance::SimpleResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_CacheableUnaryCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_CacheableUnaryCall() { + ::grpc::Service::MarkMethodGeneric(3); + } + ~WithGenericMethod_CacheableUnaryCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status CacheableUnaryCall(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::SimpleRequest* /*request*/, ::connectrpc::conformance::SimpleResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_StreamingOutputCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_StreamingOutputCall() { + ::grpc::Service::MarkMethodGeneric(4); + } + ~WithGenericMethod_StreamingOutputCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StreamingOutputCall(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::StreamingOutputCallRequest* /*request*/, ::grpc::ServerWriter< ::connectrpc::conformance::StreamingOutputCallResponse>* /*writer*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_FailStreamingOutputCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_FailStreamingOutputCall() { + ::grpc::Service::MarkMethodGeneric(5); + } + ~WithGenericMethod_FailStreamingOutputCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status FailStreamingOutputCall(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::StreamingOutputCallRequest* /*request*/, ::grpc::ServerWriter< ::connectrpc::conformance::StreamingOutputCallResponse>* /*writer*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_StreamingInputCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_StreamingInputCall() { + ::grpc::Service::MarkMethodGeneric(6); + } + ~WithGenericMethod_StreamingInputCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StreamingInputCall(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::connectrpc::conformance::StreamingInputCallRequest>* /*reader*/, ::connectrpc::conformance::StreamingInputCallResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_FullDuplexCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_FullDuplexCall() { + ::grpc::Service::MarkMethodGeneric(7); + } + ~WithGenericMethod_FullDuplexCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status FullDuplexCall(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::connectrpc::conformance::StreamingOutputCallResponse, ::connectrpc::conformance::StreamingOutputCallRequest>* /*stream*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_HalfDuplexCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_HalfDuplexCall() { + ::grpc::Service::MarkMethodGeneric(8); + } + ~WithGenericMethod_HalfDuplexCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HalfDuplexCall(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::connectrpc::conformance::StreamingOutputCallResponse, ::connectrpc::conformance::StreamingOutputCallRequest>* /*stream*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_UnimplementedCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_UnimplementedCall() { + ::grpc::Service::MarkMethodGeneric(9); + } + ~WithGenericMethod_UnimplementedCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status UnimplementedCall(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_UnimplementedStreamingOutputCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_UnimplementedStreamingOutputCall() { + ::grpc::Service::MarkMethodGeneric(10); + } + ~WithGenericMethod_UnimplementedStreamingOutputCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status UnimplementedStreamingOutputCall(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::grpc::ServerWriter< ::google::protobuf::Empty>* /*writer*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithRawMethod_EmptyCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_EmptyCall() { + ::grpc::Service::MarkMethodRaw(0); + } + ~WithRawMethod_EmptyCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status EmptyCall(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestEmptyCall(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_UnaryCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_UnaryCall() { + ::grpc::Service::MarkMethodRaw(1); + } + ~WithRawMethod_UnaryCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status UnaryCall(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::SimpleRequest* /*request*/, ::connectrpc::conformance::SimpleResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestUnaryCall(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_FailUnaryCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_FailUnaryCall() { + ::grpc::Service::MarkMethodRaw(2); + } + ~WithRawMethod_FailUnaryCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status FailUnaryCall(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::SimpleRequest* /*request*/, ::connectrpc::conformance::SimpleResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestFailUnaryCall(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_CacheableUnaryCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_CacheableUnaryCall() { + ::grpc::Service::MarkMethodRaw(3); + } + ~WithRawMethod_CacheableUnaryCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status CacheableUnaryCall(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::SimpleRequest* /*request*/, ::connectrpc::conformance::SimpleResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestCacheableUnaryCall(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_StreamingOutputCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_StreamingOutputCall() { + ::grpc::Service::MarkMethodRaw(4); + } + ~WithRawMethod_StreamingOutputCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StreamingOutputCall(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::StreamingOutputCallRequest* /*request*/, ::grpc::ServerWriter< ::connectrpc::conformance::StreamingOutputCallResponse>* /*writer*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestStreamingOutputCall(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncWriter< ::grpc::ByteBuffer>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncServerStreaming(4, context, request, writer, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_FailStreamingOutputCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_FailStreamingOutputCall() { + ::grpc::Service::MarkMethodRaw(5); + } + ~WithRawMethod_FailStreamingOutputCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status FailStreamingOutputCall(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::StreamingOutputCallRequest* /*request*/, ::grpc::ServerWriter< ::connectrpc::conformance::StreamingOutputCallResponse>* /*writer*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestFailStreamingOutputCall(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncWriter< ::grpc::ByteBuffer>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncServerStreaming(5, context, request, writer, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_StreamingInputCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_StreamingInputCall() { + ::grpc::Service::MarkMethodRaw(6); + } + ~WithRawMethod_StreamingInputCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StreamingInputCall(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::connectrpc::conformance::StreamingInputCallRequest>* /*reader*/, ::connectrpc::conformance::StreamingInputCallResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestStreamingInputCall(::grpc::ServerContext* context, ::grpc::ServerAsyncReader< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* reader, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncClientStreaming(6, context, reader, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_FullDuplexCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_FullDuplexCall() { + ::grpc::Service::MarkMethodRaw(7); + } + ~WithRawMethod_FullDuplexCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status FullDuplexCall(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::connectrpc::conformance::StreamingOutputCallResponse, ::connectrpc::conformance::StreamingOutputCallRequest>* /*stream*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestFullDuplexCall(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncBidiStreaming(7, context, stream, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_HalfDuplexCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_HalfDuplexCall() { + ::grpc::Service::MarkMethodRaw(8); + } + ~WithRawMethod_HalfDuplexCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HalfDuplexCall(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::connectrpc::conformance::StreamingOutputCallResponse, ::connectrpc::conformance::StreamingOutputCallRequest>* /*stream*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestHalfDuplexCall(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncBidiStreaming(8, context, stream, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_UnimplementedCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_UnimplementedCall() { + ::grpc::Service::MarkMethodRaw(9); + } + ~WithRawMethod_UnimplementedCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status UnimplementedCall(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestUnimplementedCall(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(9, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_UnimplementedStreamingOutputCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_UnimplementedStreamingOutputCall() { + ::grpc::Service::MarkMethodRaw(10); + } + ~WithRawMethod_UnimplementedStreamingOutputCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status UnimplementedStreamingOutputCall(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::grpc::ServerWriter< ::google::protobuf::Empty>* /*writer*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestUnimplementedStreamingOutputCall(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncWriter< ::grpc::ByteBuffer>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncServerStreaming(10, context, request, writer, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawCallbackMethod_EmptyCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_EmptyCall() { + ::grpc::Service::MarkMethodRawCallback(0, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->EmptyCall(context, request, response); })); + } + ~WithRawCallbackMethod_EmptyCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status EmptyCall(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* EmptyCall( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_UnaryCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_UnaryCall() { + ::grpc::Service::MarkMethodRawCallback(1, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->UnaryCall(context, request, response); })); + } + ~WithRawCallbackMethod_UnaryCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status UnaryCall(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::SimpleRequest* /*request*/, ::connectrpc::conformance::SimpleResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* UnaryCall( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_FailUnaryCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_FailUnaryCall() { + ::grpc::Service::MarkMethodRawCallback(2, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->FailUnaryCall(context, request, response); })); + } + ~WithRawCallbackMethod_FailUnaryCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status FailUnaryCall(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::SimpleRequest* /*request*/, ::connectrpc::conformance::SimpleResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* FailUnaryCall( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_CacheableUnaryCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_CacheableUnaryCall() { + ::grpc::Service::MarkMethodRawCallback(3, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->CacheableUnaryCall(context, request, response); })); + } + ~WithRawCallbackMethod_CacheableUnaryCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status CacheableUnaryCall(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::SimpleRequest* /*request*/, ::connectrpc::conformance::SimpleResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* CacheableUnaryCall( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_StreamingOutputCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_StreamingOutputCall() { + ::grpc::Service::MarkMethodRawCallback(4, + new ::grpc::internal::CallbackServerStreamingHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const::grpc::ByteBuffer* request) { return this->StreamingOutputCall(context, request); })); + } + ~WithRawCallbackMethod_StreamingOutputCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StreamingOutputCall(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::StreamingOutputCallRequest* /*request*/, ::grpc::ServerWriter< ::connectrpc::conformance::StreamingOutputCallResponse>* /*writer*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerWriteReactor< ::grpc::ByteBuffer>* StreamingOutputCall( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_FailStreamingOutputCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_FailStreamingOutputCall() { + ::grpc::Service::MarkMethodRawCallback(5, + new ::grpc::internal::CallbackServerStreamingHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const::grpc::ByteBuffer* request) { return this->FailStreamingOutputCall(context, request); })); + } + ~WithRawCallbackMethod_FailStreamingOutputCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status FailStreamingOutputCall(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::StreamingOutputCallRequest* /*request*/, ::grpc::ServerWriter< ::connectrpc::conformance::StreamingOutputCallResponse>* /*writer*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerWriteReactor< ::grpc::ByteBuffer>* FailStreamingOutputCall( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_StreamingInputCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_StreamingInputCall() { + ::grpc::Service::MarkMethodRawCallback(6, + new ::grpc::internal::CallbackClientStreamingHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, ::grpc::ByteBuffer* response) { return this->StreamingInputCall(context, response); })); + } + ~WithRawCallbackMethod_StreamingInputCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StreamingInputCall(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::connectrpc::conformance::StreamingInputCallRequest>* /*reader*/, ::connectrpc::conformance::StreamingInputCallResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerReadReactor< ::grpc::ByteBuffer>* StreamingInputCall( + ::grpc::CallbackServerContext* /*context*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_FullDuplexCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_FullDuplexCall() { + ::grpc::Service::MarkMethodRawCallback(7, + new ::grpc::internal::CallbackBidiHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context) { return this->FullDuplexCall(context); })); + } + ~WithRawCallbackMethod_FullDuplexCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status FullDuplexCall(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::connectrpc::conformance::StreamingOutputCallResponse, ::connectrpc::conformance::StreamingOutputCallRequest>* /*stream*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerBidiReactor< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* FullDuplexCall( + ::grpc::CallbackServerContext* /*context*/) + { return nullptr; } + }; + template + class WithRawCallbackMethod_HalfDuplexCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_HalfDuplexCall() { + ::grpc::Service::MarkMethodRawCallback(8, + new ::grpc::internal::CallbackBidiHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context) { return this->HalfDuplexCall(context); })); + } + ~WithRawCallbackMethod_HalfDuplexCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HalfDuplexCall(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::connectrpc::conformance::StreamingOutputCallResponse, ::connectrpc::conformance::StreamingOutputCallRequest>* /*stream*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerBidiReactor< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* HalfDuplexCall( + ::grpc::CallbackServerContext* /*context*/) + { return nullptr; } + }; + template + class WithRawCallbackMethod_UnimplementedCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_UnimplementedCall() { + ::grpc::Service::MarkMethodRawCallback(9, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->UnimplementedCall(context, request, response); })); + } + ~WithRawCallbackMethod_UnimplementedCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status UnimplementedCall(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* UnimplementedCall( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_UnimplementedStreamingOutputCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_UnimplementedStreamingOutputCall() { + ::grpc::Service::MarkMethodRawCallback(10, + new ::grpc::internal::CallbackServerStreamingHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const::grpc::ByteBuffer* request) { return this->UnimplementedStreamingOutputCall(context, request); })); + } + ~WithRawCallbackMethod_UnimplementedStreamingOutputCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status UnimplementedStreamingOutputCall(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::grpc::ServerWriter< ::google::protobuf::Empty>* /*writer*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerWriteReactor< ::grpc::ByteBuffer>* UnimplementedStreamingOutputCall( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/) { return nullptr; } + }; + template + class WithStreamedUnaryMethod_EmptyCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_EmptyCall() { + ::grpc::Service::MarkMethodStreamed(0, + new ::grpc::internal::StreamedUnaryHandler< + ::google::protobuf::Empty, ::google::protobuf::Empty>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::google::protobuf::Empty, ::google::protobuf::Empty>* streamer) { + return this->StreamedEmptyCall(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_EmptyCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status EmptyCall(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedEmptyCall(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty,::google::protobuf::Empty>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_UnaryCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_UnaryCall() { + ::grpc::Service::MarkMethodStreamed(1, + new ::grpc::internal::StreamedUnaryHandler< + ::connectrpc::conformance::SimpleRequest, ::connectrpc::conformance::SimpleResponse>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::connectrpc::conformance::SimpleRequest, ::connectrpc::conformance::SimpleResponse>* streamer) { + return this->StreamedUnaryCall(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_UnaryCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status UnaryCall(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::SimpleRequest* /*request*/, ::connectrpc::conformance::SimpleResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedUnaryCall(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::connectrpc::conformance::SimpleRequest,::connectrpc::conformance::SimpleResponse>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_FailUnaryCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_FailUnaryCall() { + ::grpc::Service::MarkMethodStreamed(2, + new ::grpc::internal::StreamedUnaryHandler< + ::connectrpc::conformance::SimpleRequest, ::connectrpc::conformance::SimpleResponse>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::connectrpc::conformance::SimpleRequest, ::connectrpc::conformance::SimpleResponse>* streamer) { + return this->StreamedFailUnaryCall(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_FailUnaryCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status FailUnaryCall(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::SimpleRequest* /*request*/, ::connectrpc::conformance::SimpleResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedFailUnaryCall(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::connectrpc::conformance::SimpleRequest,::connectrpc::conformance::SimpleResponse>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_CacheableUnaryCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_CacheableUnaryCall() { + ::grpc::Service::MarkMethodStreamed(3, + new ::grpc::internal::StreamedUnaryHandler< + ::connectrpc::conformance::SimpleRequest, ::connectrpc::conformance::SimpleResponse>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::connectrpc::conformance::SimpleRequest, ::connectrpc::conformance::SimpleResponse>* streamer) { + return this->StreamedCacheableUnaryCall(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_CacheableUnaryCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status CacheableUnaryCall(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::SimpleRequest* /*request*/, ::connectrpc::conformance::SimpleResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedCacheableUnaryCall(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::connectrpc::conformance::SimpleRequest,::connectrpc::conformance::SimpleResponse>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_UnimplementedCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_UnimplementedCall() { + ::grpc::Service::MarkMethodStreamed(9, + new ::grpc::internal::StreamedUnaryHandler< + ::google::protobuf::Empty, ::google::protobuf::Empty>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::google::protobuf::Empty, ::google::protobuf::Empty>* streamer) { + return this->StreamedUnimplementedCall(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_UnimplementedCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status UnimplementedCall(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedUnimplementedCall(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty,::google::protobuf::Empty>* server_unary_streamer) = 0; + }; + typedef WithStreamedUnaryMethod_EmptyCall > > > > StreamedUnaryService; + template + class WithSplitStreamingMethod_StreamingOutputCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithSplitStreamingMethod_StreamingOutputCall() { + ::grpc::Service::MarkMethodStreamed(4, + new ::grpc::internal::SplitServerStreamingHandler< + ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>( + [this](::grpc::ServerContext* context, + ::grpc::ServerSplitStreamer< + ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>* streamer) { + return this->StreamedStreamingOutputCall(context, + streamer); + })); + } + ~WithSplitStreamingMethod_StreamingOutputCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status StreamingOutputCall(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::StreamingOutputCallRequest* /*request*/, ::grpc::ServerWriter< ::connectrpc::conformance::StreamingOutputCallResponse>* /*writer*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with split streamed + virtual ::grpc::Status StreamedStreamingOutputCall(::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< ::connectrpc::conformance::StreamingOutputCallRequest,::connectrpc::conformance::StreamingOutputCallResponse>* server_split_streamer) = 0; + }; + template + class WithSplitStreamingMethod_FailStreamingOutputCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithSplitStreamingMethod_FailStreamingOutputCall() { + ::grpc::Service::MarkMethodStreamed(5, + new ::grpc::internal::SplitServerStreamingHandler< + ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>( + [this](::grpc::ServerContext* context, + ::grpc::ServerSplitStreamer< + ::connectrpc::conformance::StreamingOutputCallRequest, ::connectrpc::conformance::StreamingOutputCallResponse>* streamer) { + return this->StreamedFailStreamingOutputCall(context, + streamer); + })); + } + ~WithSplitStreamingMethod_FailStreamingOutputCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status FailStreamingOutputCall(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::StreamingOutputCallRequest* /*request*/, ::grpc::ServerWriter< ::connectrpc::conformance::StreamingOutputCallResponse>* /*writer*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with split streamed + virtual ::grpc::Status StreamedFailStreamingOutputCall(::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< ::connectrpc::conformance::StreamingOutputCallRequest,::connectrpc::conformance::StreamingOutputCallResponse>* server_split_streamer) = 0; + }; + template + class WithSplitStreamingMethod_UnimplementedStreamingOutputCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithSplitStreamingMethod_UnimplementedStreamingOutputCall() { + ::grpc::Service::MarkMethodStreamed(10, + new ::grpc::internal::SplitServerStreamingHandler< + ::google::protobuf::Empty, ::google::protobuf::Empty>( + [this](::grpc::ServerContext* context, + ::grpc::ServerSplitStreamer< + ::google::protobuf::Empty, ::google::protobuf::Empty>* streamer) { + return this->StreamedUnimplementedStreamingOutputCall(context, + streamer); + })); + } + ~WithSplitStreamingMethod_UnimplementedStreamingOutputCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status UnimplementedStreamingOutputCall(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::grpc::ServerWriter< ::google::protobuf::Empty>* /*writer*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with split streamed + virtual ::grpc::Status StreamedUnimplementedStreamingOutputCall(::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< ::google::protobuf::Empty,::google::protobuf::Empty>* server_split_streamer) = 0; + }; + typedef WithSplitStreamingMethod_StreamingOutputCall > > SplitStreamedService; + typedef WithStreamedUnaryMethod_EmptyCall > > > > > > > StreamedService; +}; + +// A simple service NOT implemented at servers so clients can test for +// that case. +class UnimplementedService final { + public: + static constexpr char const* service_full_name() { + return "connectrpc.conformance.UnimplementedService"; + } + class StubInterface { + public: + virtual ~StubInterface() {} + // A call that no server should implement + virtual ::grpc::Status UnimplementedCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::google::protobuf::Empty* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>> AsyncUnimplementedCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>>(AsyncUnimplementedCallRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>> PrepareAsyncUnimplementedCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>>(PrepareAsyncUnimplementedCallRaw(context, request, cq)); + } + // A call that no server should implement + std::unique_ptr< ::grpc::ClientReaderInterface< ::google::protobuf::Empty>> UnimplementedStreamingOutputCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request) { + return std::unique_ptr< ::grpc::ClientReaderInterface< ::google::protobuf::Empty>>(UnimplementedStreamingOutputCallRaw(context, request)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::google::protobuf::Empty>> AsyncUnimplementedStreamingOutputCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::google::protobuf::Empty>>(AsyncUnimplementedStreamingOutputCallRaw(context, request, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::google::protobuf::Empty>> PrepareAsyncUnimplementedStreamingOutputCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::google::protobuf::Empty>>(PrepareAsyncUnimplementedStreamingOutputCallRaw(context, request, cq)); + } + class async_interface { + public: + virtual ~async_interface() {} + // A call that no server should implement + virtual void UnimplementedCall(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response, std::function) = 0; + virtual void UnimplementedCall(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) = 0; + // A call that no server should implement + virtual void UnimplementedStreamingOutputCall(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::grpc::ClientReadReactor< ::google::protobuf::Empty>* reactor) = 0; + }; + typedef class async_interface experimental_async_interface; + virtual class async_interface* async() { return nullptr; } + class async_interface* experimental_async() { return async(); } + private: + virtual ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>* AsyncUnimplementedCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>* PrepareAsyncUnimplementedCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientReaderInterface< ::google::protobuf::Empty>* UnimplementedStreamingOutputCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request) = 0; + virtual ::grpc::ClientAsyncReaderInterface< ::google::protobuf::Empty>* AsyncUnimplementedStreamingOutputCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq, void* tag) = 0; + virtual ::grpc::ClientAsyncReaderInterface< ::google::protobuf::Empty>* PrepareAsyncUnimplementedStreamingOutputCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; + }; + class Stub final : public StubInterface { + public: + Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); + ::grpc::Status UnimplementedCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::google::protobuf::Empty* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>> AsyncUnimplementedCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>>(AsyncUnimplementedCallRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>> PrepareAsyncUnimplementedCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>>(PrepareAsyncUnimplementedCallRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientReader< ::google::protobuf::Empty>> UnimplementedStreamingOutputCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request) { + return std::unique_ptr< ::grpc::ClientReader< ::google::protobuf::Empty>>(UnimplementedStreamingOutputCallRaw(context, request)); + } + std::unique_ptr< ::grpc::ClientAsyncReader< ::google::protobuf::Empty>> AsyncUnimplementedStreamingOutputCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReader< ::google::protobuf::Empty>>(AsyncUnimplementedStreamingOutputCallRaw(context, request, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncReader< ::google::protobuf::Empty>> PrepareAsyncUnimplementedStreamingOutputCall(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReader< ::google::protobuf::Empty>>(PrepareAsyncUnimplementedStreamingOutputCallRaw(context, request, cq)); + } + class async final : + public StubInterface::async_interface { + public: + void UnimplementedCall(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response, std::function) override; + void UnimplementedCall(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) override; + void UnimplementedStreamingOutputCall(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::grpc::ClientReadReactor< ::google::protobuf::Empty>* reactor) override; + private: + friend class Stub; + explicit async(Stub* stub): stub_(stub) { } + Stub* stub() { return stub_; } + Stub* stub_; + }; + class async* async() override { return &async_stub_; } + + private: + std::shared_ptr< ::grpc::ChannelInterface> channel_; + class async async_stub_{this}; + ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* AsyncUnimplementedCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* PrepareAsyncUnimplementedCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientReader< ::google::protobuf::Empty>* UnimplementedStreamingOutputCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request) override; + ::grpc::ClientAsyncReader< ::google::protobuf::Empty>* AsyncUnimplementedStreamingOutputCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq, void* tag) override; + ::grpc::ClientAsyncReader< ::google::protobuf::Empty>* PrepareAsyncUnimplementedStreamingOutputCallRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; + const ::grpc::internal::RpcMethod rpcmethod_UnimplementedCall_; + const ::grpc::internal::RpcMethod rpcmethod_UnimplementedStreamingOutputCall_; + }; + static std::unique_ptr NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); + + class Service : public ::grpc::Service { + public: + Service(); + virtual ~Service(); + // A call that no server should implement + virtual ::grpc::Status UnimplementedCall(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response); + // A call that no server should implement + virtual ::grpc::Status UnimplementedStreamingOutputCall(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::grpc::ServerWriter< ::google::protobuf::Empty>* writer); + }; + template + class WithAsyncMethod_UnimplementedCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_UnimplementedCall() { + ::grpc::Service::MarkMethodAsync(0); + } + ~WithAsyncMethod_UnimplementedCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status UnimplementedCall(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestUnimplementedCall(::grpc::ServerContext* context, ::google::protobuf::Empty* request, ::grpc::ServerAsyncResponseWriter< ::google::protobuf::Empty>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_UnimplementedStreamingOutputCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_UnimplementedStreamingOutputCall() { + ::grpc::Service::MarkMethodAsync(1); + } + ~WithAsyncMethod_UnimplementedStreamingOutputCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status UnimplementedStreamingOutputCall(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::grpc::ServerWriter< ::google::protobuf::Empty>* /*writer*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestUnimplementedStreamingOutputCall(::grpc::ServerContext* context, ::google::protobuf::Empty* request, ::grpc::ServerAsyncWriter< ::google::protobuf::Empty>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncServerStreaming(1, context, request, writer, new_call_cq, notification_cq, tag); + } + }; + typedef WithAsyncMethod_UnimplementedCall > AsyncService; + template + class WithCallbackMethod_UnimplementedCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_UnimplementedCall() { + ::grpc::Service::MarkMethodCallback(0, + new ::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::google::protobuf::Empty>( + [this]( + ::grpc::CallbackServerContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response) { return this->UnimplementedCall(context, request, response); }));} + void SetMessageAllocatorFor_UnimplementedCall( + ::grpc::MessageAllocator< ::google::protobuf::Empty, ::google::protobuf::Empty>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0); + static_cast<::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::google::protobuf::Empty>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_UnimplementedCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status UnimplementedCall(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* UnimplementedCall( + ::grpc::CallbackServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) { return nullptr; } + }; + template + class WithCallbackMethod_UnimplementedStreamingOutputCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_UnimplementedStreamingOutputCall() { + ::grpc::Service::MarkMethodCallback(1, + new ::grpc::internal::CallbackServerStreamingHandler< ::google::protobuf::Empty, ::google::protobuf::Empty>( + [this]( + ::grpc::CallbackServerContext* context, const ::google::protobuf::Empty* request) { return this->UnimplementedStreamingOutputCall(context, request); })); + } + ~WithCallbackMethod_UnimplementedStreamingOutputCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status UnimplementedStreamingOutputCall(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::grpc::ServerWriter< ::google::protobuf::Empty>* /*writer*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerWriteReactor< ::google::protobuf::Empty>* UnimplementedStreamingOutputCall( + ::grpc::CallbackServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/) { return nullptr; } + }; + typedef WithCallbackMethod_UnimplementedCall > CallbackService; + typedef CallbackService ExperimentalCallbackService; + template + class WithGenericMethod_UnimplementedCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_UnimplementedCall() { + ::grpc::Service::MarkMethodGeneric(0); + } + ~WithGenericMethod_UnimplementedCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status UnimplementedCall(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_UnimplementedStreamingOutputCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_UnimplementedStreamingOutputCall() { + ::grpc::Service::MarkMethodGeneric(1); + } + ~WithGenericMethod_UnimplementedStreamingOutputCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status UnimplementedStreamingOutputCall(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::grpc::ServerWriter< ::google::protobuf::Empty>* /*writer*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithRawMethod_UnimplementedCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_UnimplementedCall() { + ::grpc::Service::MarkMethodRaw(0); + } + ~WithRawMethod_UnimplementedCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status UnimplementedCall(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestUnimplementedCall(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_UnimplementedStreamingOutputCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_UnimplementedStreamingOutputCall() { + ::grpc::Service::MarkMethodRaw(1); + } + ~WithRawMethod_UnimplementedStreamingOutputCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status UnimplementedStreamingOutputCall(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::grpc::ServerWriter< ::google::protobuf::Empty>* /*writer*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestUnimplementedStreamingOutputCall(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncWriter< ::grpc::ByteBuffer>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncServerStreaming(1, context, request, writer, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawCallbackMethod_UnimplementedCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_UnimplementedCall() { + ::grpc::Service::MarkMethodRawCallback(0, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->UnimplementedCall(context, request, response); })); + } + ~WithRawCallbackMethod_UnimplementedCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status UnimplementedCall(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* UnimplementedCall( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_UnimplementedStreamingOutputCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_UnimplementedStreamingOutputCall() { + ::grpc::Service::MarkMethodRawCallback(1, + new ::grpc::internal::CallbackServerStreamingHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const::grpc::ByteBuffer* request) { return this->UnimplementedStreamingOutputCall(context, request); })); + } + ~WithRawCallbackMethod_UnimplementedStreamingOutputCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status UnimplementedStreamingOutputCall(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::grpc::ServerWriter< ::google::protobuf::Empty>* /*writer*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerWriteReactor< ::grpc::ByteBuffer>* UnimplementedStreamingOutputCall( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/) { return nullptr; } + }; + template + class WithStreamedUnaryMethod_UnimplementedCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_UnimplementedCall() { + ::grpc::Service::MarkMethodStreamed(0, + new ::grpc::internal::StreamedUnaryHandler< + ::google::protobuf::Empty, ::google::protobuf::Empty>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::google::protobuf::Empty, ::google::protobuf::Empty>* streamer) { + return this->StreamedUnimplementedCall(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_UnimplementedCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status UnimplementedCall(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedUnimplementedCall(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty,::google::protobuf::Empty>* server_unary_streamer) = 0; + }; + typedef WithStreamedUnaryMethod_UnimplementedCall StreamedUnaryService; + template + class WithSplitStreamingMethod_UnimplementedStreamingOutputCall : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithSplitStreamingMethod_UnimplementedStreamingOutputCall() { + ::grpc::Service::MarkMethodStreamed(1, + new ::grpc::internal::SplitServerStreamingHandler< + ::google::protobuf::Empty, ::google::protobuf::Empty>( + [this](::grpc::ServerContext* context, + ::grpc::ServerSplitStreamer< + ::google::protobuf::Empty, ::google::protobuf::Empty>* streamer) { + return this->StreamedUnimplementedStreamingOutputCall(context, + streamer); + })); + } + ~WithSplitStreamingMethod_UnimplementedStreamingOutputCall() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status UnimplementedStreamingOutputCall(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::grpc::ServerWriter< ::google::protobuf::Empty>* /*writer*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with split streamed + virtual ::grpc::Status StreamedUnimplementedStreamingOutputCall(::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< ::google::protobuf::Empty,::google::protobuf::Empty>* server_split_streamer) = 0; + }; + typedef WithSplitStreamingMethod_UnimplementedStreamingOutputCall SplitStreamedService; + typedef WithStreamedUnaryMethod_UnimplementedCall > StreamedService; +}; + +// A service used to control reconnect server. +class ReconnectService final { + public: + static constexpr char const* service_full_name() { + return "connectrpc.conformance.ReconnectService"; + } + class StubInterface { + public: + virtual ~StubInterface() {} + virtual ::grpc::Status Start(::grpc::ClientContext* context, const ::connectrpc::conformance::ReconnectParams& request, ::google::protobuf::Empty* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>> AsyncStart(::grpc::ClientContext* context, const ::connectrpc::conformance::ReconnectParams& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>>(AsyncStartRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>> PrepareAsyncStart(::grpc::ClientContext* context, const ::connectrpc::conformance::ReconnectParams& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>>(PrepareAsyncStartRaw(context, request, cq)); + } + virtual ::grpc::Status Stop(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::connectrpc::conformance::ReconnectInfo* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::ReconnectInfo>> AsyncStop(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::ReconnectInfo>>(AsyncStopRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::ReconnectInfo>> PrepareAsyncStop(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::ReconnectInfo>>(PrepareAsyncStopRaw(context, request, cq)); + } + class async_interface { + public: + virtual ~async_interface() {} + virtual void Start(::grpc::ClientContext* context, const ::connectrpc::conformance::ReconnectParams* request, ::google::protobuf::Empty* response, std::function) = 0; + virtual void Start(::grpc::ClientContext* context, const ::connectrpc::conformance::ReconnectParams* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) = 0; + virtual void Stop(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::connectrpc::conformance::ReconnectInfo* response, std::function) = 0; + virtual void Stop(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::connectrpc::conformance::ReconnectInfo* response, ::grpc::ClientUnaryReactor* reactor) = 0; + }; + typedef class async_interface experimental_async_interface; + virtual class async_interface* async() { return nullptr; } + class async_interface* experimental_async() { return async(); } + private: + virtual ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>* AsyncStartRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::ReconnectParams& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>* PrepareAsyncStartRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::ReconnectParams& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::ReconnectInfo>* AsyncStopRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::ReconnectInfo>* PrepareAsyncStopRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; + }; + class Stub final : public StubInterface { + public: + Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); + ::grpc::Status Start(::grpc::ClientContext* context, const ::connectrpc::conformance::ReconnectParams& request, ::google::protobuf::Empty* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>> AsyncStart(::grpc::ClientContext* context, const ::connectrpc::conformance::ReconnectParams& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>>(AsyncStartRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>> PrepareAsyncStart(::grpc::ClientContext* context, const ::connectrpc::conformance::ReconnectParams& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>>(PrepareAsyncStartRaw(context, request, cq)); + } + ::grpc::Status Stop(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::connectrpc::conformance::ReconnectInfo* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::ReconnectInfo>> AsyncStop(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::ReconnectInfo>>(AsyncStopRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::ReconnectInfo>> PrepareAsyncStop(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::ReconnectInfo>>(PrepareAsyncStopRaw(context, request, cq)); + } + class async final : + public StubInterface::async_interface { + public: + void Start(::grpc::ClientContext* context, const ::connectrpc::conformance::ReconnectParams* request, ::google::protobuf::Empty* response, std::function) override; + void Start(::grpc::ClientContext* context, const ::connectrpc::conformance::ReconnectParams* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) override; + void Stop(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::connectrpc::conformance::ReconnectInfo* response, std::function) override; + void Stop(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::connectrpc::conformance::ReconnectInfo* response, ::grpc::ClientUnaryReactor* reactor) override; + private: + friend class Stub; + explicit async(Stub* stub): stub_(stub) { } + Stub* stub() { return stub_; } + Stub* stub_; + }; + class async* async() override { return &async_stub_; } + + private: + std::shared_ptr< ::grpc::ChannelInterface> channel_; + class async async_stub_{this}; + ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* AsyncStartRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::ReconnectParams& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* PrepareAsyncStartRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::ReconnectParams& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::ReconnectInfo>* AsyncStopRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::ReconnectInfo>* PrepareAsyncStopRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; + const ::grpc::internal::RpcMethod rpcmethod_Start_; + const ::grpc::internal::RpcMethod rpcmethod_Stop_; + }; + static std::unique_ptr NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); + + class Service : public ::grpc::Service { + public: + Service(); + virtual ~Service(); + virtual ::grpc::Status Start(::grpc::ServerContext* context, const ::connectrpc::conformance::ReconnectParams* request, ::google::protobuf::Empty* response); + virtual ::grpc::Status Stop(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::connectrpc::conformance::ReconnectInfo* response); + }; + template + class WithAsyncMethod_Start : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_Start() { + ::grpc::Service::MarkMethodAsync(0); + } + ~WithAsyncMethod_Start() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Start(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::ReconnectParams* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestStart(::grpc::ServerContext* context, ::connectrpc::conformance::ReconnectParams* request, ::grpc::ServerAsyncResponseWriter< ::google::protobuf::Empty>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_Stop : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_Stop() { + ::grpc::Service::MarkMethodAsync(1); + } + ~WithAsyncMethod_Stop() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Stop(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::connectrpc::conformance::ReconnectInfo* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestStop(::grpc::ServerContext* context, ::google::protobuf::Empty* request, ::grpc::ServerAsyncResponseWriter< ::connectrpc::conformance::ReconnectInfo>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); + } + }; + typedef WithAsyncMethod_Start > AsyncService; + template + class WithCallbackMethod_Start : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_Start() { + ::grpc::Service::MarkMethodCallback(0, + new ::grpc::internal::CallbackUnaryHandler< ::connectrpc::conformance::ReconnectParams, ::google::protobuf::Empty>( + [this]( + ::grpc::CallbackServerContext* context, const ::connectrpc::conformance::ReconnectParams* request, ::google::protobuf::Empty* response) { return this->Start(context, request, response); }));} + void SetMessageAllocatorFor_Start( + ::grpc::MessageAllocator< ::connectrpc::conformance::ReconnectParams, ::google::protobuf::Empty>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0); + static_cast<::grpc::internal::CallbackUnaryHandler< ::connectrpc::conformance::ReconnectParams, ::google::protobuf::Empty>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_Start() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Start(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::ReconnectParams* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* Start( + ::grpc::CallbackServerContext* /*context*/, const ::connectrpc::conformance::ReconnectParams* /*request*/, ::google::protobuf::Empty* /*response*/) { return nullptr; } + }; + template + class WithCallbackMethod_Stop : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_Stop() { + ::grpc::Service::MarkMethodCallback(1, + new ::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::connectrpc::conformance::ReconnectInfo>( + [this]( + ::grpc::CallbackServerContext* context, const ::google::protobuf::Empty* request, ::connectrpc::conformance::ReconnectInfo* response) { return this->Stop(context, request, response); }));} + void SetMessageAllocatorFor_Stop( + ::grpc::MessageAllocator< ::google::protobuf::Empty, ::connectrpc::conformance::ReconnectInfo>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1); + static_cast<::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::connectrpc::conformance::ReconnectInfo>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_Stop() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Stop(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::connectrpc::conformance::ReconnectInfo* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* Stop( + ::grpc::CallbackServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::connectrpc::conformance::ReconnectInfo* /*response*/) { return nullptr; } + }; + typedef WithCallbackMethod_Start > CallbackService; + typedef CallbackService ExperimentalCallbackService; + template + class WithGenericMethod_Start : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_Start() { + ::grpc::Service::MarkMethodGeneric(0); + } + ~WithGenericMethod_Start() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Start(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::ReconnectParams* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_Stop : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_Stop() { + ::grpc::Service::MarkMethodGeneric(1); + } + ~WithGenericMethod_Stop() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Stop(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::connectrpc::conformance::ReconnectInfo* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithRawMethod_Start : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_Start() { + ::grpc::Service::MarkMethodRaw(0); + } + ~WithRawMethod_Start() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Start(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::ReconnectParams* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestStart(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_Stop : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_Stop() { + ::grpc::Service::MarkMethodRaw(1); + } + ~WithRawMethod_Stop() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Stop(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::connectrpc::conformance::ReconnectInfo* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestStop(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawCallbackMethod_Start : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_Start() { + ::grpc::Service::MarkMethodRawCallback(0, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Start(context, request, response); })); + } + ~WithRawCallbackMethod_Start() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Start(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::ReconnectParams* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* Start( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_Stop : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_Stop() { + ::grpc::Service::MarkMethodRawCallback(1, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Stop(context, request, response); })); + } + ~WithRawCallbackMethod_Stop() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Stop(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::connectrpc::conformance::ReconnectInfo* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* Stop( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithStreamedUnaryMethod_Start : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_Start() { + ::grpc::Service::MarkMethodStreamed(0, + new ::grpc::internal::StreamedUnaryHandler< + ::connectrpc::conformance::ReconnectParams, ::google::protobuf::Empty>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::connectrpc::conformance::ReconnectParams, ::google::protobuf::Empty>* streamer) { + return this->StreamedStart(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_Start() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status Start(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::ReconnectParams* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedStart(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::connectrpc::conformance::ReconnectParams,::google::protobuf::Empty>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_Stop : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_Stop() { + ::grpc::Service::MarkMethodStreamed(1, + new ::grpc::internal::StreamedUnaryHandler< + ::google::protobuf::Empty, ::connectrpc::conformance::ReconnectInfo>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::google::protobuf::Empty, ::connectrpc::conformance::ReconnectInfo>* streamer) { + return this->StreamedStop(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_Stop() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status Stop(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::connectrpc::conformance::ReconnectInfo* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedStop(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty,::connectrpc::conformance::ReconnectInfo>* server_unary_streamer) = 0; + }; + typedef WithStreamedUnaryMethod_Start > StreamedUnaryService; + typedef Service SplitStreamedService; + typedef WithStreamedUnaryMethod_Start > StreamedService; +}; + +// A service used to obtain stats for verifying LB behavior. +class LoadBalancerStatsService final { + public: + static constexpr char const* service_full_name() { + return "connectrpc.conformance.LoadBalancerStatsService"; + } + class StubInterface { + public: + virtual ~StubInterface() {} + // Gets the backend distribution for RPCs sent by a test client. + virtual ::grpc::Status GetClientStats(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerStatsRequest& request, ::connectrpc::conformance::LoadBalancerStatsResponse* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::LoadBalancerStatsResponse>> AsyncGetClientStats(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerStatsRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::LoadBalancerStatsResponse>>(AsyncGetClientStatsRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::LoadBalancerStatsResponse>> PrepareAsyncGetClientStats(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerStatsRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::LoadBalancerStatsResponse>>(PrepareAsyncGetClientStatsRaw(context, request, cq)); + } + // Gets the accumulated stats for RPCs sent by a test client. + virtual ::grpc::Status GetClientAccumulatedStats(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest& request, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse>> AsyncGetClientAccumulatedStats(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse>>(AsyncGetClientAccumulatedStatsRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse>> PrepareAsyncGetClientAccumulatedStats(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse>>(PrepareAsyncGetClientAccumulatedStatsRaw(context, request, cq)); + } + class async_interface { + public: + virtual ~async_interface() {} + // Gets the backend distribution for RPCs sent by a test client. + virtual void GetClientStats(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerStatsRequest* request, ::connectrpc::conformance::LoadBalancerStatsResponse* response, std::function) = 0; + virtual void GetClientStats(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerStatsRequest* request, ::connectrpc::conformance::LoadBalancerStatsResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; + // Gets the accumulated stats for RPCs sent by a test client. + virtual void GetClientAccumulatedStats(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest* request, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse* response, std::function) = 0; + virtual void GetClientAccumulatedStats(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest* request, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; + }; + typedef class async_interface experimental_async_interface; + virtual class async_interface* async() { return nullptr; } + class async_interface* experimental_async() { return async(); } + private: + virtual ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::LoadBalancerStatsResponse>* AsyncGetClientStatsRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerStatsRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::LoadBalancerStatsResponse>* PrepareAsyncGetClientStatsRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerStatsRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse>* AsyncGetClientAccumulatedStatsRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse>* PrepareAsyncGetClientAccumulatedStatsRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest& request, ::grpc::CompletionQueue* cq) = 0; + }; + class Stub final : public StubInterface { + public: + Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); + ::grpc::Status GetClientStats(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerStatsRequest& request, ::connectrpc::conformance::LoadBalancerStatsResponse* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::LoadBalancerStatsResponse>> AsyncGetClientStats(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerStatsRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::LoadBalancerStatsResponse>>(AsyncGetClientStatsRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::LoadBalancerStatsResponse>> PrepareAsyncGetClientStats(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerStatsRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::LoadBalancerStatsResponse>>(PrepareAsyncGetClientStatsRaw(context, request, cq)); + } + ::grpc::Status GetClientAccumulatedStats(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest& request, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse>> AsyncGetClientAccumulatedStats(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse>>(AsyncGetClientAccumulatedStatsRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse>> PrepareAsyncGetClientAccumulatedStats(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse>>(PrepareAsyncGetClientAccumulatedStatsRaw(context, request, cq)); + } + class async final : + public StubInterface::async_interface { + public: + void GetClientStats(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerStatsRequest* request, ::connectrpc::conformance::LoadBalancerStatsResponse* response, std::function) override; + void GetClientStats(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerStatsRequest* request, ::connectrpc::conformance::LoadBalancerStatsResponse* response, ::grpc::ClientUnaryReactor* reactor) override; + void GetClientAccumulatedStats(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest* request, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse* response, std::function) override; + void GetClientAccumulatedStats(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest* request, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse* response, ::grpc::ClientUnaryReactor* reactor) override; + private: + friend class Stub; + explicit async(Stub* stub): stub_(stub) { } + Stub* stub() { return stub_; } + Stub* stub_; + }; + class async* async() override { return &async_stub_; } + + private: + std::shared_ptr< ::grpc::ChannelInterface> channel_; + class async async_stub_{this}; + ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::LoadBalancerStatsResponse>* AsyncGetClientStatsRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerStatsRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::LoadBalancerStatsResponse>* PrepareAsyncGetClientStatsRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerStatsRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse>* AsyncGetClientAccumulatedStatsRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse>* PrepareAsyncGetClientAccumulatedStatsRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest& request, ::grpc::CompletionQueue* cq) override; + const ::grpc::internal::RpcMethod rpcmethod_GetClientStats_; + const ::grpc::internal::RpcMethod rpcmethod_GetClientAccumulatedStats_; + }; + static std::unique_ptr NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); + + class Service : public ::grpc::Service { + public: + Service(); + virtual ~Service(); + // Gets the backend distribution for RPCs sent by a test client. + virtual ::grpc::Status GetClientStats(::grpc::ServerContext* context, const ::connectrpc::conformance::LoadBalancerStatsRequest* request, ::connectrpc::conformance::LoadBalancerStatsResponse* response); + // Gets the accumulated stats for RPCs sent by a test client. + virtual ::grpc::Status GetClientAccumulatedStats(::grpc::ServerContext* context, const ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest* request, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse* response); + }; + template + class WithAsyncMethod_GetClientStats : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_GetClientStats() { + ::grpc::Service::MarkMethodAsync(0); + } + ~WithAsyncMethod_GetClientStats() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetClientStats(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::LoadBalancerStatsRequest* /*request*/, ::connectrpc::conformance::LoadBalancerStatsResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestGetClientStats(::grpc::ServerContext* context, ::connectrpc::conformance::LoadBalancerStatsRequest* request, ::grpc::ServerAsyncResponseWriter< ::connectrpc::conformance::LoadBalancerStatsResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_GetClientAccumulatedStats : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_GetClientAccumulatedStats() { + ::grpc::Service::MarkMethodAsync(1); + } + ~WithAsyncMethod_GetClientAccumulatedStats() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetClientAccumulatedStats(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest* /*request*/, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestGetClientAccumulatedStats(::grpc::ServerContext* context, ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest* request, ::grpc::ServerAsyncResponseWriter< ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); + } + }; + typedef WithAsyncMethod_GetClientStats > AsyncService; + template + class WithCallbackMethod_GetClientStats : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_GetClientStats() { + ::grpc::Service::MarkMethodCallback(0, + new ::grpc::internal::CallbackUnaryHandler< ::connectrpc::conformance::LoadBalancerStatsRequest, ::connectrpc::conformance::LoadBalancerStatsResponse>( + [this]( + ::grpc::CallbackServerContext* context, const ::connectrpc::conformance::LoadBalancerStatsRequest* request, ::connectrpc::conformance::LoadBalancerStatsResponse* response) { return this->GetClientStats(context, request, response); }));} + void SetMessageAllocatorFor_GetClientStats( + ::grpc::MessageAllocator< ::connectrpc::conformance::LoadBalancerStatsRequest, ::connectrpc::conformance::LoadBalancerStatsResponse>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0); + static_cast<::grpc::internal::CallbackUnaryHandler< ::connectrpc::conformance::LoadBalancerStatsRequest, ::connectrpc::conformance::LoadBalancerStatsResponse>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_GetClientStats() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetClientStats(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::LoadBalancerStatsRequest* /*request*/, ::connectrpc::conformance::LoadBalancerStatsResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* GetClientStats( + ::grpc::CallbackServerContext* /*context*/, const ::connectrpc::conformance::LoadBalancerStatsRequest* /*request*/, ::connectrpc::conformance::LoadBalancerStatsResponse* /*response*/) { return nullptr; } + }; + template + class WithCallbackMethod_GetClientAccumulatedStats : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_GetClientAccumulatedStats() { + ::grpc::Service::MarkMethodCallback(1, + new ::grpc::internal::CallbackUnaryHandler< ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse>( + [this]( + ::grpc::CallbackServerContext* context, const ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest* request, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse* response) { return this->GetClientAccumulatedStats(context, request, response); }));} + void SetMessageAllocatorFor_GetClientAccumulatedStats( + ::grpc::MessageAllocator< ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1); + static_cast<::grpc::internal::CallbackUnaryHandler< ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_GetClientAccumulatedStats() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetClientAccumulatedStats(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest* /*request*/, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* GetClientAccumulatedStats( + ::grpc::CallbackServerContext* /*context*/, const ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest* /*request*/, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse* /*response*/) { return nullptr; } + }; + typedef WithCallbackMethod_GetClientStats > CallbackService; + typedef CallbackService ExperimentalCallbackService; + template + class WithGenericMethod_GetClientStats : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_GetClientStats() { + ::grpc::Service::MarkMethodGeneric(0); + } + ~WithGenericMethod_GetClientStats() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetClientStats(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::LoadBalancerStatsRequest* /*request*/, ::connectrpc::conformance::LoadBalancerStatsResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_GetClientAccumulatedStats : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_GetClientAccumulatedStats() { + ::grpc::Service::MarkMethodGeneric(1); + } + ~WithGenericMethod_GetClientAccumulatedStats() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetClientAccumulatedStats(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest* /*request*/, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithRawMethod_GetClientStats : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_GetClientStats() { + ::grpc::Service::MarkMethodRaw(0); + } + ~WithRawMethod_GetClientStats() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetClientStats(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::LoadBalancerStatsRequest* /*request*/, ::connectrpc::conformance::LoadBalancerStatsResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestGetClientStats(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_GetClientAccumulatedStats : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_GetClientAccumulatedStats() { + ::grpc::Service::MarkMethodRaw(1); + } + ~WithRawMethod_GetClientAccumulatedStats() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetClientAccumulatedStats(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest* /*request*/, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestGetClientAccumulatedStats(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawCallbackMethod_GetClientStats : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_GetClientStats() { + ::grpc::Service::MarkMethodRawCallback(0, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->GetClientStats(context, request, response); })); + } + ~WithRawCallbackMethod_GetClientStats() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetClientStats(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::LoadBalancerStatsRequest* /*request*/, ::connectrpc::conformance::LoadBalancerStatsResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* GetClientStats( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_GetClientAccumulatedStats : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_GetClientAccumulatedStats() { + ::grpc::Service::MarkMethodRawCallback(1, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->GetClientAccumulatedStats(context, request, response); })); + } + ~WithRawCallbackMethod_GetClientAccumulatedStats() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetClientAccumulatedStats(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest* /*request*/, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* GetClientAccumulatedStats( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithStreamedUnaryMethod_GetClientStats : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_GetClientStats() { + ::grpc::Service::MarkMethodStreamed(0, + new ::grpc::internal::StreamedUnaryHandler< + ::connectrpc::conformance::LoadBalancerStatsRequest, ::connectrpc::conformance::LoadBalancerStatsResponse>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::connectrpc::conformance::LoadBalancerStatsRequest, ::connectrpc::conformance::LoadBalancerStatsResponse>* streamer) { + return this->StreamedGetClientStats(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_GetClientStats() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status GetClientStats(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::LoadBalancerStatsRequest* /*request*/, ::connectrpc::conformance::LoadBalancerStatsResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedGetClientStats(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::connectrpc::conformance::LoadBalancerStatsRequest,::connectrpc::conformance::LoadBalancerStatsResponse>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_GetClientAccumulatedStats : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_GetClientAccumulatedStats() { + ::grpc::Service::MarkMethodStreamed(1, + new ::grpc::internal::StreamedUnaryHandler< + ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse>* streamer) { + return this->StreamedGetClientAccumulatedStats(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_GetClientAccumulatedStats() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status GetClientAccumulatedStats(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest* /*request*/, ::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedGetClientAccumulatedStats(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::connectrpc::conformance::LoadBalancerAccumulatedStatsRequest,::connectrpc::conformance::LoadBalancerAccumulatedStatsResponse>* server_unary_streamer) = 0; + }; + typedef WithStreamedUnaryMethod_GetClientStats > StreamedUnaryService; + typedef Service SplitStreamedService; + typedef WithStreamedUnaryMethod_GetClientStats > StreamedService; +}; + +// A service to remotely control health status of an xDS test server. +class XdsUpdateHealthService final { + public: + static constexpr char const* service_full_name() { + return "connectrpc.conformance.XdsUpdateHealthService"; + } + class StubInterface { + public: + virtual ~StubInterface() {} + virtual ::grpc::Status SetServing(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::google::protobuf::Empty* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>> AsyncSetServing(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>>(AsyncSetServingRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>> PrepareAsyncSetServing(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>>(PrepareAsyncSetServingRaw(context, request, cq)); + } + virtual ::grpc::Status SetNotServing(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::google::protobuf::Empty* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>> AsyncSetNotServing(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>>(AsyncSetNotServingRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>> PrepareAsyncSetNotServing(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>>(PrepareAsyncSetNotServingRaw(context, request, cq)); + } + class async_interface { + public: + virtual ~async_interface() {} + virtual void SetServing(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response, std::function) = 0; + virtual void SetServing(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) = 0; + virtual void SetNotServing(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response, std::function) = 0; + virtual void SetNotServing(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) = 0; + }; + typedef class async_interface experimental_async_interface; + virtual class async_interface* async() { return nullptr; } + class async_interface* experimental_async() { return async(); } + private: + virtual ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>* AsyncSetServingRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>* PrepareAsyncSetServingRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>* AsyncSetNotServingRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>* PrepareAsyncSetNotServingRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; + }; + class Stub final : public StubInterface { + public: + Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); + ::grpc::Status SetServing(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::google::protobuf::Empty* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>> AsyncSetServing(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>>(AsyncSetServingRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>> PrepareAsyncSetServing(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>>(PrepareAsyncSetServingRaw(context, request, cq)); + } + ::grpc::Status SetNotServing(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::google::protobuf::Empty* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>> AsyncSetNotServing(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>>(AsyncSetNotServingRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>> PrepareAsyncSetNotServing(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>>(PrepareAsyncSetNotServingRaw(context, request, cq)); + } + class async final : + public StubInterface::async_interface { + public: + void SetServing(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response, std::function) override; + void SetServing(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) override; + void SetNotServing(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response, std::function) override; + void SetNotServing(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) override; + private: + friend class Stub; + explicit async(Stub* stub): stub_(stub) { } + Stub* stub() { return stub_; } + Stub* stub_; + }; + class async* async() override { return &async_stub_; } + + private: + std::shared_ptr< ::grpc::ChannelInterface> channel_; + class async async_stub_{this}; + ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* AsyncSetServingRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* PrepareAsyncSetServingRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* AsyncSetNotServingRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* PrepareAsyncSetNotServingRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; + const ::grpc::internal::RpcMethod rpcmethod_SetServing_; + const ::grpc::internal::RpcMethod rpcmethod_SetNotServing_; + }; + static std::unique_ptr NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); + + class Service : public ::grpc::Service { + public: + Service(); + virtual ~Service(); + virtual ::grpc::Status SetServing(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response); + virtual ::grpc::Status SetNotServing(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response); + }; + template + class WithAsyncMethod_SetServing : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_SetServing() { + ::grpc::Service::MarkMethodAsync(0); + } + ~WithAsyncMethod_SetServing() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetServing(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestSetServing(::grpc::ServerContext* context, ::google::protobuf::Empty* request, ::grpc::ServerAsyncResponseWriter< ::google::protobuf::Empty>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_SetNotServing : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_SetNotServing() { + ::grpc::Service::MarkMethodAsync(1); + } + ~WithAsyncMethod_SetNotServing() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetNotServing(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestSetNotServing(::grpc::ServerContext* context, ::google::protobuf::Empty* request, ::grpc::ServerAsyncResponseWriter< ::google::protobuf::Empty>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); + } + }; + typedef WithAsyncMethod_SetServing > AsyncService; + template + class WithCallbackMethod_SetServing : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_SetServing() { + ::grpc::Service::MarkMethodCallback(0, + new ::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::google::protobuf::Empty>( + [this]( + ::grpc::CallbackServerContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response) { return this->SetServing(context, request, response); }));} + void SetMessageAllocatorFor_SetServing( + ::grpc::MessageAllocator< ::google::protobuf::Empty, ::google::protobuf::Empty>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0); + static_cast<::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::google::protobuf::Empty>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_SetServing() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetServing(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* SetServing( + ::grpc::CallbackServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) { return nullptr; } + }; + template + class WithCallbackMethod_SetNotServing : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_SetNotServing() { + ::grpc::Service::MarkMethodCallback(1, + new ::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::google::protobuf::Empty>( + [this]( + ::grpc::CallbackServerContext* context, const ::google::protobuf::Empty* request, ::google::protobuf::Empty* response) { return this->SetNotServing(context, request, response); }));} + void SetMessageAllocatorFor_SetNotServing( + ::grpc::MessageAllocator< ::google::protobuf::Empty, ::google::protobuf::Empty>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1); + static_cast<::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::google::protobuf::Empty>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_SetNotServing() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetNotServing(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* SetNotServing( + ::grpc::CallbackServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) { return nullptr; } + }; + typedef WithCallbackMethod_SetServing > CallbackService; + typedef CallbackService ExperimentalCallbackService; + template + class WithGenericMethod_SetServing : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_SetServing() { + ::grpc::Service::MarkMethodGeneric(0); + } + ~WithGenericMethod_SetServing() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetServing(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_SetNotServing : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_SetNotServing() { + ::grpc::Service::MarkMethodGeneric(1); + } + ~WithGenericMethod_SetNotServing() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetNotServing(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithRawMethod_SetServing : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_SetServing() { + ::grpc::Service::MarkMethodRaw(0); + } + ~WithRawMethod_SetServing() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetServing(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestSetServing(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_SetNotServing : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_SetNotServing() { + ::grpc::Service::MarkMethodRaw(1); + } + ~WithRawMethod_SetNotServing() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetNotServing(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestSetNotServing(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawCallbackMethod_SetServing : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_SetServing() { + ::grpc::Service::MarkMethodRawCallback(0, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->SetServing(context, request, response); })); + } + ~WithRawCallbackMethod_SetServing() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetServing(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* SetServing( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithRawCallbackMethod_SetNotServing : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_SetNotServing() { + ::grpc::Service::MarkMethodRawCallback(1, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->SetNotServing(context, request, response); })); + } + ~WithRawCallbackMethod_SetNotServing() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SetNotServing(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* SetNotServing( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithStreamedUnaryMethod_SetServing : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_SetServing() { + ::grpc::Service::MarkMethodStreamed(0, + new ::grpc::internal::StreamedUnaryHandler< + ::google::protobuf::Empty, ::google::protobuf::Empty>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::google::protobuf::Empty, ::google::protobuf::Empty>* streamer) { + return this->StreamedSetServing(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_SetServing() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status SetServing(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedSetServing(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty,::google::protobuf::Empty>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_SetNotServing : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_SetNotServing() { + ::grpc::Service::MarkMethodStreamed(1, + new ::grpc::internal::StreamedUnaryHandler< + ::google::protobuf::Empty, ::google::protobuf::Empty>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::google::protobuf::Empty, ::google::protobuf::Empty>* streamer) { + return this->StreamedSetNotServing(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_SetNotServing() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status SetNotServing(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedSetNotServing(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty,::google::protobuf::Empty>* server_unary_streamer) = 0; + }; + typedef WithStreamedUnaryMethod_SetServing > StreamedUnaryService; + typedef Service SplitStreamedService; + typedef WithStreamedUnaryMethod_SetServing > StreamedService; +}; + +// A service to dynamically update the configuration of an xDS test client. +class XdsUpdateClientConfigureService final { + public: + static constexpr char const* service_full_name() { + return "connectrpc.conformance.XdsUpdateClientConfigureService"; + } + class StubInterface { + public: + virtual ~StubInterface() {} + // Update the tes client's configuration. + virtual ::grpc::Status Configure(::grpc::ClientContext* context, const ::connectrpc::conformance::ClientConfigureRequest& request, ::connectrpc::conformance::ClientConfigureResponse* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::ClientConfigureResponse>> AsyncConfigure(::grpc::ClientContext* context, const ::connectrpc::conformance::ClientConfigureRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::ClientConfigureResponse>>(AsyncConfigureRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::ClientConfigureResponse>> PrepareAsyncConfigure(::grpc::ClientContext* context, const ::connectrpc::conformance::ClientConfigureRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::ClientConfigureResponse>>(PrepareAsyncConfigureRaw(context, request, cq)); + } + class async_interface { + public: + virtual ~async_interface() {} + // Update the tes client's configuration. + virtual void Configure(::grpc::ClientContext* context, const ::connectrpc::conformance::ClientConfigureRequest* request, ::connectrpc::conformance::ClientConfigureResponse* response, std::function) = 0; + virtual void Configure(::grpc::ClientContext* context, const ::connectrpc::conformance::ClientConfigureRequest* request, ::connectrpc::conformance::ClientConfigureResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; + }; + typedef class async_interface experimental_async_interface; + virtual class async_interface* async() { return nullptr; } + class async_interface* experimental_async() { return async(); } + private: + virtual ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::ClientConfigureResponse>* AsyncConfigureRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::ClientConfigureRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::connectrpc::conformance::ClientConfigureResponse>* PrepareAsyncConfigureRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::ClientConfigureRequest& request, ::grpc::CompletionQueue* cq) = 0; + }; + class Stub final : public StubInterface { + public: + Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); + ::grpc::Status Configure(::grpc::ClientContext* context, const ::connectrpc::conformance::ClientConfigureRequest& request, ::connectrpc::conformance::ClientConfigureResponse* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::ClientConfigureResponse>> AsyncConfigure(::grpc::ClientContext* context, const ::connectrpc::conformance::ClientConfigureRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::ClientConfigureResponse>>(AsyncConfigureRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::ClientConfigureResponse>> PrepareAsyncConfigure(::grpc::ClientContext* context, const ::connectrpc::conformance::ClientConfigureRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::ClientConfigureResponse>>(PrepareAsyncConfigureRaw(context, request, cq)); + } + class async final : + public StubInterface::async_interface { + public: + void Configure(::grpc::ClientContext* context, const ::connectrpc::conformance::ClientConfigureRequest* request, ::connectrpc::conformance::ClientConfigureResponse* response, std::function) override; + void Configure(::grpc::ClientContext* context, const ::connectrpc::conformance::ClientConfigureRequest* request, ::connectrpc::conformance::ClientConfigureResponse* response, ::grpc::ClientUnaryReactor* reactor) override; + private: + friend class Stub; + explicit async(Stub* stub): stub_(stub) { } + Stub* stub() { return stub_; } + Stub* stub_; + }; + class async* async() override { return &async_stub_; } + + private: + std::shared_ptr< ::grpc::ChannelInterface> channel_; + class async async_stub_{this}; + ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::ClientConfigureResponse>* AsyncConfigureRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::ClientConfigureRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::connectrpc::conformance::ClientConfigureResponse>* PrepareAsyncConfigureRaw(::grpc::ClientContext* context, const ::connectrpc::conformance::ClientConfigureRequest& request, ::grpc::CompletionQueue* cq) override; + const ::grpc::internal::RpcMethod rpcmethod_Configure_; + }; + static std::unique_ptr NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); + + class Service : public ::grpc::Service { + public: + Service(); + virtual ~Service(); + // Update the tes client's configuration. + virtual ::grpc::Status Configure(::grpc::ServerContext* context, const ::connectrpc::conformance::ClientConfigureRequest* request, ::connectrpc::conformance::ClientConfigureResponse* response); + }; + template + class WithAsyncMethod_Configure : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_Configure() { + ::grpc::Service::MarkMethodAsync(0); + } + ~WithAsyncMethod_Configure() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Configure(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::ClientConfigureRequest* /*request*/, ::connectrpc::conformance::ClientConfigureResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestConfigure(::grpc::ServerContext* context, ::connectrpc::conformance::ClientConfigureRequest* request, ::grpc::ServerAsyncResponseWriter< ::connectrpc::conformance::ClientConfigureResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); + } + }; + typedef WithAsyncMethod_Configure AsyncService; + template + class WithCallbackMethod_Configure : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_Configure() { + ::grpc::Service::MarkMethodCallback(0, + new ::grpc::internal::CallbackUnaryHandler< ::connectrpc::conformance::ClientConfigureRequest, ::connectrpc::conformance::ClientConfigureResponse>( + [this]( + ::grpc::CallbackServerContext* context, const ::connectrpc::conformance::ClientConfigureRequest* request, ::connectrpc::conformance::ClientConfigureResponse* response) { return this->Configure(context, request, response); }));} + void SetMessageAllocatorFor_Configure( + ::grpc::MessageAllocator< ::connectrpc::conformance::ClientConfigureRequest, ::connectrpc::conformance::ClientConfigureResponse>* allocator) { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0); + static_cast<::grpc::internal::CallbackUnaryHandler< ::connectrpc::conformance::ClientConfigureRequest, ::connectrpc::conformance::ClientConfigureResponse>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_Configure() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Configure(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::ClientConfigureRequest* /*request*/, ::connectrpc::conformance::ClientConfigureResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* Configure( + ::grpc::CallbackServerContext* /*context*/, const ::connectrpc::conformance::ClientConfigureRequest* /*request*/, ::connectrpc::conformance::ClientConfigureResponse* /*response*/) { return nullptr; } + }; + typedef WithCallbackMethod_Configure CallbackService; + typedef CallbackService ExperimentalCallbackService; + template + class WithGenericMethod_Configure : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_Configure() { + ::grpc::Service::MarkMethodGeneric(0); + } + ~WithGenericMethod_Configure() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Configure(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::ClientConfigureRequest* /*request*/, ::connectrpc::conformance::ClientConfigureResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithRawMethod_Configure : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_Configure() { + ::grpc::Service::MarkMethodRaw(0); + } + ~WithRawMethod_Configure() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Configure(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::ClientConfigureRequest* /*request*/, ::connectrpc::conformance::ClientConfigureResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestConfigure(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawCallbackMethod_Configure : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_Configure() { + ::grpc::Service::MarkMethodRawCallback(0, + new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Configure(context, request, response); })); + } + ~WithRawCallbackMethod_Configure() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Configure(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::ClientConfigureRequest* /*request*/, ::connectrpc::conformance::ClientConfigureResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* Configure( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; + template + class WithStreamedUnaryMethod_Configure : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_Configure() { + ::grpc::Service::MarkMethodStreamed(0, + new ::grpc::internal::StreamedUnaryHandler< + ::connectrpc::conformance::ClientConfigureRequest, ::connectrpc::conformance::ClientConfigureResponse>( + [this](::grpc::ServerContext* context, + ::grpc::ServerUnaryStreamer< + ::connectrpc::conformance::ClientConfigureRequest, ::connectrpc::conformance::ClientConfigureResponse>* streamer) { + return this->StreamedConfigure(context, + streamer); + })); + } + ~WithStreamedUnaryMethod_Configure() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status Configure(::grpc::ServerContext* /*context*/, const ::connectrpc::conformance::ClientConfigureRequest* /*request*/, ::connectrpc::conformance::ClientConfigureResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedConfigure(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::connectrpc::conformance::ClientConfigureRequest,::connectrpc::conformance::ClientConfigureResponse>* server_unary_streamer) = 0; + }; + typedef WithStreamedUnaryMethod_Configure StreamedUnaryService; + typedef Service SplitStreamedService; + typedef WithStreamedUnaryMethod_Configure StreamedService; +}; + +} // namespace conformance +} // namespace connectrpc + + +#endif // GRPC_connectrpc_2fconformance_2ftest_2eproto__INCLUDED diff --git a/cc/gen/connectrpc/conformance/test.pb.cc b/cc/gen/connectrpc/conformance/test.pb.cc new file mode 100644 index 00000000..212641e8 --- /dev/null +++ b/cc/gen/connectrpc/conformance/test.pb.cc @@ -0,0 +1,160 @@ +// Copyright 2022 Buf Technologies, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: connectrpc/conformance/test.proto + +#include "connectrpc/conformance/test.pb.h" + +#include +#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) + +// Must be included last. +#include "google/protobuf/port_def.inc" +PROTOBUF_PRAGMA_INIT_SEG +namespace _pb = ::PROTOBUF_NAMESPACE_ID; +namespace _pbi = ::PROTOBUF_NAMESPACE_ID::internal; +namespace connectrpc { +namespace conformance { +} // namespace conformance +} // namespace connectrpc +static constexpr const ::_pb::EnumDescriptor** + file_level_enum_descriptors_connectrpc_2fconformance_2ftest_2eproto = nullptr; +static constexpr const ::_pb::ServiceDescriptor** + file_level_service_descriptors_connectrpc_2fconformance_2ftest_2eproto = nullptr; +const ::uint32_t TableStruct_connectrpc_2fconformance_2ftest_2eproto::offsets[1] = {}; +static constexpr ::_pbi::MigrationSchema* schemas = nullptr; +static constexpr ::_pb::Message* const* file_default_instances = nullptr; +const char descriptor_table_protodef_connectrpc_2fconformance_2ftest_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + "\n!connectrpc/conformance/test.proto\022\026con" + "nectrpc.conformance\032%connectrpc/conforma" + "nce/messages.proto\032\033google/protobuf/empt" + "y.proto2\222\t\n\013TestService\022;\n\tEmptyCall\022\026.g" + "oogle.protobuf.Empty\032\026.google.protobuf.E" + "mpty\022Z\n\tUnaryCall\022%.connectrpc.conforman" + "ce.SimpleRequest\032&.connectrpc.conformanc" + "e.SimpleResponse\022^\n\rFailUnaryCall\022%.conn" + "ectrpc.conformance.SimpleRequest\032&.conne" + "ctrpc.conformance.SimpleResponse\022h\n\022Cach" + "eableUnaryCall\022%.connectrpc.conformance." + "SimpleRequest\032&.connectrpc.conformance.S" + "impleResponse\"\003\220\002\001\022\200\001\n\023StreamingOutputCa" + "ll\0222.connectrpc.conformance.StreamingOut" + "putCallRequest\0323.connectrpc.conformance." + "StreamingOutputCallResponse0\001\022\204\001\n\027FailSt" + "reamingOutputCall\0222.connectrpc.conforman" + "ce.StreamingOutputCallRequest\0323.connectr" + "pc.conformance.StreamingOutputCallRespon" + "se0\001\022}\n\022StreamingInputCall\0221.connectrpc." + "conformance.StreamingInputCallRequest\0322." + "connectrpc.conformance.StreamingInputCal" + "lResponse(\001\022}\n\016FullDuplexCall\0222.connectr" + "pc.conformance.StreamingOutputCallReques" + "t\0323.connectrpc.conformance.StreamingOutp" + "utCallResponse(\0010\001\022}\n\016HalfDuplexCall\0222.c" + "onnectrpc.conformance.StreamingOutputCal" + "lRequest\0323.connectrpc.conformance.Stream" + "ingOutputCallResponse(\0010\001\022C\n\021Unimplement" + "edCall\022\026.google.protobuf.Empty\032\026.google." + "protobuf.Empty\022T\n UnimplementedStreaming" + "OutputCall\022\026.google.protobuf.Empty\032\026.goo" + "gle.protobuf.Empty0\0012\261\001\n\024UnimplementedSe" + "rvice\022C\n\021UnimplementedCall\022\026.google.prot" + "obuf.Empty\032\026.google.protobuf.Empty\022T\n Un" + "implementedStreamingOutputCall\022\026.google." + "protobuf.Empty\032\026.google.protobuf.Empty0\001" + "2\243\001\n\020ReconnectService\022H\n\005Start\022\'.connect" + "rpc.conformance.ReconnectParams\032\026.google" + ".protobuf.Empty\022E\n\004Stop\022\026.google.protobu" + "f.Empty\032%.connectrpc.conformance.Reconne" + "ctInfo2\256\002\n\030LoadBalancerStatsService\022w\n\016G" + "etClientStats\0220.connectrpc.conformance.L" + "oadBalancerStatsRequest\0321.connectrpc.con" + "formance.LoadBalancerStatsResponse\"\000\022\230\001\n" + "\031GetClientAccumulatedStats\022;.connectrpc." + "conformance.LoadBalancerAccumulatedStats" + "Request\032<.connectrpc.conformance.LoadBal" + "ancerAccumulatedStatsResponse\"\0002\227\001\n\026XdsU" + "pdateHealthService\022<\n\nSetServing\022\026.googl" + "e.protobuf.Empty\032\026.google.protobuf.Empty" + "\022\?\n\rSetNotServing\022\026.google.protobuf.Empt" + "y\032\026.google.protobuf.Empty2\217\001\n\037XdsUpdateC" + "lientConfigureService\022l\n\tConfigure\022..con" + "nectrpc.conformance.ClientConfigureReque" + "st\032/.connectrpc.conformance.ClientConfig" + "ureResponseB\364\001\n\032com.connectrpc.conforman" + "ceB\tTestProtoP\001ZRgithub.com/bufbuild/con" + "nect-crosstest/internal/gen/proto/go/con" + "nectrpc/conformance\242\002\003CCX\252\002\026Connectrpc.C" + "onformance\312\002\026Connectrpc\\Conformance\342\002\"Co" + "nnectrpc\\Conformance\\GPBMetadata\352\002\027Conne" + "ctrpc::Conformanceb\006proto3" +}; +static const ::_pbi::DescriptorTable* const descriptor_table_connectrpc_2fconformance_2ftest_2eproto_deps[2] = + { + &::descriptor_table_connectrpc_2fconformance_2fmessages_2eproto, + &::descriptor_table_google_2fprotobuf_2fempty_2eproto, +}; +static ::absl::once_flag descriptor_table_connectrpc_2fconformance_2ftest_2eproto_once; +const ::_pbi::DescriptorTable descriptor_table_connectrpc_2fconformance_2ftest_2eproto = { + false, + false, + 2506, + descriptor_table_protodef_connectrpc_2fconformance_2ftest_2eproto, + "connectrpc/conformance/test.proto", + &descriptor_table_connectrpc_2fconformance_2ftest_2eproto_once, + descriptor_table_connectrpc_2fconformance_2ftest_2eproto_deps, + 2, + 0, + schemas, + file_default_instances, + TableStruct_connectrpc_2fconformance_2ftest_2eproto::offsets, + nullptr, + file_level_enum_descriptors_connectrpc_2fconformance_2ftest_2eproto, + file_level_service_descriptors_connectrpc_2fconformance_2ftest_2eproto, +}; + +// This function exists to be marked as weak. +// It can significantly speed up compilation by breaking up LLVM's SCC +// in the .pb.cc translation units. Large translation units see a +// reduction of more than 35% of walltime for optimized builds. Without +// the weak attribute all the messages in the file, including all the +// vtables and everything they use become part of the same SCC through +// a cycle like: +// GetMetadata -> descriptor table -> default instances -> +// vtables -> GetMetadata +// By adding a weak function here we break the connection from the +// individual vtables back into the descriptor table. +PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_connectrpc_2fconformance_2ftest_2eproto_getter() { + return &descriptor_table_connectrpc_2fconformance_2ftest_2eproto; +} +// Force running AddDescriptors() at dynamic initialization time. +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 +static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_connectrpc_2fconformance_2ftest_2eproto(&descriptor_table_connectrpc_2fconformance_2ftest_2eproto); +namespace connectrpc { +namespace conformance { +// @@protoc_insertion_point(namespace_scope) +} // namespace conformance +} // namespace connectrpc +PROTOBUF_NAMESPACE_OPEN +PROTOBUF_NAMESPACE_CLOSE +// @@protoc_insertion_point(global_scope) +#include "google/protobuf/port_undef.inc" diff --git a/cc/gen/connectrpc/conformance/test.pb.h b/cc/gen/connectrpc/conformance/test.pb.h new file mode 100644 index 00000000..af873b43 --- /dev/null +++ b/cc/gen/connectrpc/conformance/test.pb.h @@ -0,0 +1,102 @@ +// Copyright 2022 Buf Technologies, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: connectrpc/conformance/test.proto + +#ifndef GOOGLE_PROTOBUF_INCLUDED_connectrpc_2fconformance_2ftest_2eproto_2epb_2eh +#define GOOGLE_PROTOBUF_INCLUDED_connectrpc_2fconformance_2ftest_2eproto_2epb_2eh + +#include +#include +#include + +#include "google/protobuf/port_def.inc" +#if PROTOBUF_VERSION < 4023000 +#error "This file was generated by a newer version of protoc which is" +#error "incompatible with your Protocol Buffer headers. Please update" +#error "your headers." +#endif // PROTOBUF_VERSION + +#if 4023004 < PROTOBUF_MIN_PROTOC_VERSION +#error "This file was generated by an older version of protoc which is" +#error "incompatible with your Protocol Buffer headers. Please" +#error "regenerate this file with a newer version of protoc." +#endif // PROTOBUF_MIN_PROTOC_VERSION +#include "google/protobuf/port_undef.inc" +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/arena.h" +#include "google/protobuf/arenastring.h" +#include "google/protobuf/generated_message_util.h" +#include "google/protobuf/metadata_lite.h" +#include "google/protobuf/generated_message_reflection.h" +#include "google/protobuf/repeated_field.h" // IWYU pragma: export +#include "google/protobuf/extension_set.h" // IWYU pragma: export +#include "connectrpc/conformance/messages.pb.h" +#include "google/protobuf/empty.pb.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" + +#define PROTOBUF_INTERNAL_EXPORT_connectrpc_2fconformance_2ftest_2eproto + +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_connectrpc_2fconformance_2ftest_2eproto { + static const ::uint32_t offsets[]; +}; +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable + descriptor_table_connectrpc_2fconformance_2ftest_2eproto; +PROTOBUF_NAMESPACE_OPEN +PROTOBUF_NAMESPACE_CLOSE + +namespace connectrpc { +namespace conformance { + +// =================================================================== + + + +// =================================================================== + + + + +// =================================================================== + + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif // __GNUC__ + +// @@protoc_insertion_point(namespace_scope) +} // namespace conformance +} // namespace connectrpc + + +// @@protoc_insertion_point(global_scope) + +#include "google/protobuf/port_undef.inc" + +#endif // GOOGLE_PROTOBUF_INCLUDED_connectrpc_2fconformance_2ftest_2eproto_2epb_2eh diff --git a/cc/gen/server/v1/server.grpc.pb.cc b/cc/gen/server/v1/server.grpc.pb.cc new file mode 100644 index 00000000..b46ce0c0 --- /dev/null +++ b/cc/gen/server/v1/server.grpc.pb.cc @@ -0,0 +1,41 @@ +// Copyright 2022 Buf Technologies, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Generated by the gRPC C++ plugin. +// If you make any local change, they will be lost. +// source: server/v1/server.proto + +#include "server/v1/server.pb.h" +#include "server/v1/server.grpc.pb.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +namespace server { +namespace v1 { + +} // namespace server +} // namespace v1 + diff --git a/cc/gen/server/v1/server.grpc.pb.h b/cc/gen/server/v1/server.grpc.pb.h new file mode 100644 index 00000000..9e9a431e --- /dev/null +++ b/cc/gen/server/v1/server.grpc.pb.h @@ -0,0 +1,46 @@ +// Copyright 2022 Buf Technologies, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef GRPC_server_2fv1_2fserver_2eproto__INCLUDED +#define GRPC_server_2fv1_2fserver_2eproto__INCLUDED + +#include "server/v1/server.pb.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace server { +namespace v1 { + +} // namespace v1 +} // namespace server + + +#endif // GRPC_server_2fv1_2fserver_2eproto__INCLUDED diff --git a/cc/gen/server/v1/server.pb.cc b/cc/gen/server/v1/server.pb.cc new file mode 100644 index 00000000..d551cde7 --- /dev/null +++ b/cc/gen/server/v1/server.pb.cc @@ -0,0 +1,938 @@ +// Copyright 2022 Buf Technologies, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: server/v1/server.proto + +#include "server/v1/server.pb.h" + +#include +#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) + +// Must be included last. +#include "google/protobuf/port_def.inc" +PROTOBUF_PRAGMA_INIT_SEG +namespace _pb = ::PROTOBUF_NAMESPACE_ID; +namespace _pbi = ::PROTOBUF_NAMESPACE_ID::internal; +namespace server { +namespace v1 { +template +PROTOBUF_CONSTEXPR ServerMetadata::ServerMetadata( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.protocols_)*/{} + , /*decltype(_impl_.host_)*/ { + &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} + } + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct ServerMetadataDefaultTypeInternal { + PROTOBUF_CONSTEXPR ServerMetadataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ServerMetadataDefaultTypeInternal() {} + union { + ServerMetadata _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ServerMetadataDefaultTypeInternal _ServerMetadata_default_instance_; +template +PROTOBUF_CONSTEXPR ProtocolSupport::ProtocolSupport( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.http_versions_)*/{} + , /*decltype(_impl_.port_)*/ { + &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} + } + + , /*decltype(_impl_.protocol_)*/ 0 + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct ProtocolSupportDefaultTypeInternal { + PROTOBUF_CONSTEXPR ProtocolSupportDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ProtocolSupportDefaultTypeInternal() {} + union { + ProtocolSupport _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ProtocolSupportDefaultTypeInternal _ProtocolSupport_default_instance_; +template +PROTOBUF_CONSTEXPR HTTPVersion::HTTPVersion( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.major_)*/ 0 + + , /*decltype(_impl_.minor_)*/ 0 + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct HTTPVersionDefaultTypeInternal { + PROTOBUF_CONSTEXPR HTTPVersionDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~HTTPVersionDefaultTypeInternal() {} + union { + HTTPVersion _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HTTPVersionDefaultTypeInternal _HTTPVersion_default_instance_; +} // namespace v1 +} // namespace server +static ::_pb::Metadata file_level_metadata_server_2fv1_2fserver_2eproto[3]; +static const ::_pb::EnumDescriptor* file_level_enum_descriptors_server_2fv1_2fserver_2eproto[1]; +static constexpr const ::_pb::ServiceDescriptor** + file_level_service_descriptors_server_2fv1_2fserver_2eproto = nullptr; +const ::uint32_t TableStruct_server_2fv1_2fserver_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( + protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::server::v1::ServerMetadata, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::server::v1::ServerMetadata, _impl_.host_), + PROTOBUF_FIELD_OFFSET(::server::v1::ServerMetadata, _impl_.protocols_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::server::v1::ProtocolSupport, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::server::v1::ProtocolSupport, _impl_.protocol_), + PROTOBUF_FIELD_OFFSET(::server::v1::ProtocolSupport, _impl_.http_versions_), + PROTOBUF_FIELD_OFFSET(::server::v1::ProtocolSupport, _impl_.port_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::server::v1::HTTPVersion, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::server::v1::HTTPVersion, _impl_.major_), + PROTOBUF_FIELD_OFFSET(::server::v1::HTTPVersion, _impl_.minor_), +}; + +static const ::_pbi::MigrationSchema + schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + { 0, -1, -1, sizeof(::server::v1::ServerMetadata)}, + { 10, -1, -1, sizeof(::server::v1::ProtocolSupport)}, + { 21, -1, -1, sizeof(::server::v1::HTTPVersion)}, +}; + +static const ::_pb::Message* const file_default_instances[] = { + &::server::v1::_ServerMetadata_default_instance_._instance, + &::server::v1::_ProtocolSupport_default_instance_._instance, + &::server::v1::_HTTPVersion_default_instance_._instance, +}; +const char descriptor_table_protodef_server_2fv1_2fserver_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + "\n\026server/v1/server.proto\022\tserver.v1\"^\n\016S" + "erverMetadata\022\022\n\004host\030\001 \001(\tR\004host\0228\n\tpro" + "tocols\030\002 \003(\0132\032.server.v1.ProtocolSupport" + "R\tprotocols\"\223\001\n\017ProtocolSupport\022/\n\010proto" + "col\030\001 \001(\0162\023.server.v1.ProtocolR\010protocol" + "\022;\n\rhttp_versions\030\002 \003(\0132\026.server.v1.HTTP" + "VersionR\014httpVersions\022\022\n\004port\030\003 \001(\tR\004por" + "t\"9\n\013HTTPVersion\022\024\n\005major\030\001 \001(\005R\005major\022\024" + "\n\005minor\030\002 \001(\005R\005minor*N\n\010Protocol\022\030\n\024PROT" + "OCOL_UNSPECIFIED\020\000\022\021\n\rPROTOCOL_GRPC\020\001\022\025\n" + "\021PROTOCOL_GRPC_WEB\020\002B\261\001\n\rcom.server.v1B\013" + "ServerProtoP\001ZNgithub.com/bufbuild/conne" + "ct-crosstest/internal/gen/proto/go/serve" + "r/v1;serverv1\242\002\003SXX\252\002\tServer.V1\312\002\tServer" + "\\V1\342\002\025Server\\V1\\GPBMetadata\352\002\nServer::V1" + "b\006proto3" +}; +static ::absl::once_flag descriptor_table_server_2fv1_2fserver_2eproto_once; +const ::_pbi::DescriptorTable descriptor_table_server_2fv1_2fserver_2eproto = { + false, + false, + 608, + descriptor_table_protodef_server_2fv1_2fserver_2eproto, + "server/v1/server.proto", + &descriptor_table_server_2fv1_2fserver_2eproto_once, + nullptr, + 0, + 3, + schemas, + file_default_instances, + TableStruct_server_2fv1_2fserver_2eproto::offsets, + file_level_metadata_server_2fv1_2fserver_2eproto, + file_level_enum_descriptors_server_2fv1_2fserver_2eproto, + file_level_service_descriptors_server_2fv1_2fserver_2eproto, +}; + +// This function exists to be marked as weak. +// It can significantly speed up compilation by breaking up LLVM's SCC +// in the .pb.cc translation units. Large translation units see a +// reduction of more than 35% of walltime for optimized builds. Without +// the weak attribute all the messages in the file, including all the +// vtables and everything they use become part of the same SCC through +// a cycle like: +// GetMetadata -> descriptor table -> default instances -> +// vtables -> GetMetadata +// By adding a weak function here we break the connection from the +// individual vtables back into the descriptor table. +PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_server_2fv1_2fserver_2eproto_getter() { + return &descriptor_table_server_2fv1_2fserver_2eproto; +} +// Force running AddDescriptors() at dynamic initialization time. +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 +static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_server_2fv1_2fserver_2eproto(&descriptor_table_server_2fv1_2fserver_2eproto); +namespace server { +namespace v1 { +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Protocol_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_server_2fv1_2fserver_2eproto); + return file_level_enum_descriptors_server_2fv1_2fserver_2eproto[0]; +} +bool Protocol_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} +// =================================================================== + +class ServerMetadata::_Internal { + public: +}; + +ServerMetadata::ServerMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:server.v1.ServerMetadata) +} +ServerMetadata::ServerMetadata(const ServerMetadata& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + ServerMetadata* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.protocols_){from._impl_.protocols_} + , decltype(_impl_.host_) {} + + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.host_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.host_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_host().empty()) { + _this->_impl_.host_.Set(from._internal_host(), _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:server.v1.ServerMetadata) +} + +inline void ServerMetadata::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.protocols_){arena} + , decltype(_impl_.host_) {} + + , /*decltype(_impl_._cached_size_)*/{} + }; + _impl_.host_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.host_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +ServerMetadata::~ServerMetadata() { + // @@protoc_insertion_point(destructor:server.v1.ServerMetadata) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ServerMetadata::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _internal_mutable_protocols()->~RepeatedPtrField(); + _impl_.host_.Destroy(); +} + +void ServerMetadata::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ServerMetadata::Clear() { +// @@protoc_insertion_point(message_clear_start:server.v1.ServerMetadata) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_mutable_protocols()->Clear(); + _impl_.host_.ClearToEmpty(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ServerMetadata::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // string host = 1 [json_name = "host"]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { + auto str = _internal_mutable_host(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + CHK_(::_pbi::VerifyUTF8(str, "server.v1.ServerMetadata.host")); + } else { + goto handle_unusual; + } + continue; + // repeated .server.v1.ProtocolSupport protocols = 2 [json_name = "protocols"]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_protocols(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else { + goto handle_unusual; + } + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* ServerMetadata::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:server.v1.ServerMetadata) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // string host = 1 [json_name = "host"]; + if (!this->_internal_host().empty()) { + const std::string& _s = this->_internal_host(); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "server.v1.ServerMetadata.host"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // repeated .server.v1.ProtocolSupport protocols = 2 [json_name = "protocols"]; + for (unsigned i = 0, + n = static_cast(this->_internal_protocols_size()); i < n; i++) { + const auto& repfield = this->_internal_protocols(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:server.v1.ServerMetadata) + return target; +} + +::size_t ServerMetadata::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:server.v1.ServerMetadata) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .server.v1.ProtocolSupport protocols = 2 [json_name = "protocols"]; + total_size += 1UL * this->_internal_protocols_size(); + for (const auto& msg : this->_internal_protocols()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // string host = 1 [json_name = "host"]; + if (!this->_internal_host().empty()) { + total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_host()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ServerMetadata::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + ServerMetadata::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ServerMetadata::GetClassData() const { return &_class_data_; } + + +void ServerMetadata::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:server.v1.ServerMetadata) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_mutable_protocols()->MergeFrom(from._internal_protocols()); + if (!from._internal_host().empty()) { + _this->_internal_set_host(from._internal_host()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ServerMetadata::CopyFrom(const ServerMetadata& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:server.v1.ServerMetadata) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ServerMetadata::IsInitialized() const { + return true; +} + +void ServerMetadata::InternalSwap(ServerMetadata* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _internal_mutable_protocols()->InternalSwap(other->_internal_mutable_protocols()); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.host_, lhs_arena, + &other->_impl_.host_, rhs_arena); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ServerMetadata::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_server_2fv1_2fserver_2eproto_getter, &descriptor_table_server_2fv1_2fserver_2eproto_once, + file_level_metadata_server_2fv1_2fserver_2eproto[0]); +} +// =================================================================== + +class ProtocolSupport::_Internal { + public: +}; + +ProtocolSupport::ProtocolSupport(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:server.v1.ProtocolSupport) +} +ProtocolSupport::ProtocolSupport(const ProtocolSupport& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + ProtocolSupport* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.http_versions_){from._impl_.http_versions_} + , decltype(_impl_.port_) {} + + , decltype(_impl_.protocol_) {} + + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.port_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.port_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_port().empty()) { + _this->_impl_.port_.Set(from._internal_port(), _this->GetArenaForAllocation()); + } + _this->_impl_.protocol_ = from._impl_.protocol_; + // @@protoc_insertion_point(copy_constructor:server.v1.ProtocolSupport) +} + +inline void ProtocolSupport::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.http_versions_){arena} + , decltype(_impl_.port_) {} + + , decltype(_impl_.protocol_) { 0 } + + , /*decltype(_impl_._cached_size_)*/{} + }; + _impl_.port_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.port_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +ProtocolSupport::~ProtocolSupport() { + // @@protoc_insertion_point(destructor:server.v1.ProtocolSupport) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ProtocolSupport::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _internal_mutable_http_versions()->~RepeatedPtrField(); + _impl_.port_.Destroy(); +} + +void ProtocolSupport::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ProtocolSupport::Clear() { +// @@protoc_insertion_point(message_clear_start:server.v1.ProtocolSupport) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_mutable_http_versions()->Clear(); + _impl_.port_.ClearToEmpty(); + _impl_.protocol_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ProtocolSupport::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .server.v1.Protocol protocol = 1 [json_name = "protocol"]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) { + ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + _internal_set_protocol(static_cast<::server::v1::Protocol>(val)); + } else { + goto handle_unusual; + } + continue; + // repeated .server.v1.HTTPVersion http_versions = 2 [json_name = "httpVersions"]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_http_versions(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else { + goto handle_unusual; + } + continue; + // string port = 3 [json_name = "port"]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) { + auto str = _internal_mutable_port(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + CHK_(::_pbi::VerifyUTF8(str, "server.v1.ProtocolSupport.port")); + } else { + goto handle_unusual; + } + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* ProtocolSupport::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:server.v1.ProtocolSupport) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // .server.v1.Protocol protocol = 1 [json_name = "protocol"]; + if (this->_internal_protocol() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this->_internal_protocol(), target); + } + + // repeated .server.v1.HTTPVersion http_versions = 2 [json_name = "httpVersions"]; + for (unsigned i = 0, + n = static_cast(this->_internal_http_versions_size()); i < n; i++) { + const auto& repfield = this->_internal_http_versions(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream); + } + + // string port = 3 [json_name = "port"]; + if (!this->_internal_port().empty()) { + const std::string& _s = this->_internal_port(); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "server.v1.ProtocolSupport.port"); + target = stream->WriteStringMaybeAliased(3, _s, target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:server.v1.ProtocolSupport) + return target; +} + +::size_t ProtocolSupport::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:server.v1.ProtocolSupport) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .server.v1.HTTPVersion http_versions = 2 [json_name = "httpVersions"]; + total_size += 1UL * this->_internal_http_versions_size(); + for (const auto& msg : this->_internal_http_versions()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // string port = 3 [json_name = "port"]; + if (!this->_internal_port().empty()) { + total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_port()); + } + + // .server.v1.Protocol protocol = 1 [json_name = "protocol"]; + if (this->_internal_protocol() != 0) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_protocol()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ProtocolSupport::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + ProtocolSupport::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ProtocolSupport::GetClassData() const { return &_class_data_; } + + +void ProtocolSupport::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:server.v1.ProtocolSupport) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_mutable_http_versions()->MergeFrom(from._internal_http_versions()); + if (!from._internal_port().empty()) { + _this->_internal_set_port(from._internal_port()); + } + if (from._internal_protocol() != 0) { + _this->_internal_set_protocol(from._internal_protocol()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ProtocolSupport::CopyFrom(const ProtocolSupport& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:server.v1.ProtocolSupport) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ProtocolSupport::IsInitialized() const { + return true; +} + +void ProtocolSupport::InternalSwap(ProtocolSupport* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _internal_mutable_http_versions()->InternalSwap(other->_internal_mutable_http_versions()); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.port_, lhs_arena, + &other->_impl_.port_, rhs_arena); + swap(_impl_.protocol_, other->_impl_.protocol_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ProtocolSupport::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_server_2fv1_2fserver_2eproto_getter, &descriptor_table_server_2fv1_2fserver_2eproto_once, + file_level_metadata_server_2fv1_2fserver_2eproto[1]); +} +// =================================================================== + +class HTTPVersion::_Internal { + public: +}; + +HTTPVersion::HTTPVersion(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:server.v1.HTTPVersion) +} +HTTPVersion::HTTPVersion(const HTTPVersion& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>( + from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:server.v1.HTTPVersion) +} + +inline void HTTPVersion::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.major_) { 0 } + + , decltype(_impl_.minor_) { 0 } + + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +HTTPVersion::~HTTPVersion() { + // @@protoc_insertion_point(destructor:server.v1.HTTPVersion) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void HTTPVersion::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); +} + +void HTTPVersion::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void HTTPVersion::Clear() { +// @@protoc_insertion_point(message_clear_start:server.v1.HTTPVersion) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.major_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.minor_) - + reinterpret_cast(&_impl_.major_)) + sizeof(_impl_.minor_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* HTTPVersion::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int32 major = 1 [json_name = "major"]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) { + _impl_.major_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // int32 minor = 2 [json_name = "minor"]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) { + _impl_.minor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* HTTPVersion::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:server.v1.HTTPVersion) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // int32 major = 1 [json_name = "major"]; + if (this->_internal_major() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray( + 1, this->_internal_major(), target); + } + + // int32 minor = 2 [json_name = "minor"]; + if (this->_internal_minor() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray( + 2, this->_internal_minor(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:server.v1.HTTPVersion) + return target; +} + +::size_t HTTPVersion::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:server.v1.HTTPVersion) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // int32 major = 1 [json_name = "major"]; + if (this->_internal_major() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_major()); + } + + // int32 minor = 2 [json_name = "minor"]; + if (this->_internal_minor() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_minor()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HTTPVersion::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + HTTPVersion::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HTTPVersion::GetClassData() const { return &_class_data_; } + + +void HTTPVersion::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:server.v1.HTTPVersion) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_major() != 0) { + _this->_internal_set_major(from._internal_major()); + } + if (from._internal_minor() != 0) { + _this->_internal_set_minor(from._internal_minor()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void HTTPVersion::CopyFrom(const HTTPVersion& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:server.v1.HTTPVersion) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HTTPVersion::IsInitialized() const { + return true; +} + +void HTTPVersion::InternalSwap(HTTPVersion* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(HTTPVersion, _impl_.minor_) + + sizeof(HTTPVersion::_impl_.minor_) + - PROTOBUF_FIELD_OFFSET(HTTPVersion, _impl_.major_)>( + reinterpret_cast(&_impl_.major_), + reinterpret_cast(&other->_impl_.major_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HTTPVersion::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_server_2fv1_2fserver_2eproto_getter, &descriptor_table_server_2fv1_2fserver_2eproto_once, + file_level_metadata_server_2fv1_2fserver_2eproto[2]); +} +// @@protoc_insertion_point(namespace_scope) +} // namespace v1 +} // namespace server +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::server::v1::ServerMetadata* +Arena::CreateMaybeMessage< ::server::v1::ServerMetadata >(Arena* arena) { + return Arena::CreateMessageInternal< ::server::v1::ServerMetadata >(arena); +} +template<> PROTOBUF_NOINLINE ::server::v1::ProtocolSupport* +Arena::CreateMaybeMessage< ::server::v1::ProtocolSupport >(Arena* arena) { + return Arena::CreateMessageInternal< ::server::v1::ProtocolSupport >(arena); +} +template<> PROTOBUF_NOINLINE ::server::v1::HTTPVersion* +Arena::CreateMaybeMessage< ::server::v1::HTTPVersion >(Arena* arena) { + return Arena::CreateMessageInternal< ::server::v1::HTTPVersion >(arena); +} +PROTOBUF_NAMESPACE_CLOSE +// @@protoc_insertion_point(global_scope) +#include "google/protobuf/port_undef.inc" diff --git a/cc/gen/server/v1/server.pb.h b/cc/gen/server/v1/server.pb.h new file mode 100644 index 00000000..11fa0b4c --- /dev/null +++ b/cc/gen/server/v1/server.pb.h @@ -0,0 +1,982 @@ +// Copyright 2022 Buf Technologies, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: server/v1/server.proto + +#ifndef GOOGLE_PROTOBUF_INCLUDED_server_2fv1_2fserver_2eproto_2epb_2eh +#define GOOGLE_PROTOBUF_INCLUDED_server_2fv1_2fserver_2eproto_2epb_2eh + +#include +#include +#include + +#include "google/protobuf/port_def.inc" +#if PROTOBUF_VERSION < 4023000 +#error "This file was generated by a newer version of protoc which is" +#error "incompatible with your Protocol Buffer headers. Please update" +#error "your headers." +#endif // PROTOBUF_VERSION + +#if 4023004 < PROTOBUF_MIN_PROTOC_VERSION +#error "This file was generated by an older version of protoc which is" +#error "incompatible with your Protocol Buffer headers. Please" +#error "regenerate this file with a newer version of protoc." +#endif // PROTOBUF_MIN_PROTOC_VERSION +#include "google/protobuf/port_undef.inc" +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/arena.h" +#include "google/protobuf/arenastring.h" +#include "google/protobuf/generated_message_util.h" +#include "google/protobuf/metadata_lite.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/generated_enum_reflection.h" +#include "google/protobuf/unknown_field_set.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" + +#define PROTOBUF_INTERNAL_EXPORT_server_2fv1_2fserver_2eproto + +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_server_2fv1_2fserver_2eproto { + static const ::uint32_t offsets[]; +}; +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable + descriptor_table_server_2fv1_2fserver_2eproto; +namespace server { +namespace v1 { +class HTTPVersion; +struct HTTPVersionDefaultTypeInternal; +extern HTTPVersionDefaultTypeInternal _HTTPVersion_default_instance_; +class ProtocolSupport; +struct ProtocolSupportDefaultTypeInternal; +extern ProtocolSupportDefaultTypeInternal _ProtocolSupport_default_instance_; +class ServerMetadata; +struct ServerMetadataDefaultTypeInternal; +extern ServerMetadataDefaultTypeInternal _ServerMetadata_default_instance_; +} // namespace v1 +} // namespace server +PROTOBUF_NAMESPACE_OPEN +template <> +::server::v1::HTTPVersion* Arena::CreateMaybeMessage<::server::v1::HTTPVersion>(Arena*); +template <> +::server::v1::ProtocolSupport* Arena::CreateMaybeMessage<::server::v1::ProtocolSupport>(Arena*); +template <> +::server::v1::ServerMetadata* Arena::CreateMaybeMessage<::server::v1::ServerMetadata>(Arena*); +PROTOBUF_NAMESPACE_CLOSE + +namespace server { +namespace v1 { +enum Protocol : int { + PROTOCOL_UNSPECIFIED = 0, + PROTOCOL_GRPC = 1, + PROTOCOL_GRPC_WEB = 2, + Protocol_INT_MIN_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::min(), + Protocol_INT_MAX_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::max(), +}; + +bool Protocol_IsValid(int value); +constexpr Protocol Protocol_MIN = static_cast(0); +constexpr Protocol Protocol_MAX = static_cast(2); +constexpr int Protocol_ARRAYSIZE = 2 + 1; +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* +Protocol_descriptor(); +template +const std::string& Protocol_Name(T value) { + static_assert(std::is_same::value || + std::is_integral::value, + "Incorrect type passed to Protocol_Name()."); + return Protocol_Name(static_cast(value)); +} +template <> +inline const std::string& Protocol_Name(Protocol value) { + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfDenseEnum( + static_cast(value)); +} +inline bool Protocol_Parse(absl::string_view name, Protocol* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Protocol_descriptor(), name, value); +} + +// =================================================================== + + +// ------------------------------------------------------------------- + +class ServerMetadata final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:server.v1.ServerMetadata) */ { + public: + inline ServerMetadata() : ServerMetadata(nullptr) {} + ~ServerMetadata() override; + template + explicit PROTOBUF_CONSTEXPR ServerMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ServerMetadata(const ServerMetadata& from); + ServerMetadata(ServerMetadata&& from) noexcept + : ServerMetadata() { + *this = ::std::move(from); + } + + inline ServerMetadata& operator=(const ServerMetadata& from) { + CopyFrom(from); + return *this; + } + inline ServerMetadata& operator=(ServerMetadata&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ServerMetadata& default_instance() { + return *internal_default_instance(); + } + static inline const ServerMetadata* internal_default_instance() { + return reinterpret_cast( + &_ServerMetadata_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(ServerMetadata& a, ServerMetadata& b) { + a.Swap(&b); + } + inline void Swap(ServerMetadata* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ServerMetadata* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ServerMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ServerMetadata& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const ServerMetadata& from) { + ServerMetadata::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + 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; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ServerMetadata* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "server.v1.ServerMetadata"; + } + protected: + explicit ServerMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kProtocolsFieldNumber = 2, + kHostFieldNumber = 1, + }; + // repeated .server.v1.ProtocolSupport protocols = 2 [json_name = "protocols"]; + int protocols_size() const; + private: + int _internal_protocols_size() const; + + public: + void clear_protocols() ; + ::server::v1::ProtocolSupport* mutable_protocols(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::server::v1::ProtocolSupport >* + mutable_protocols(); + private: + const ::server::v1::ProtocolSupport& _internal_protocols(int index) const; + ::server::v1::ProtocolSupport* _internal_add_protocols(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::server::v1::ProtocolSupport>& _internal_protocols() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::server::v1::ProtocolSupport>* _internal_mutable_protocols(); + public: + const ::server::v1::ProtocolSupport& protocols(int index) const; + ::server::v1::ProtocolSupport* add_protocols(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::server::v1::ProtocolSupport >& + protocols() const; + // string host = 1 [json_name = "host"]; + void clear_host() ; + const std::string& host() const; + + + + + template + void set_host(Arg_&& arg, Args_... args); + std::string* mutable_host(); + PROTOBUF_NODISCARD std::string* release_host(); + void set_allocated_host(std::string* ptr); + + private: + const std::string& _internal_host() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_host( + const std::string& value); + std::string* _internal_mutable_host(); + + public: + // @@protoc_insertion_point(class_scope:server.v1.ServerMetadata) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::server::v1::ProtocolSupport > protocols_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr host_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_server_2fv1_2fserver_2eproto; +};// ------------------------------------------------------------------- + +class ProtocolSupport final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:server.v1.ProtocolSupport) */ { + public: + inline ProtocolSupport() : ProtocolSupport(nullptr) {} + ~ProtocolSupport() override; + template + explicit PROTOBUF_CONSTEXPR ProtocolSupport(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ProtocolSupport(const ProtocolSupport& from); + ProtocolSupport(ProtocolSupport&& from) noexcept + : ProtocolSupport() { + *this = ::std::move(from); + } + + inline ProtocolSupport& operator=(const ProtocolSupport& from) { + CopyFrom(from); + return *this; + } + inline ProtocolSupport& operator=(ProtocolSupport&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ProtocolSupport& default_instance() { + return *internal_default_instance(); + } + static inline const ProtocolSupport* internal_default_instance() { + return reinterpret_cast( + &_ProtocolSupport_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + friend void swap(ProtocolSupport& a, ProtocolSupport& b) { + a.Swap(&b); + } + inline void Swap(ProtocolSupport* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ProtocolSupport* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ProtocolSupport* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ProtocolSupport& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const ProtocolSupport& from) { + ProtocolSupport::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + 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; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ProtocolSupport* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "server.v1.ProtocolSupport"; + } + protected: + explicit ProtocolSupport(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kHttpVersionsFieldNumber = 2, + kPortFieldNumber = 3, + kProtocolFieldNumber = 1, + }; + // repeated .server.v1.HTTPVersion http_versions = 2 [json_name = "httpVersions"]; + int http_versions_size() const; + private: + int _internal_http_versions_size() const; + + public: + void clear_http_versions() ; + ::server::v1::HTTPVersion* mutable_http_versions(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::server::v1::HTTPVersion >* + mutable_http_versions(); + private: + const ::server::v1::HTTPVersion& _internal_http_versions(int index) const; + ::server::v1::HTTPVersion* _internal_add_http_versions(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::server::v1::HTTPVersion>& _internal_http_versions() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::server::v1::HTTPVersion>* _internal_mutable_http_versions(); + public: + const ::server::v1::HTTPVersion& http_versions(int index) const; + ::server::v1::HTTPVersion* add_http_versions(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::server::v1::HTTPVersion >& + http_versions() const; + // string port = 3 [json_name = "port"]; + void clear_port() ; + const std::string& port() const; + + + + + template + void set_port(Arg_&& arg, Args_... args); + std::string* mutable_port(); + PROTOBUF_NODISCARD std::string* release_port(); + void set_allocated_port(std::string* ptr); + + private: + const std::string& _internal_port() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_port( + const std::string& value); + std::string* _internal_mutable_port(); + + public: + // .server.v1.Protocol protocol = 1 [json_name = "protocol"]; + void clear_protocol() ; + ::server::v1::Protocol protocol() const; + void set_protocol(::server::v1::Protocol value); + + private: + ::server::v1::Protocol _internal_protocol() const; + void _internal_set_protocol(::server::v1::Protocol value); + + public: + // @@protoc_insertion_point(class_scope:server.v1.ProtocolSupport) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::server::v1::HTTPVersion > http_versions_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr port_; + int protocol_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_server_2fv1_2fserver_2eproto; +};// ------------------------------------------------------------------- + +class HTTPVersion final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:server.v1.HTTPVersion) */ { + public: + inline HTTPVersion() : HTTPVersion(nullptr) {} + ~HTTPVersion() override; + template + explicit PROTOBUF_CONSTEXPR HTTPVersion(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + HTTPVersion(const HTTPVersion& from); + HTTPVersion(HTTPVersion&& from) noexcept + : HTTPVersion() { + *this = ::std::move(from); + } + + inline HTTPVersion& operator=(const HTTPVersion& from) { + CopyFrom(from); + return *this; + } + inline HTTPVersion& operator=(HTTPVersion&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const HTTPVersion& default_instance() { + return *internal_default_instance(); + } + static inline const HTTPVersion* internal_default_instance() { + return reinterpret_cast( + &_HTTPVersion_default_instance_); + } + static constexpr int kIndexInFileMessages = + 2; + + friend void swap(HTTPVersion& a, HTTPVersion& b) { + a.Swap(&b); + } + inline void Swap(HTTPVersion* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(HTTPVersion* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + HTTPVersion* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const HTTPVersion& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const HTTPVersion& from) { + HTTPVersion::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + 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; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(HTTPVersion* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "server.v1.HTTPVersion"; + } + protected: + explicit HTTPVersion(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMajorFieldNumber = 1, + kMinorFieldNumber = 2, + }; + // int32 major = 1 [json_name = "major"]; + void clear_major() ; + ::int32_t major() const; + void set_major(::int32_t value); + + private: + ::int32_t _internal_major() const; + void _internal_set_major(::int32_t value); + + public: + // int32 minor = 2 [json_name = "minor"]; + void clear_minor() ; + ::int32_t minor() const; + void set_minor(::int32_t value); + + private: + ::int32_t _internal_minor() const; + void _internal_set_minor(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:server.v1.HTTPVersion) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::int32_t major_; + ::int32_t minor_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_server_2fv1_2fserver_2eproto; +}; + +// =================================================================== + + + + +// =================================================================== + + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// ServerMetadata + +// string host = 1 [json_name = "host"]; +inline void ServerMetadata::clear_host() { + _impl_.host_.ClearToEmpty(); +} +inline const std::string& ServerMetadata::host() const { + // @@protoc_insertion_point(field_get:server.v1.ServerMetadata.host) + return _internal_host(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ServerMetadata::set_host(Arg_&& arg, + Args_... args) { + ; + _impl_.host_.Set(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:server.v1.ServerMetadata.host) +} +inline std::string* ServerMetadata::mutable_host() { + std::string* _s = _internal_mutable_host(); + // @@protoc_insertion_point(field_mutable:server.v1.ServerMetadata.host) + return _s; +} +inline const std::string& ServerMetadata::_internal_host() const { + return _impl_.host_.Get(); +} +inline void ServerMetadata::_internal_set_host(const std::string& value) { + ; + + + _impl_.host_.Set(value, GetArenaForAllocation()); +} +inline std::string* ServerMetadata::_internal_mutable_host() { + ; + return _impl_.host_.Mutable( GetArenaForAllocation()); +} +inline std::string* ServerMetadata::release_host() { + // @@protoc_insertion_point(field_release:server.v1.ServerMetadata.host) + return _impl_.host_.Release(); +} +inline void ServerMetadata::set_allocated_host(std::string* value) { + _impl_.host_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.host_.IsDefault()) { + _impl_.host_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:server.v1.ServerMetadata.host) +} + +// repeated .server.v1.ProtocolSupport protocols = 2 [json_name = "protocols"]; +inline int ServerMetadata::_internal_protocols_size() const { + return _impl_.protocols_.size(); +} +inline int ServerMetadata::protocols_size() const { + return _internal_protocols_size(); +} +inline void ServerMetadata::clear_protocols() { + _internal_mutable_protocols()->Clear(); +} +inline ::server::v1::ProtocolSupport* ServerMetadata::mutable_protocols(int index) { + // @@protoc_insertion_point(field_mutable:server.v1.ServerMetadata.protocols) + return _internal_mutable_protocols()->Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::server::v1::ProtocolSupport >* +ServerMetadata::mutable_protocols() { + // @@protoc_insertion_point(field_mutable_list:server.v1.ServerMetadata.protocols) + return _internal_mutable_protocols(); +} +inline const ::server::v1::ProtocolSupport& ServerMetadata::_internal_protocols(int index) const { + return _internal_protocols().Get(index); +} +inline const ::server::v1::ProtocolSupport& ServerMetadata::protocols(int index) const { + // @@protoc_insertion_point(field_get:server.v1.ServerMetadata.protocols) + return _internal_protocols(index); +} +inline ::server::v1::ProtocolSupport* ServerMetadata::_internal_add_protocols() { + return _internal_mutable_protocols()->Add(); +} +inline ::server::v1::ProtocolSupport* ServerMetadata::add_protocols() { + ::server::v1::ProtocolSupport* _add = _internal_add_protocols(); + // @@protoc_insertion_point(field_add:server.v1.ServerMetadata.protocols) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::server::v1::ProtocolSupport >& +ServerMetadata::protocols() const { + // @@protoc_insertion_point(field_list:server.v1.ServerMetadata.protocols) + return _internal_protocols(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::server::v1::ProtocolSupport>& +ServerMetadata::_internal_protocols() const { + return _impl_.protocols_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::server::v1::ProtocolSupport>* +ServerMetadata::_internal_mutable_protocols() { + return &_impl_.protocols_; +} + +// ------------------------------------------------------------------- + +// ProtocolSupport + +// .server.v1.Protocol protocol = 1 [json_name = "protocol"]; +inline void ProtocolSupport::clear_protocol() { + _impl_.protocol_ = 0; +} +inline ::server::v1::Protocol ProtocolSupport::protocol() const { + // @@protoc_insertion_point(field_get:server.v1.ProtocolSupport.protocol) + return _internal_protocol(); +} +inline void ProtocolSupport::set_protocol(::server::v1::Protocol value) { + _internal_set_protocol(value); + // @@protoc_insertion_point(field_set:server.v1.ProtocolSupport.protocol) +} +inline ::server::v1::Protocol ProtocolSupport::_internal_protocol() const { + return static_cast<::server::v1::Protocol>(_impl_.protocol_); +} +inline void ProtocolSupport::_internal_set_protocol(::server::v1::Protocol value) { + ; + _impl_.protocol_ = value; +} + +// repeated .server.v1.HTTPVersion http_versions = 2 [json_name = "httpVersions"]; +inline int ProtocolSupport::_internal_http_versions_size() const { + return _impl_.http_versions_.size(); +} +inline int ProtocolSupport::http_versions_size() const { + return _internal_http_versions_size(); +} +inline void ProtocolSupport::clear_http_versions() { + _internal_mutable_http_versions()->Clear(); +} +inline ::server::v1::HTTPVersion* ProtocolSupport::mutable_http_versions(int index) { + // @@protoc_insertion_point(field_mutable:server.v1.ProtocolSupport.http_versions) + return _internal_mutable_http_versions()->Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::server::v1::HTTPVersion >* +ProtocolSupport::mutable_http_versions() { + // @@protoc_insertion_point(field_mutable_list:server.v1.ProtocolSupport.http_versions) + return _internal_mutable_http_versions(); +} +inline const ::server::v1::HTTPVersion& ProtocolSupport::_internal_http_versions(int index) const { + return _internal_http_versions().Get(index); +} +inline const ::server::v1::HTTPVersion& ProtocolSupport::http_versions(int index) const { + // @@protoc_insertion_point(field_get:server.v1.ProtocolSupport.http_versions) + return _internal_http_versions(index); +} +inline ::server::v1::HTTPVersion* ProtocolSupport::_internal_add_http_versions() { + return _internal_mutable_http_versions()->Add(); +} +inline ::server::v1::HTTPVersion* ProtocolSupport::add_http_versions() { + ::server::v1::HTTPVersion* _add = _internal_add_http_versions(); + // @@protoc_insertion_point(field_add:server.v1.ProtocolSupport.http_versions) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::server::v1::HTTPVersion >& +ProtocolSupport::http_versions() const { + // @@protoc_insertion_point(field_list:server.v1.ProtocolSupport.http_versions) + return _internal_http_versions(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::server::v1::HTTPVersion>& +ProtocolSupport::_internal_http_versions() const { + return _impl_.http_versions_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::server::v1::HTTPVersion>* +ProtocolSupport::_internal_mutable_http_versions() { + return &_impl_.http_versions_; +} + +// string port = 3 [json_name = "port"]; +inline void ProtocolSupport::clear_port() { + _impl_.port_.ClearToEmpty(); +} +inline const std::string& ProtocolSupport::port() const { + // @@protoc_insertion_point(field_get:server.v1.ProtocolSupport.port) + return _internal_port(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ProtocolSupport::set_port(Arg_&& arg, + Args_... args) { + ; + _impl_.port_.Set(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:server.v1.ProtocolSupport.port) +} +inline std::string* ProtocolSupport::mutable_port() { + std::string* _s = _internal_mutable_port(); + // @@protoc_insertion_point(field_mutable:server.v1.ProtocolSupport.port) + return _s; +} +inline const std::string& ProtocolSupport::_internal_port() const { + return _impl_.port_.Get(); +} +inline void ProtocolSupport::_internal_set_port(const std::string& value) { + ; + + + _impl_.port_.Set(value, GetArenaForAllocation()); +} +inline std::string* ProtocolSupport::_internal_mutable_port() { + ; + return _impl_.port_.Mutable( GetArenaForAllocation()); +} +inline std::string* ProtocolSupport::release_port() { + // @@protoc_insertion_point(field_release:server.v1.ProtocolSupport.port) + return _impl_.port_.Release(); +} +inline void ProtocolSupport::set_allocated_port(std::string* value) { + _impl_.port_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.port_.IsDefault()) { + _impl_.port_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:server.v1.ProtocolSupport.port) +} + +// ------------------------------------------------------------------- + +// HTTPVersion + +// int32 major = 1 [json_name = "major"]; +inline void HTTPVersion::clear_major() { + _impl_.major_ = 0; +} +inline ::int32_t HTTPVersion::major() const { + // @@protoc_insertion_point(field_get:server.v1.HTTPVersion.major) + return _internal_major(); +} +inline void HTTPVersion::set_major(::int32_t value) { + _internal_set_major(value); + // @@protoc_insertion_point(field_set:server.v1.HTTPVersion.major) +} +inline ::int32_t HTTPVersion::_internal_major() const { + return _impl_.major_; +} +inline void HTTPVersion::_internal_set_major(::int32_t value) { + ; + _impl_.major_ = value; +} + +// int32 minor = 2 [json_name = "minor"]; +inline void HTTPVersion::clear_minor() { + _impl_.minor_ = 0; +} +inline ::int32_t HTTPVersion::minor() const { + // @@protoc_insertion_point(field_get:server.v1.HTTPVersion.minor) + return _internal_minor(); +} +inline void HTTPVersion::set_minor(::int32_t value) { + _internal_set_minor(value); + // @@protoc_insertion_point(field_set:server.v1.HTTPVersion.minor) +} +inline ::int32_t HTTPVersion::_internal_minor() const { + return _impl_.minor_; +} +inline void HTTPVersion::_internal_set_minor(::int32_t value) { + ; + _impl_.minor_ = value; +} + +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif // __GNUC__ + +// @@protoc_insertion_point(namespace_scope) +} // namespace v1 +} // namespace server + + +PROTOBUF_NAMESPACE_OPEN + +template <> +struct is_proto_enum<::server::v1::Protocol> : std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor<::server::v1::Protocol>() { + return ::server::v1::Protocol_descriptor(); +} + +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) + +#include "google/protobuf/port_undef.inc" + +#endif // GOOGLE_PROTOBUF_INCLUDED_server_2fv1_2fserver_2eproto_2epb_2eh diff --git a/cc/grpc_client_test.cc b/cc/grpc_client_test.cc new file mode 100644 index 00000000..e0fd5598 --- /dev/null +++ b/cc/grpc_client_test.cc @@ -0,0 +1,559 @@ +#include +#include + +#include "absl/container/flat_hash_map.h" +#include "absl/strings/escaping.h" +#include "absl/strings/str_split.h" +#include "absl/time/clock.h" +#include "connectrpc/conformance/test.grpc.pb.h" +#include "connectrpc/conformance/test.pb.h" +#include "gmock/gmock.h" +#include "google/rpc/status.pb.h" +#include "grpcpp/channel.h" +#include "grpcpp/client_context.h" +#include "grpcpp/create_channel.h" +#include "grpcpp/grpcpp.h" +#include "grpcpp/security/credentials.h" +#include "gtest/gtest.h" + +namespace connectrpc::conformance { +namespace { +constexpr int kEightBytes = 8; + +constexpr int kSixteenBytes = 16; +constexpr int kOneKiB = 1024; +constexpr int kTwoKiB = 2028; +constexpr int kThirtyTwoKiB = 32768; +constexpr int kSixtyFourKiB = 65536; +constexpr int kTwoFiftyKiB = 256000; +constexpr int kFiveHundredKiB = 512000; +constexpr int kLargeReqSize = kTwoFiftyKiB; +constexpr int kLargeRespSize = kFiveHundredKiB; +constexpr const auto kLeadingMetadataKey = "x-grpc-test-echo-initial"; +constexpr const auto kTrailingMetadataKey = "x-grpc-test-echo-trailing-bin"; + +constexpr std::array kReqSizes = {kTwoFiftyKiB, kEightBytes, kOneKiB, kThirtyTwoKiB}; +constexpr std::array kRespSizes = {kFiveHundredKiB, kSixteenBytes, kTwoKiB, kSixtyFourKiB}; +using metadata_t = absl::flat_hash_map>; + +class GrpcClientTest : public ::testing::Test { + public: + static void SetUpTestSuite() { + // Get the port from the env + std::string port = getEnvStr("PORT"); + ASSERT_FALSE(port.empty()) << "PORT env var must be set"; + // Get the host from the env + std::string host = getEnvStr("HOST", "127.0.0.1"); + // Get the insecure cert from the env + std::string certFile = getEnvStr("CERT_FILE"); + std::string keyFile = getEnvStr("KEY_FILE"); + if (!certFile.empty() || !keyFile.empty()) { + channel = grpc::CreateChannel( + host + ":" + port, + grpc::SslCredentials(grpc::SslCredentialsOptions{ + .pem_root_certs = certFile, + .pem_private_key = keyFile, + })); + } else { + channel = grpc::CreateChannel(host + ":" + port, grpc::InsecureChannelCredentials()); + } + stub = TestService::NewStub(channel); + } + + static void TearDownTestSuite() { + stub = nullptr; + channel = nullptr; + } + + protected: + static std::string getEnvStr(const char* name, const char* defaultValue = "") { + const char* value = std::getenv(name); + if (value == nullptr) { + return defaultValue; + } + return value; + } + + static std::shared_ptr channel; + static std::unique_ptr stub; + + void newPayload(PayloadType type, int size, Payload* payload) { + payload->set_type(type); + payload->set_body(std::string(size, '\0')); + } + + void addMetadata( + metadata_t customMetadataString, + metadata_t customMetadataBinary, + grpc::ClientContext* context) { + for (const auto& [key, values] : customMetadataString) { + for (const auto& value : values) { + context->AddMetadata(key, value); + } + } + for (const auto& [key, values] : customMetadataBinary) { + for (const auto& value : values) { + std::string encoded; + absl::Base64Escape(value, &encoded); + context->AddMetadata(key, encoded); + } + } + } + + void customMetadataUnaryTest(metadata_t customMetadataString, metadata_t customMetadataBinary) { + grpc::ClientContext context; + addMetadata(customMetadataString, customMetadataBinary, &context); + SimpleRequest req; + req.set_response_type(PayloadType::COMPRESSABLE); + req.set_response_size(1); + newPayload(PayloadType::COMPRESSABLE, 1, req.mutable_payload()); + + SimpleResponse res; + auto result = stub->UnaryCall(&context, req, &res); + EXPECT_TRUE(result.ok()) << result.error_code() << ": " << result.error_message(); + EXPECT_EQ(res.payload().type(), PayloadType::COMPRESSABLE); + EXPECT_EQ(res.payload().body().size(), 1); + validateMetadata(context, customMetadataString, customMetadataBinary); + } + + void customMetadataServerStreamingTest( + metadata_t customMetadataString, metadata_t customMetadataBinary) { + grpc::ClientContext context; + addMetadata(customMetadataString, customMetadataBinary, &context); + StreamingOutputCallRequest req; + req.set_response_type(PayloadType::COMPRESSABLE); + req.add_response_parameters()->set_size(1); + newPayload(PayloadType::COMPRESSABLE, 1, req.mutable_payload()); + auto stream = stub->StreamingOutputCall(&context, req); + StreamingOutputCallResponse res; + EXPECT_TRUE(stream->Read(&res)); + EXPECT_EQ(res.payload().type(), PayloadType::COMPRESSABLE); + EXPECT_EQ(res.payload().body().size(), 1); + auto result = stream->Finish(); + EXPECT_TRUE(result.ok()) << result.error_code() << ": " << result.error_message(); + validateMetadata(context, customMetadataString, customMetadataBinary); + } + + void customMetadataFullDuplexTest( + metadata_t customMetadataString, metadata_t customMetadataBinary) { + grpc::ClientContext context; + addMetadata(customMetadataString, customMetadataBinary, &context); + auto stream = stub->FullDuplexCall(&context); + StreamingOutputCallRequest req; + req.set_response_type(PayloadType::COMPRESSABLE); + req.add_response_parameters()->set_size(1); + newPayload(PayloadType::COMPRESSABLE, 1, req.mutable_payload()); + EXPECT_TRUE(stream->Write(req)); + StreamingOutputCallResponse res; + EXPECT_TRUE(stream->Read(&res)); + EXPECT_EQ(res.payload().type(), PayloadType::COMPRESSABLE); + EXPECT_EQ(res.payload().body().size(), 1); + stream->WritesDone(); + auto result = stream->Finish(); + EXPECT_TRUE(result.ok()) << result.error_code() << ": " << result.error_message(); + validateMetadata(context, customMetadataString, customMetadataBinary); + } + + void validateMetadata( + const grpc::ClientContext& context, + metadata_t expectedMetadataString, + metadata_t expectedMetadataBinary) { + const auto header = context.GetServerInitialMetadata(); + const auto trailer = context.GetServerTrailingMetadata(); + for (const auto& [key, values] : expectedMetadataString) { + auto range = header.equal_range(key); + EXPECT_TRUE(range.first != range.second) << "key: " << key; + if (range.first == range.second) { + continue; + } + std::vector actualValues; + for (auto it = range.first; it != range.second; ++it) { + actualValues.emplace_back(it->second.data(), it->second.size()); + } + // The server may have combined multiple lines for a field to a single line, see + // https://www.rfc-editor.org/rfc/rfc9110.html#section-5.3. + if (values.size() != actualValues.size() && actualValues.size() == 1) { + actualValues = absl::StrSplit(actualValues[0], ", "); + } + EXPECT_THAT(actualValues, testing::UnorderedElementsAreArray(values)) << "key: " << key; + } + for (const auto& [key, values] : expectedMetadataBinary) { + auto range = trailer.equal_range(key); + EXPECT_TRUE(range.first != range.second) << "key: " << key; + if (range.first == range.second) { + continue; + } + std::vector actualValues; + for (auto it = range.first; it != range.second; ++it) { + actualValues.emplace_back(it->second.data(), it->second.size()); + } + // The server may have combined multiple lines for a field to a single line, see + // https://www.rfc-editor.org/rfc/rfc9110.html#section-5.3. + if (values.size() != actualValues.size() && actualValues.size() == 1) { + actualValues = absl::StrSplit(actualValues[0], ", "); + } + // Decode the base64 encoded values. + for (auto& value : actualValues) { + std::string decoded; + EXPECT_TRUE(absl::Base64Unescape(value, &decoded)); + value = decoded; + } + EXPECT_THAT(actualValues, testing::UnorderedElementsAreArray(values)) << "key: " << key; + } + } +}; + +std::shared_ptr GrpcClientTest::channel = nullptr; +std::unique_ptr GrpcClientTest::stub = nullptr; + +TEST_F(GrpcClientTest, EmptyUnary) { + grpc::ClientContext context; + google::protobuf::Empty res; + auto result = stub->EmptyCall(&context, google::protobuf::Empty::default_instance(), &res); + EXPECT_TRUE(result.ok()) << result.error_code() << ": " << result.error_message(); +} + +// Performs an idempotent unary RPC with empty request and response messages. +TEST_F(GrpcClientTest, CacheableUnaryCall) { + grpc::ClientContext context; + SimpleRequest req; + req.set_response_type(PayloadType::COMPRESSABLE); + req.set_response_size(1); + newPayload(PayloadType::COMPRESSABLE, 1, req.mutable_payload()); + + SimpleResponse res; + auto result = stub->CacheableUnaryCall(&context, req, &res); + EXPECT_TRUE(result.ok()) << result.error_code() << ": " << result.error_message(); + EXPECT_EQ(res.payload().type(), PayloadType::COMPRESSABLE); + EXPECT_EQ(res.payload().body().size(), 1); +} + +// Performs a unary RPC with large payload in the request and response. +TEST_F(GrpcClientTest, LargeUnaryCall) { + grpc::ClientContext context; + SimpleRequest req; + req.set_response_type(PayloadType::COMPRESSABLE); + req.set_response_size(kLargeRespSize); + newPayload(PayloadType::COMPRESSABLE, kLargeReqSize, req.mutable_payload()); + + SimpleResponse res; + auto result = stub->UnaryCall(&context, req, &res); + EXPECT_TRUE(result.ok()) << result.error_code() << ": " << result.error_message(); + EXPECT_EQ(res.payload().type(), PayloadType::COMPRESSABLE); + EXPECT_EQ(res.payload().body().size(), kLargeRespSize); +} + +// Performs a client streaming RPC. +TEST_F(GrpcClientTest, ClientStreaming) { + grpc::ClientContext context; + StreamingInputCallResponse res; + auto stream = stub->StreamingInputCall(&context, &res); + int sum = 0; + for (int size : kReqSizes) { + StreamingInputCallRequest req; + newPayload(PayloadType::COMPRESSABLE, size, req.mutable_payload()); + EXPECT_TRUE(stream->Write(req)); + sum += size; + } + stream->WritesDone(); + auto result = stream->Finish(); + EXPECT_TRUE(result.ok()) << result.error_code() << ": " << result.error_message(); + EXPECT_EQ(res.aggregated_payload_size(), sum); +} + +// Performs a server streaming RPC. +TEST_F(GrpcClientTest, ServerStreaming) { + grpc::ClientContext context; + StreamingOutputCallRequest req; + req.set_response_type(PayloadType::COMPRESSABLE); + for (int size : kRespSizes) { + req.add_response_parameters()->set_size(size); + } + auto stream = stub->StreamingOutputCall(&context, req); + StreamingOutputCallResponse res; + int i = 0; + while (stream->Read(&res)) { + EXPECT_EQ(res.payload().type(), PayloadType::COMPRESSABLE); + EXPECT_EQ(res.payload().body().size(), kRespSizes.at(i++)); + } +} + +// Performs a ping-pong style bi-directional streaming RPC. +TEST_F(GrpcClientTest, PingPong) { + grpc::ClientContext context; + auto stream = stub->FullDuplexCall(&context); + for (int reqSize : kReqSizes) { + StreamingOutputCallRequest req; + req.set_response_type(PayloadType::COMPRESSABLE); + req.add_response_parameters()->set_size(reqSize); + newPayload(PayloadType::COMPRESSABLE, reqSize, req.mutable_payload()); + EXPECT_TRUE(stream->Write(req)); + StreamingOutputCallResponse res; + EXPECT_TRUE(stream->Read(&res)); + EXPECT_EQ(res.payload().type(), PayloadType::COMPRESSABLE); + EXPECT_EQ(res.payload().body().size(), reqSize); + } + stream->WritesDone(); + auto result = stream->Finish(); + EXPECT_TRUE(result.ok()) << result.error_code() << ": " << result.error_message(); +} + +// Sets up a bidi streaming with zero messages. +TEST_F(GrpcClientTest, EmptyStream) { + grpc::ClientContext context; + auto stream = stub->FullDuplexCall(&context); + stream->WritesDone(); + auto result = stream->Finish(); + EXPECT_TRUE(result.ok()) << result.error_code() << ": " << result.error_message(); +} + +// Performs an RPC on a sleep server which causes RPC timeout. +TEST_F(GrpcClientTest, TimeoutOnSleepingServer) { + grpc::ClientContext context; + context.set_deadline(std::chrono::system_clock::now() + std::chrono::milliseconds(500)); + auto stream = stub->FullDuplexCall(&context); + StreamingOutputCallRequest req; + newPayload(PayloadType::COMPRESSABLE, 27182, req.mutable_payload()); + stream->Write(req); + absl::SleepFor(absl::Seconds(1)); + auto result = stream->Finish(); + EXPECT_EQ(result.error_code(), grpc::StatusCode::DEADLINE_EXCEEDED); +} + +// Cancels the RPC after metadata has been sent but before payloads are sent. +TEST_F(GrpcClientTest, CancelAfterBegin) { + grpc::ClientContext context; + StreamingInputCallResponse res; + auto stream = stub->StreamingInputCall(&context, &res); + context.TryCancel(); + auto result = stream->Finish(); + EXPECT_EQ(result.error_code(), grpc::StatusCode::CANCELLED); +} + +// Cancels the RPC after receiving the first message from the server. +TEST_F(GrpcClientTest, CancelAfterFirstResponse) { + grpc::ClientContext context; + auto stream = stub->FullDuplexCall(&context); + StreamingOutputCallRequest req; + req.set_response_type(PayloadType::COMPRESSABLE); + req.add_response_parameters()->set_size(31415); + newPayload(PayloadType::COMPRESSABLE, 27182, req.mutable_payload()); + EXPECT_TRUE(stream->Write(req)); + StreamingOutputCallResponse res; + EXPECT_TRUE(stream->Read(&res)); + context.TryCancel(); + auto result = stream->Finish(); + EXPECT_EQ(result.error_code(), grpc::StatusCode::CANCELLED); +} + +constexpr auto kLeadingMetadataValue = "test_initial_metadata_value"; +constexpr auto kTrailingMetadataValue = "\x0a\x0b\x0a\x0b\x0a\x0b"; + +// Checks that metadata is echoed back to the client with unary call. +TEST_F(GrpcClientTest, CustomMetadataUnary) { + metadata_t customMetadataString = { + {kLeadingMetadataKey, {kLeadingMetadataValue}}, + }; + metadata_t customMetadataBinary = { + {kTrailingMetadataKey, {kTrailingMetadataValue}}, + }; + customMetadataUnaryTest(customMetadataString, customMetadataBinary); +} + +// Checks that metadata is echoed back to the client with server streaming call. +TEST_F(GrpcClientTest, CustomMetadataServerStreaming) { + metadata_t customMetadataString = { + {kLeadingMetadataKey, {kLeadingMetadataValue}}, + }; + metadata_t customMetadataBinary = { + {kTrailingMetadataKey, {kTrailingMetadataValue}}, + }; + customMetadataServerStreamingTest(customMetadataString, customMetadataBinary); +} + +// Checks that metadata is echoed back to the client with bidi streaming call. +TEST_F(GrpcClientTest, CustomMetadataFullDuplex) { + metadata_t customMetadataString = { + {kLeadingMetadataKey, {kLeadingMetadataValue}}, + }; + metadata_t customMetadataBinary = { + {kTrailingMetadataKey, {kTrailingMetadataValue}}, + }; + customMetadataFullDuplexTest(customMetadataString, customMetadataBinary); +} + +// Adds duplicated metadata keys and checks that the metadata is echoed back +// to the client with unary call. +TEST_F(GrpcClientTest, DuplicatedCustomMetadataUnary) { + metadata_t customMetadataString = { + {kLeadingMetadataKey, + {kLeadingMetadataValue, kLeadingMetadataValue + std::string(";more_stuff")}}, + }; + metadata_t customMetadataBinary = { + {kTrailingMetadataKey, + {kTrailingMetadataValue, kTrailingMetadataValue + std::string("\x0a")}}, + }; + customMetadataUnaryTest(customMetadataString, customMetadataBinary); +} + +TEST_F(GrpcClientTest, DuplicatedCustomMetadataServerStreaming) { + metadata_t customMetadataString = { + {kLeadingMetadataKey, + {kLeadingMetadataValue, kLeadingMetadataValue + std::string(";more_stuff")}}, + }; + metadata_t customMetadataBinary = { + {kTrailingMetadataKey, + {kTrailingMetadataValue, kTrailingMetadataValue + std::string("\x0a")}}, + }; + customMetadataServerStreamingTest(customMetadataString, customMetadataBinary); +} + +TEST_F(GrpcClientTest, DuplicatedCustomMetadataFullDuplex) { + metadata_t customMetadataString = { + {kLeadingMetadataKey, + {kLeadingMetadataValue, kLeadingMetadataValue + std::string(";more_stuff")}}, + }; + metadata_t customMetadataBinary = { + {kTrailingMetadataKey, + {kTrailingMetadataValue, kTrailingMetadataValue + std::string("\x0a")}}, + }; + customMetadataFullDuplexTest(customMetadataString, customMetadataBinary); +} + +// Checks that the status code is propagated back to the client with unary call. +TEST_F(GrpcClientTest, StatusCodeAndMessageUnary) { + grpc::ClientContext context; + SimpleRequest req; + req.mutable_response_status()->set_code(grpc::StatusCode::UNKNOWN); + req.mutable_response_status()->set_message("test status message"); + SimpleResponse res; + auto result = stub->UnaryCall(&context, req, &res); + EXPECT_EQ(result.error_code(), grpc::StatusCode::UNKNOWN); + EXPECT_EQ(result.error_message(), "test status message"); +} + +TEST_F(GrpcClientTest, StatusCodeAndMessageFullDuplex) { + grpc::ClientContext context; + auto stream = stub->FullDuplexCall(&context); + StreamingOutputCallRequest req; + req.mutable_response_status()->set_code(grpc::StatusCode::UNKNOWN); + req.mutable_response_status()->set_message("test status message"); + EXPECT_TRUE(stream->Write(req)); + stream->WritesDone(); + auto result = stream->Finish(); + EXPECT_EQ(result.error_code(), grpc::StatusCode::UNKNOWN); + EXPECT_EQ(result.error_message(), "test status message"); +} + +// Verifies Unicode and whitespace is correctly processed in status message +TEST_F(GrpcClientTest, SpecialStatusMessage) { + std::string msg = "\t\ntest with whitespace\r\nand Unicode BMP ☺ and non-BMP 😈\t\n"; + grpc::ClientContext context; + SimpleRequest req; + req.mutable_response_status()->set_code(grpc::StatusCode::UNKNOWN); + req.mutable_response_status()->set_message(msg); + SimpleResponse res; + auto result = stub->UnaryCall(&context, req, &res); + EXPECT_EQ(result.error_code(), grpc::StatusCode::UNKNOWN); + EXPECT_EQ(result.error_message(), msg); +} + +// Attempts to call an unimplemented method. +TEST_F(GrpcClientTest, UnimplementedMethod) { + grpc::ClientContext context; + google::protobuf::Empty req; + google::protobuf::Empty res; + auto result = stub->UnimplementedCall(&context, req, &res); + EXPECT_EQ(result.error_code(), grpc::StatusCode::UNIMPLEMENTED); +} + +// Performs a server streaming RPC that is unimplemented. +TEST_F(GrpcClientTest, UnimplementedServerStreamingMehod) { + grpc::ClientContext context; + google::protobuf::Empty req; + auto stream = stub->UnimplementedStreamingOutputCall(&context, req); + auto result = stream->Finish(); + EXPECT_EQ(result.error_code(), grpc::StatusCode::UNIMPLEMENTED); +} + +// Attempts to call a method from an unimplemented service. +TEST_F(GrpcClientTest, UnimplementedService) { + UnimplementedService::Stub ustub(channel); + grpc::ClientContext context; + google::protobuf::Empty req; + google::protobuf::Empty res; + auto result = ustub.UnimplementedCall(&context, req, &res); + + // TODO: 404 should always be UNIMPLEMENTED. Report the bug to gRPC. + if (result.error_code() != grpc::StatusCode::UNKNOWN) { + EXPECT_EQ(result.error_code(), grpc::StatusCode::UNIMPLEMENTED) << result.error_message(); + } +} + +// Performs a server streaming RPC from an unimplemented service. +TEST_F(GrpcClientTest, UnimplementedServiceStreaming) { + UnimplementedService::Stub ustub(channel); + grpc::ClientContext context; + google::protobuf::Empty req; + auto stream = ustub.UnimplementedStreamingOutputCall(&context, req); + auto result = stream->Finish(); + // TODO: 404 should always be UNIMPLEMENTED. Report the bug to gRPC. + if (result.error_code() != grpc::StatusCode::UNKNOWN) { + EXPECT_EQ(result.error_code(), grpc::StatusCode::UNIMPLEMENTED) << result.error_message(); + } +} + +constexpr auto kNonAsciiError = "soirée 🎉"; + +void checkNonAsciiError(const grpc::Status& result) { + EXPECT_EQ(result.error_code(), grpc::StatusCode::RESOURCE_EXHAUSTED); + EXPECT_EQ(result.error_message(), kNonAsciiError); + google::rpc::Status status; + status.ParseFromString(result.error_details()); + EXPECT_EQ(status.code(), grpc::StatusCode::RESOURCE_EXHAUSTED); + EXPECT_EQ(status.message(), kNonAsciiError); + ASSERT_EQ(status.details_size(), 1); + ErrorDetail error_details; + // status.details().at(0).UnpackTo(&error_details); + error_details.ParseFromString(status.details().at(0).value()); + EXPECT_EQ(error_details.reason(), kNonAsciiError); + EXPECT_EQ(error_details.domain(), "connect-crosstest"); +} + +// Performs a unary RPC that always return a readable non-ASCII error. +TEST_F(GrpcClientTest, FailWithNonAsciiError) { + grpc::ClientContext context; + SimpleRequest req; + req.set_response_type(PayloadType::COMPRESSABLE); + SimpleResponse res; + checkNonAsciiError(stub->FailUnaryCall(&context, req, &res)); +} + +// Performs a server streaming RPC that always return a readable non-ASCII error. +TEST_F(GrpcClientTest, FailServerStreamingWithNonASCIIError) { + grpc::ClientContext context; + StreamingOutputCallRequest req; + req.set_response_type(PayloadType::COMPRESSABLE); + auto stream = stub->FailStreamingOutputCall(&context, req); + checkNonAsciiError(stream->Finish()); +} + +TEST_F(GrpcClientTest, FailServerStreamingAfterResponse) { + StreamingOutputCallRequest req; + req.set_response_type(PayloadType::COMPRESSABLE); + for (int size : kRespSizes) { + req.add_response_parameters()->set_size(size); + } + grpc::ClientContext context; + auto stream = stub->FailStreamingOutputCall(&context, req); + StreamingOutputCallResponse res; + for (int size : kRespSizes) { + EXPECT_TRUE(stream->Read(&res)); + EXPECT_EQ(res.payload().type(), PayloadType::COMPRESSABLE); + EXPECT_EQ(res.payload().body().size(), size); + } + checkNonAsciiError(stream->Finish()); +} + +} // namespace +} // namespace connectrpc::conformance