1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: tensorflow/core/protobuf/master.proto
3
4 #include "tensorflow/core/protobuf/master.pb.h"
5
6 #include <algorithm>
7 #include <cstdint>
8
9 #include <google/protobuf/io/coded_stream.h>
10 #include <google/protobuf/extension_set.h>
11 #include <google/protobuf/wire_format_lite.h>
12 #include <google/protobuf/io/zero_copy_stream_impl_lite.h>
13 // @@protoc_insertion_point(includes)
14 #include <google/protobuf/port_def.inc>
15
16 PROTOBUF_PRAGMA_INIT_SEG
17
18 namespace _pb = ::PROTOBUF_NAMESPACE_ID;
19 namespace _pbi = _pb::internal;
20
21 namespace tensorflow {
CreateSessionRequest(::_pbi::ConstantInitialized)22 PROTOBUF_CONSTEXPR CreateSessionRequest::CreateSessionRequest(
23 ::_pbi::ConstantInitialized): _impl_{
24 /*decltype(_impl_.target_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
25 , /*decltype(_impl_.graph_def_)*/nullptr
26 , /*decltype(_impl_.config_)*/nullptr
27 , /*decltype(_impl_._cached_size_)*/{}} {}
28 struct CreateSessionRequestDefaultTypeInternal {
CreateSessionRequestDefaultTypeInternaltensorflow::CreateSessionRequestDefaultTypeInternal29 PROTOBUF_CONSTEXPR CreateSessionRequestDefaultTypeInternal()
30 : _instance(::_pbi::ConstantInitialized{}) {}
~CreateSessionRequestDefaultTypeInternaltensorflow::CreateSessionRequestDefaultTypeInternal31 ~CreateSessionRequestDefaultTypeInternal() {}
32 union { // NOLINT(misc-non-private-member-variables-in-classes)
33 CreateSessionRequest _instance;
34 };
35 };
36 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CreateSessionRequestDefaultTypeInternal _CreateSessionRequest_default_instance_;
CreateSessionResponse(::_pbi::ConstantInitialized)37 PROTOBUF_CONSTEXPR CreateSessionResponse::CreateSessionResponse(
38 ::_pbi::ConstantInitialized): _impl_{
39 /*decltype(_impl_.session_handle_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
40 , /*decltype(_impl_.graph_version_)*/::int64_t{0}
41 , /*decltype(_impl_._cached_size_)*/{}} {}
42 struct CreateSessionResponseDefaultTypeInternal {
CreateSessionResponseDefaultTypeInternaltensorflow::CreateSessionResponseDefaultTypeInternal43 PROTOBUF_CONSTEXPR CreateSessionResponseDefaultTypeInternal()
44 : _instance(::_pbi::ConstantInitialized{}) {}
~CreateSessionResponseDefaultTypeInternaltensorflow::CreateSessionResponseDefaultTypeInternal45 ~CreateSessionResponseDefaultTypeInternal() {}
46 union { // NOLINT(misc-non-private-member-variables-in-classes)
47 CreateSessionResponse _instance;
48 };
49 };
50 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CreateSessionResponseDefaultTypeInternal _CreateSessionResponse_default_instance_;
ExtendSessionRequest(::_pbi::ConstantInitialized)51 PROTOBUF_CONSTEXPR ExtendSessionRequest::ExtendSessionRequest(
52 ::_pbi::ConstantInitialized): _impl_{
53 /*decltype(_impl_.session_handle_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
54 , /*decltype(_impl_.graph_def_)*/nullptr
55 , /*decltype(_impl_.current_graph_version_)*/::int64_t{0}
56 , /*decltype(_impl_._cached_size_)*/{}} {}
57 struct ExtendSessionRequestDefaultTypeInternal {
ExtendSessionRequestDefaultTypeInternaltensorflow::ExtendSessionRequestDefaultTypeInternal58 PROTOBUF_CONSTEXPR ExtendSessionRequestDefaultTypeInternal()
59 : _instance(::_pbi::ConstantInitialized{}) {}
~ExtendSessionRequestDefaultTypeInternaltensorflow::ExtendSessionRequestDefaultTypeInternal60 ~ExtendSessionRequestDefaultTypeInternal() {}
61 union { // NOLINT(misc-non-private-member-variables-in-classes)
62 ExtendSessionRequest _instance;
63 };
64 };
65 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ExtendSessionRequestDefaultTypeInternal _ExtendSessionRequest_default_instance_;
ExtendSessionResponse(::_pbi::ConstantInitialized)66 PROTOBUF_CONSTEXPR ExtendSessionResponse::ExtendSessionResponse(
67 ::_pbi::ConstantInitialized): _impl_{
68 /*decltype(_impl_.new_graph_version_)*/::int64_t{0}
69 , /*decltype(_impl_._cached_size_)*/{}} {}
70 struct ExtendSessionResponseDefaultTypeInternal {
ExtendSessionResponseDefaultTypeInternaltensorflow::ExtendSessionResponseDefaultTypeInternal71 PROTOBUF_CONSTEXPR ExtendSessionResponseDefaultTypeInternal()
72 : _instance(::_pbi::ConstantInitialized{}) {}
~ExtendSessionResponseDefaultTypeInternaltensorflow::ExtendSessionResponseDefaultTypeInternal73 ~ExtendSessionResponseDefaultTypeInternal() {}
74 union { // NOLINT(misc-non-private-member-variables-in-classes)
75 ExtendSessionResponse _instance;
76 };
77 };
78 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ExtendSessionResponseDefaultTypeInternal _ExtendSessionResponse_default_instance_;
RunStepRequest(::_pbi::ConstantInitialized)79 PROTOBUF_CONSTEXPR RunStepRequest::RunStepRequest(
80 ::_pbi::ConstantInitialized): _impl_{
81 /*decltype(_impl_.feed_)*/{}
82 , /*decltype(_impl_.fetch_)*/{}
83 , /*decltype(_impl_.target_)*/{}
84 , /*decltype(_impl_.session_handle_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
85 , /*decltype(_impl_.partial_run_handle_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
86 , /*decltype(_impl_.options_)*/nullptr
87 , /*decltype(_impl_.request_id_)*/::int64_t{0}
88 , /*decltype(_impl_.store_errors_in_response_body_)*/false
89 , /*decltype(_impl_._cached_size_)*/{}} {}
90 struct RunStepRequestDefaultTypeInternal {
RunStepRequestDefaultTypeInternaltensorflow::RunStepRequestDefaultTypeInternal91 PROTOBUF_CONSTEXPR RunStepRequestDefaultTypeInternal()
92 : _instance(::_pbi::ConstantInitialized{}) {}
~RunStepRequestDefaultTypeInternaltensorflow::RunStepRequestDefaultTypeInternal93 ~RunStepRequestDefaultTypeInternal() {}
94 union { // NOLINT(misc-non-private-member-variables-in-classes)
95 RunStepRequest _instance;
96 };
97 };
98 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RunStepRequestDefaultTypeInternal _RunStepRequest_default_instance_;
RunStepResponse(::_pbi::ConstantInitialized)99 PROTOBUF_CONSTEXPR RunStepResponse::RunStepResponse(
100 ::_pbi::ConstantInitialized): _impl_{
101 /*decltype(_impl_.tensor_)*/{}
102 , /*decltype(_impl_.status_error_message_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
103 , /*decltype(_impl_.metadata_)*/nullptr
104 , /*decltype(_impl_.status_code_)*/0
105 , /*decltype(_impl_._cached_size_)*/{}} {}
106 struct RunStepResponseDefaultTypeInternal {
RunStepResponseDefaultTypeInternaltensorflow::RunStepResponseDefaultTypeInternal107 PROTOBUF_CONSTEXPR RunStepResponseDefaultTypeInternal()
108 : _instance(::_pbi::ConstantInitialized{}) {}
~RunStepResponseDefaultTypeInternaltensorflow::RunStepResponseDefaultTypeInternal109 ~RunStepResponseDefaultTypeInternal() {}
110 union { // NOLINT(misc-non-private-member-variables-in-classes)
111 RunStepResponse _instance;
112 };
113 };
114 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RunStepResponseDefaultTypeInternal _RunStepResponse_default_instance_;
PartialRunSetupRequest(::_pbi::ConstantInitialized)115 PROTOBUF_CONSTEXPR PartialRunSetupRequest::PartialRunSetupRequest(
116 ::_pbi::ConstantInitialized): _impl_{
117 /*decltype(_impl_.feed_)*/{}
118 , /*decltype(_impl_.fetch_)*/{}
119 , /*decltype(_impl_.target_)*/{}
120 , /*decltype(_impl_.session_handle_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
121 , /*decltype(_impl_.request_id_)*/::int64_t{0}
122 , /*decltype(_impl_._cached_size_)*/{}} {}
123 struct PartialRunSetupRequestDefaultTypeInternal {
PartialRunSetupRequestDefaultTypeInternaltensorflow::PartialRunSetupRequestDefaultTypeInternal124 PROTOBUF_CONSTEXPR PartialRunSetupRequestDefaultTypeInternal()
125 : _instance(::_pbi::ConstantInitialized{}) {}
~PartialRunSetupRequestDefaultTypeInternaltensorflow::PartialRunSetupRequestDefaultTypeInternal126 ~PartialRunSetupRequestDefaultTypeInternal() {}
127 union { // NOLINT(misc-non-private-member-variables-in-classes)
128 PartialRunSetupRequest _instance;
129 };
130 };
131 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PartialRunSetupRequestDefaultTypeInternal _PartialRunSetupRequest_default_instance_;
PartialRunSetupResponse(::_pbi::ConstantInitialized)132 PROTOBUF_CONSTEXPR PartialRunSetupResponse::PartialRunSetupResponse(
133 ::_pbi::ConstantInitialized): _impl_{
134 /*decltype(_impl_.partial_run_handle_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
135 , /*decltype(_impl_._cached_size_)*/{}} {}
136 struct PartialRunSetupResponseDefaultTypeInternal {
PartialRunSetupResponseDefaultTypeInternaltensorflow::PartialRunSetupResponseDefaultTypeInternal137 PROTOBUF_CONSTEXPR PartialRunSetupResponseDefaultTypeInternal()
138 : _instance(::_pbi::ConstantInitialized{}) {}
~PartialRunSetupResponseDefaultTypeInternaltensorflow::PartialRunSetupResponseDefaultTypeInternal139 ~PartialRunSetupResponseDefaultTypeInternal() {}
140 union { // NOLINT(misc-non-private-member-variables-in-classes)
141 PartialRunSetupResponse _instance;
142 };
143 };
144 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PartialRunSetupResponseDefaultTypeInternal _PartialRunSetupResponse_default_instance_;
CloseSessionRequest(::_pbi::ConstantInitialized)145 PROTOBUF_CONSTEXPR CloseSessionRequest::CloseSessionRequest(
146 ::_pbi::ConstantInitialized): _impl_{
147 /*decltype(_impl_.session_handle_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
148 , /*decltype(_impl_._cached_size_)*/{}} {}
149 struct CloseSessionRequestDefaultTypeInternal {
CloseSessionRequestDefaultTypeInternaltensorflow::CloseSessionRequestDefaultTypeInternal150 PROTOBUF_CONSTEXPR CloseSessionRequestDefaultTypeInternal()
151 : _instance(::_pbi::ConstantInitialized{}) {}
~CloseSessionRequestDefaultTypeInternaltensorflow::CloseSessionRequestDefaultTypeInternal152 ~CloseSessionRequestDefaultTypeInternal() {}
153 union { // NOLINT(misc-non-private-member-variables-in-classes)
154 CloseSessionRequest _instance;
155 };
156 };
157 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CloseSessionRequestDefaultTypeInternal _CloseSessionRequest_default_instance_;
CloseSessionResponse(::_pbi::ConstantInitialized)158 PROTOBUF_CONSTEXPR CloseSessionResponse::CloseSessionResponse(
159 ::_pbi::ConstantInitialized): _impl_{
160 /*decltype(_impl_._cached_size_)*/{}} {}
161 struct CloseSessionResponseDefaultTypeInternal {
CloseSessionResponseDefaultTypeInternaltensorflow::CloseSessionResponseDefaultTypeInternal162 PROTOBUF_CONSTEXPR CloseSessionResponseDefaultTypeInternal()
163 : _instance(::_pbi::ConstantInitialized{}) {}
~CloseSessionResponseDefaultTypeInternaltensorflow::CloseSessionResponseDefaultTypeInternal164 ~CloseSessionResponseDefaultTypeInternal() {}
165 union { // NOLINT(misc-non-private-member-variables-in-classes)
166 CloseSessionResponse _instance;
167 };
168 };
169 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CloseSessionResponseDefaultTypeInternal _CloseSessionResponse_default_instance_;
ResetRequest(::_pbi::ConstantInitialized)170 PROTOBUF_CONSTEXPR ResetRequest::ResetRequest(
171 ::_pbi::ConstantInitialized): _impl_{
172 /*decltype(_impl_.container_)*/{}
173 , /*decltype(_impl_.device_filters_)*/{}
174 , /*decltype(_impl_._cached_size_)*/{}} {}
175 struct ResetRequestDefaultTypeInternal {
ResetRequestDefaultTypeInternaltensorflow::ResetRequestDefaultTypeInternal176 PROTOBUF_CONSTEXPR ResetRequestDefaultTypeInternal()
177 : _instance(::_pbi::ConstantInitialized{}) {}
~ResetRequestDefaultTypeInternaltensorflow::ResetRequestDefaultTypeInternal178 ~ResetRequestDefaultTypeInternal() {}
179 union { // NOLINT(misc-non-private-member-variables-in-classes)
180 ResetRequest _instance;
181 };
182 };
183 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ResetRequestDefaultTypeInternal _ResetRequest_default_instance_;
ResetResponse(::_pbi::ConstantInitialized)184 PROTOBUF_CONSTEXPR ResetResponse::ResetResponse(
185 ::_pbi::ConstantInitialized): _impl_{
186 /*decltype(_impl_._cached_size_)*/{}} {}
187 struct ResetResponseDefaultTypeInternal {
ResetResponseDefaultTypeInternaltensorflow::ResetResponseDefaultTypeInternal188 PROTOBUF_CONSTEXPR ResetResponseDefaultTypeInternal()
189 : _instance(::_pbi::ConstantInitialized{}) {}
~ResetResponseDefaultTypeInternaltensorflow::ResetResponseDefaultTypeInternal190 ~ResetResponseDefaultTypeInternal() {}
191 union { // NOLINT(misc-non-private-member-variables-in-classes)
192 ResetResponse _instance;
193 };
194 };
195 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ResetResponseDefaultTypeInternal _ResetResponse_default_instance_;
ListDevicesRequest(::_pbi::ConstantInitialized)196 PROTOBUF_CONSTEXPR ListDevicesRequest::ListDevicesRequest(
197 ::_pbi::ConstantInitialized): _impl_{
198 /*decltype(_impl_.session_handle_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
199 , /*decltype(_impl_._cached_size_)*/{}} {}
200 struct ListDevicesRequestDefaultTypeInternal {
ListDevicesRequestDefaultTypeInternaltensorflow::ListDevicesRequestDefaultTypeInternal201 PROTOBUF_CONSTEXPR ListDevicesRequestDefaultTypeInternal()
202 : _instance(::_pbi::ConstantInitialized{}) {}
~ListDevicesRequestDefaultTypeInternaltensorflow::ListDevicesRequestDefaultTypeInternal203 ~ListDevicesRequestDefaultTypeInternal() {}
204 union { // NOLINT(misc-non-private-member-variables-in-classes)
205 ListDevicesRequest _instance;
206 };
207 };
208 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ListDevicesRequestDefaultTypeInternal _ListDevicesRequest_default_instance_;
ListDevicesResponse(::_pbi::ConstantInitialized)209 PROTOBUF_CONSTEXPR ListDevicesResponse::ListDevicesResponse(
210 ::_pbi::ConstantInitialized): _impl_{
211 /*decltype(_impl_.local_device_)*/{}
212 , /*decltype(_impl_.remote_device_)*/{}
213 , /*decltype(_impl_._cached_size_)*/{}} {}
214 struct ListDevicesResponseDefaultTypeInternal {
ListDevicesResponseDefaultTypeInternaltensorflow::ListDevicesResponseDefaultTypeInternal215 PROTOBUF_CONSTEXPR ListDevicesResponseDefaultTypeInternal()
216 : _instance(::_pbi::ConstantInitialized{}) {}
~ListDevicesResponseDefaultTypeInternaltensorflow::ListDevicesResponseDefaultTypeInternal217 ~ListDevicesResponseDefaultTypeInternal() {}
218 union { // NOLINT(misc-non-private-member-variables-in-classes)
219 ListDevicesResponse _instance;
220 };
221 };
222 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ListDevicesResponseDefaultTypeInternal _ListDevicesResponse_default_instance_;
MakeCallableRequest(::_pbi::ConstantInitialized)223 PROTOBUF_CONSTEXPR MakeCallableRequest::MakeCallableRequest(
224 ::_pbi::ConstantInitialized): _impl_{
225 /*decltype(_impl_.session_handle_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
226 , /*decltype(_impl_.options_)*/nullptr
227 , /*decltype(_impl_.request_id_)*/::int64_t{0}
228 , /*decltype(_impl_._cached_size_)*/{}} {}
229 struct MakeCallableRequestDefaultTypeInternal {
MakeCallableRequestDefaultTypeInternaltensorflow::MakeCallableRequestDefaultTypeInternal230 PROTOBUF_CONSTEXPR MakeCallableRequestDefaultTypeInternal()
231 : _instance(::_pbi::ConstantInitialized{}) {}
~MakeCallableRequestDefaultTypeInternaltensorflow::MakeCallableRequestDefaultTypeInternal232 ~MakeCallableRequestDefaultTypeInternal() {}
233 union { // NOLINT(misc-non-private-member-variables-in-classes)
234 MakeCallableRequest _instance;
235 };
236 };
237 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MakeCallableRequestDefaultTypeInternal _MakeCallableRequest_default_instance_;
MakeCallableResponse(::_pbi::ConstantInitialized)238 PROTOBUF_CONSTEXPR MakeCallableResponse::MakeCallableResponse(
239 ::_pbi::ConstantInitialized): _impl_{
240 /*decltype(_impl_.handle_)*/::int64_t{0}
241 , /*decltype(_impl_._cached_size_)*/{}} {}
242 struct MakeCallableResponseDefaultTypeInternal {
MakeCallableResponseDefaultTypeInternaltensorflow::MakeCallableResponseDefaultTypeInternal243 PROTOBUF_CONSTEXPR MakeCallableResponseDefaultTypeInternal()
244 : _instance(::_pbi::ConstantInitialized{}) {}
~MakeCallableResponseDefaultTypeInternaltensorflow::MakeCallableResponseDefaultTypeInternal245 ~MakeCallableResponseDefaultTypeInternal() {}
246 union { // NOLINT(misc-non-private-member-variables-in-classes)
247 MakeCallableResponse _instance;
248 };
249 };
250 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MakeCallableResponseDefaultTypeInternal _MakeCallableResponse_default_instance_;
RunCallableRequest(::_pbi::ConstantInitialized)251 PROTOBUF_CONSTEXPR RunCallableRequest::RunCallableRequest(
252 ::_pbi::ConstantInitialized): _impl_{
253 /*decltype(_impl_.feed_)*/{}
254 , /*decltype(_impl_.session_handle_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
255 , /*decltype(_impl_.handle_)*/::int64_t{0}
256 , /*decltype(_impl_.request_id_)*/::int64_t{0}
257 , /*decltype(_impl_._cached_size_)*/{}} {}
258 struct RunCallableRequestDefaultTypeInternal {
RunCallableRequestDefaultTypeInternaltensorflow::RunCallableRequestDefaultTypeInternal259 PROTOBUF_CONSTEXPR RunCallableRequestDefaultTypeInternal()
260 : _instance(::_pbi::ConstantInitialized{}) {}
~RunCallableRequestDefaultTypeInternaltensorflow::RunCallableRequestDefaultTypeInternal261 ~RunCallableRequestDefaultTypeInternal() {}
262 union { // NOLINT(misc-non-private-member-variables-in-classes)
263 RunCallableRequest _instance;
264 };
265 };
266 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RunCallableRequestDefaultTypeInternal _RunCallableRequest_default_instance_;
RunCallableResponse(::_pbi::ConstantInitialized)267 PROTOBUF_CONSTEXPR RunCallableResponse::RunCallableResponse(
268 ::_pbi::ConstantInitialized): _impl_{
269 /*decltype(_impl_.fetch_)*/{}
270 , /*decltype(_impl_.metadata_)*/nullptr
271 , /*decltype(_impl_._cached_size_)*/{}} {}
272 struct RunCallableResponseDefaultTypeInternal {
RunCallableResponseDefaultTypeInternaltensorflow::RunCallableResponseDefaultTypeInternal273 PROTOBUF_CONSTEXPR RunCallableResponseDefaultTypeInternal()
274 : _instance(::_pbi::ConstantInitialized{}) {}
~RunCallableResponseDefaultTypeInternaltensorflow::RunCallableResponseDefaultTypeInternal275 ~RunCallableResponseDefaultTypeInternal() {}
276 union { // NOLINT(misc-non-private-member-variables-in-classes)
277 RunCallableResponse _instance;
278 };
279 };
280 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RunCallableResponseDefaultTypeInternal _RunCallableResponse_default_instance_;
ReleaseCallableRequest(::_pbi::ConstantInitialized)281 PROTOBUF_CONSTEXPR ReleaseCallableRequest::ReleaseCallableRequest(
282 ::_pbi::ConstantInitialized): _impl_{
283 /*decltype(_impl_.session_handle_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
284 , /*decltype(_impl_.handle_)*/::int64_t{0}
285 , /*decltype(_impl_._cached_size_)*/{}} {}
286 struct ReleaseCallableRequestDefaultTypeInternal {
ReleaseCallableRequestDefaultTypeInternaltensorflow::ReleaseCallableRequestDefaultTypeInternal287 PROTOBUF_CONSTEXPR ReleaseCallableRequestDefaultTypeInternal()
288 : _instance(::_pbi::ConstantInitialized{}) {}
~ReleaseCallableRequestDefaultTypeInternaltensorflow::ReleaseCallableRequestDefaultTypeInternal289 ~ReleaseCallableRequestDefaultTypeInternal() {}
290 union { // NOLINT(misc-non-private-member-variables-in-classes)
291 ReleaseCallableRequest _instance;
292 };
293 };
294 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ReleaseCallableRequestDefaultTypeInternal _ReleaseCallableRequest_default_instance_;
ReleaseCallableResponse(::_pbi::ConstantInitialized)295 PROTOBUF_CONSTEXPR ReleaseCallableResponse::ReleaseCallableResponse(
296 ::_pbi::ConstantInitialized): _impl_{
297 /*decltype(_impl_._cached_size_)*/{}} {}
298 struct ReleaseCallableResponseDefaultTypeInternal {
ReleaseCallableResponseDefaultTypeInternaltensorflow::ReleaseCallableResponseDefaultTypeInternal299 PROTOBUF_CONSTEXPR ReleaseCallableResponseDefaultTypeInternal()
300 : _instance(::_pbi::ConstantInitialized{}) {}
~ReleaseCallableResponseDefaultTypeInternaltensorflow::ReleaseCallableResponseDefaultTypeInternal301 ~ReleaseCallableResponseDefaultTypeInternal() {}
302 union { // NOLINT(misc-non-private-member-variables-in-classes)
303 ReleaseCallableResponse _instance;
304 };
305 };
306 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ReleaseCallableResponseDefaultTypeInternal _ReleaseCallableResponse_default_instance_;
307 } // namespace tensorflow
308 namespace tensorflow {
309
310 // ===================================================================
311
312 class CreateSessionRequest::_Internal {
313 public:
314 static const ::tensorflow::GraphDef& graph_def(const CreateSessionRequest* msg);
315 static const ::tensorflow::ConfigProto& config(const CreateSessionRequest* msg);
316 };
317
318 const ::tensorflow::GraphDef&
graph_def(const CreateSessionRequest * msg)319 CreateSessionRequest::_Internal::graph_def(const CreateSessionRequest* msg) {
320 return *msg->_impl_.graph_def_;
321 }
322 const ::tensorflow::ConfigProto&
config(const CreateSessionRequest * msg)323 CreateSessionRequest::_Internal::config(const CreateSessionRequest* msg) {
324 return *msg->_impl_.config_;
325 }
clear_graph_def()326 void CreateSessionRequest::clear_graph_def() {
327 if (GetArenaForAllocation() == nullptr && _impl_.graph_def_ != nullptr) {
328 delete _impl_.graph_def_;
329 }
330 _impl_.graph_def_ = nullptr;
331 }
clear_config()332 void CreateSessionRequest::clear_config() {
333 if (GetArenaForAllocation() == nullptr && _impl_.config_ != nullptr) {
334 delete _impl_.config_;
335 }
336 _impl_.config_ = nullptr;
337 }
CreateSessionRequest(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)338 CreateSessionRequest::CreateSessionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
339 bool is_message_owned)
340 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
341 SharedCtor(arena, is_message_owned);
342 // @@protoc_insertion_point(arena_constructor:tensorflow.CreateSessionRequest)
343 }
CreateSessionRequest(const CreateSessionRequest & from)344 CreateSessionRequest::CreateSessionRequest(const CreateSessionRequest& from)
345 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
346 CreateSessionRequest* const _this = this; (void)_this;
347 new (&_impl_) Impl_{
348 decltype(_impl_.target_){}
349 , decltype(_impl_.graph_def_){nullptr}
350 , decltype(_impl_.config_){nullptr}
351 , /*decltype(_impl_._cached_size_)*/{}};
352
353 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
354 _impl_.target_.InitDefault();
355 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
356 _impl_.target_.Set("", GetArenaForAllocation());
357 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
358 if (!from._internal_target().empty()) {
359 _this->_impl_.target_.Set(from._internal_target(),
360 _this->GetArenaForAllocation());
361 }
362 if (from._internal_has_graph_def()) {
363 _this->_impl_.graph_def_ = new ::tensorflow::GraphDef(*from._impl_.graph_def_);
364 }
365 if (from._internal_has_config()) {
366 _this->_impl_.config_ = new ::tensorflow::ConfigProto(*from._impl_.config_);
367 }
368 // @@protoc_insertion_point(copy_constructor:tensorflow.CreateSessionRequest)
369 }
370
SharedCtor(::_pb::Arena * arena,bool is_message_owned)371 inline void CreateSessionRequest::SharedCtor(
372 ::_pb::Arena* arena, bool is_message_owned) {
373 (void)arena;
374 (void)is_message_owned;
375 new (&_impl_) Impl_{
376 decltype(_impl_.target_){}
377 , decltype(_impl_.graph_def_){nullptr}
378 , decltype(_impl_.config_){nullptr}
379 , /*decltype(_impl_._cached_size_)*/{}
380 };
381 _impl_.target_.InitDefault();
382 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
383 _impl_.target_.Set("", GetArenaForAllocation());
384 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
385 }
386
~CreateSessionRequest()387 CreateSessionRequest::~CreateSessionRequest() {
388 // @@protoc_insertion_point(destructor:tensorflow.CreateSessionRequest)
389 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
390 (void)arena;
391 return;
392 }
393 SharedDtor();
394 }
395
SharedDtor()396 inline void CreateSessionRequest::SharedDtor() {
397 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
398 _impl_.target_.Destroy();
399 if (this != internal_default_instance()) delete _impl_.graph_def_;
400 if (this != internal_default_instance()) delete _impl_.config_;
401 }
402
SetCachedSize(int size) const403 void CreateSessionRequest::SetCachedSize(int size) const {
404 _impl_._cached_size_.Set(size);
405 }
406
Clear()407 void CreateSessionRequest::Clear() {
408 // @@protoc_insertion_point(message_clear_start:tensorflow.CreateSessionRequest)
409 ::uint32_t cached_has_bits = 0;
410 // Prevent compiler warnings about cached_has_bits being unused
411 (void) cached_has_bits;
412
413 _impl_.target_.ClearToEmpty();
414 if (GetArenaForAllocation() == nullptr && _impl_.graph_def_ != nullptr) {
415 delete _impl_.graph_def_;
416 }
417 _impl_.graph_def_ = nullptr;
418 if (GetArenaForAllocation() == nullptr && _impl_.config_ != nullptr) {
419 delete _impl_.config_;
420 }
421 _impl_.config_ = nullptr;
422 _internal_metadata_.Clear<std::string>();
423 }
424
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)425 const char* CreateSessionRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
426 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
427 while (!ctx->Done(&ptr)) {
428 ::uint32_t tag;
429 ptr = ::_pbi::ReadTag(ptr, &tag);
430 switch (tag >> 3) {
431 // .tensorflow.GraphDef graph_def = 1;
432 case 1:
433 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
434 ptr = ctx->ParseMessage(_internal_mutable_graph_def(), ptr);
435 CHK_(ptr);
436 } else {
437 goto handle_unusual;
438 }
439 continue;
440 // .tensorflow.ConfigProto config = 2;
441 case 2:
442 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
443 ptr = ctx->ParseMessage(_internal_mutable_config(), ptr);
444 CHK_(ptr);
445 } else {
446 goto handle_unusual;
447 }
448 continue;
449 // string target = 3;
450 case 3:
451 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
452 auto str = _internal_mutable_target();
453 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
454 CHK_(ptr);
455 CHK_(::_pbi::VerifyUTF8(str, nullptr));
456 } else {
457 goto handle_unusual;
458 }
459 continue;
460 default:
461 goto handle_unusual;
462 } // switch
463 handle_unusual:
464 if ((tag == 0) || ((tag & 7) == 4)) {
465 CHK_(ptr);
466 ctx->SetLastTag(tag);
467 goto message_done;
468 }
469 ptr = UnknownFieldParse(
470 tag,
471 _internal_metadata_.mutable_unknown_fields<std::string>(),
472 ptr, ctx);
473 CHK_(ptr != nullptr);
474 } // while
475 message_done:
476 return ptr;
477 failure:
478 ptr = nullptr;
479 goto message_done;
480 #undef CHK_
481 }
482
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const483 ::uint8_t* CreateSessionRequest::_InternalSerialize(
484 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
485 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.CreateSessionRequest)
486 ::uint32_t cached_has_bits = 0;
487 (void) cached_has_bits;
488
489 // .tensorflow.GraphDef graph_def = 1;
490 if (this->_internal_has_graph_def()) {
491 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
492 InternalWriteMessage(1, _Internal::graph_def(this),
493 _Internal::graph_def(this).GetCachedSize(), target, stream);
494 }
495
496 // .tensorflow.ConfigProto config = 2;
497 if (this->_internal_has_config()) {
498 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
499 InternalWriteMessage(2, _Internal::config(this),
500 _Internal::config(this).GetCachedSize(), target, stream);
501 }
502
503 // string target = 3;
504 if (!this->_internal_target().empty()) {
505 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
506 this->_internal_target().data(), static_cast<int>(this->_internal_target().length()),
507 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
508 "tensorflow.CreateSessionRequest.target");
509 target = stream->WriteStringMaybeAliased(
510 3, this->_internal_target(), target);
511 }
512
513 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
514 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
515 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
516 }
517 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.CreateSessionRequest)
518 return target;
519 }
520
ByteSizeLong() const521 size_t CreateSessionRequest::ByteSizeLong() const {
522 // @@protoc_insertion_point(message_byte_size_start:tensorflow.CreateSessionRequest)
523 size_t total_size = 0;
524
525 ::uint32_t cached_has_bits = 0;
526 // Prevent compiler warnings about cached_has_bits being unused
527 (void) cached_has_bits;
528
529 // string target = 3;
530 if (!this->_internal_target().empty()) {
531 total_size += 1 +
532 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
533 this->_internal_target());
534 }
535
536 // .tensorflow.GraphDef graph_def = 1;
537 if (this->_internal_has_graph_def()) {
538 total_size += 1 +
539 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
540 *_impl_.graph_def_);
541 }
542
543 // .tensorflow.ConfigProto config = 2;
544 if (this->_internal_has_config()) {
545 total_size += 1 +
546 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
547 *_impl_.config_);
548 }
549
550 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
551 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
552 }
553 int cached_size = ::_pbi::ToCachedSize(total_size);
554 SetCachedSize(cached_size);
555 return total_size;
556 }
557
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)558 void CreateSessionRequest::CheckTypeAndMergeFrom(
559 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
560 MergeFrom(*::_pbi::DownCast<const CreateSessionRequest*>(
561 &from));
562 }
563
MergeFrom(const CreateSessionRequest & from)564 void CreateSessionRequest::MergeFrom(const CreateSessionRequest& from) {
565 CreateSessionRequest* const _this = this;
566 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.CreateSessionRequest)
567 GOOGLE_DCHECK_NE(&from, _this);
568 ::uint32_t cached_has_bits = 0;
569 (void) cached_has_bits;
570
571 if (!from._internal_target().empty()) {
572 _this->_internal_set_target(from._internal_target());
573 }
574 if (from._internal_has_graph_def()) {
575 _this->_internal_mutable_graph_def()->::tensorflow::GraphDef::MergeFrom(
576 from._internal_graph_def());
577 }
578 if (from._internal_has_config()) {
579 _this->_internal_mutable_config()->::tensorflow::ConfigProto::MergeFrom(
580 from._internal_config());
581 }
582 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
583 }
584
CopyFrom(const CreateSessionRequest & from)585 void CreateSessionRequest::CopyFrom(const CreateSessionRequest& from) {
586 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.CreateSessionRequest)
587 if (&from == this) return;
588 Clear();
589 MergeFrom(from);
590 }
591
IsInitialized() const592 bool CreateSessionRequest::IsInitialized() const {
593 return true;
594 }
595
InternalSwap(CreateSessionRequest * other)596 void CreateSessionRequest::InternalSwap(CreateSessionRequest* other) {
597 using std::swap;
598 auto* lhs_arena = GetArenaForAllocation();
599 auto* rhs_arena = other->GetArenaForAllocation();
600 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
601 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
602 &_impl_.target_, lhs_arena,
603 &other->_impl_.target_, rhs_arena
604 );
605 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
606 PROTOBUF_FIELD_OFFSET(CreateSessionRequest, _impl_.config_)
607 + sizeof(CreateSessionRequest::_impl_.config_) // NOLINT
608 - PROTOBUF_FIELD_OFFSET(CreateSessionRequest, _impl_.graph_def_)>(
609 reinterpret_cast<char*>(&_impl_.graph_def_),
610 reinterpret_cast<char*>(&other->_impl_.graph_def_));
611 }
612
GetTypeName() const613 std::string CreateSessionRequest::GetTypeName() const {
614 return "tensorflow.CreateSessionRequest";
615 }
616
617
618 // ===================================================================
619
620 class CreateSessionResponse::_Internal {
621 public:
622 };
623
CreateSessionResponse(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)624 CreateSessionResponse::CreateSessionResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
625 bool is_message_owned)
626 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
627 SharedCtor(arena, is_message_owned);
628 // @@protoc_insertion_point(arena_constructor:tensorflow.CreateSessionResponse)
629 }
CreateSessionResponse(const CreateSessionResponse & from)630 CreateSessionResponse::CreateSessionResponse(const CreateSessionResponse& from)
631 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
632 CreateSessionResponse* const _this = this; (void)_this;
633 new (&_impl_) Impl_{
634 decltype(_impl_.session_handle_){}
635 , decltype(_impl_.graph_version_){}
636 , /*decltype(_impl_._cached_size_)*/{}};
637
638 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
639 _impl_.session_handle_.InitDefault();
640 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
641 _impl_.session_handle_.Set("", GetArenaForAllocation());
642 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
643 if (!from._internal_session_handle().empty()) {
644 _this->_impl_.session_handle_.Set(from._internal_session_handle(),
645 _this->GetArenaForAllocation());
646 }
647 _this->_impl_.graph_version_ = from._impl_.graph_version_;
648 // @@protoc_insertion_point(copy_constructor:tensorflow.CreateSessionResponse)
649 }
650
SharedCtor(::_pb::Arena * arena,bool is_message_owned)651 inline void CreateSessionResponse::SharedCtor(
652 ::_pb::Arena* arena, bool is_message_owned) {
653 (void)arena;
654 (void)is_message_owned;
655 new (&_impl_) Impl_{
656 decltype(_impl_.session_handle_){}
657 , decltype(_impl_.graph_version_){::int64_t{0}}
658 , /*decltype(_impl_._cached_size_)*/{}
659 };
660 _impl_.session_handle_.InitDefault();
661 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
662 _impl_.session_handle_.Set("", GetArenaForAllocation());
663 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
664 }
665
~CreateSessionResponse()666 CreateSessionResponse::~CreateSessionResponse() {
667 // @@protoc_insertion_point(destructor:tensorflow.CreateSessionResponse)
668 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
669 (void)arena;
670 return;
671 }
672 SharedDtor();
673 }
674
SharedDtor()675 inline void CreateSessionResponse::SharedDtor() {
676 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
677 _impl_.session_handle_.Destroy();
678 }
679
SetCachedSize(int size) const680 void CreateSessionResponse::SetCachedSize(int size) const {
681 _impl_._cached_size_.Set(size);
682 }
683
Clear()684 void CreateSessionResponse::Clear() {
685 // @@protoc_insertion_point(message_clear_start:tensorflow.CreateSessionResponse)
686 ::uint32_t cached_has_bits = 0;
687 // Prevent compiler warnings about cached_has_bits being unused
688 (void) cached_has_bits;
689
690 _impl_.session_handle_.ClearToEmpty();
691 _impl_.graph_version_ = ::int64_t{0};
692 _internal_metadata_.Clear<std::string>();
693 }
694
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)695 const char* CreateSessionResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
696 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
697 while (!ctx->Done(&ptr)) {
698 ::uint32_t tag;
699 ptr = ::_pbi::ReadTag(ptr, &tag);
700 switch (tag >> 3) {
701 // string session_handle = 1;
702 case 1:
703 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
704 auto str = _internal_mutable_session_handle();
705 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
706 CHK_(ptr);
707 CHK_(::_pbi::VerifyUTF8(str, nullptr));
708 } else {
709 goto handle_unusual;
710 }
711 continue;
712 // int64 graph_version = 2;
713 case 2:
714 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
715 _impl_.graph_version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
716 CHK_(ptr);
717 } else {
718 goto handle_unusual;
719 }
720 continue;
721 default:
722 goto handle_unusual;
723 } // switch
724 handle_unusual:
725 if ((tag == 0) || ((tag & 7) == 4)) {
726 CHK_(ptr);
727 ctx->SetLastTag(tag);
728 goto message_done;
729 }
730 ptr = UnknownFieldParse(
731 tag,
732 _internal_metadata_.mutable_unknown_fields<std::string>(),
733 ptr, ctx);
734 CHK_(ptr != nullptr);
735 } // while
736 message_done:
737 return ptr;
738 failure:
739 ptr = nullptr;
740 goto message_done;
741 #undef CHK_
742 }
743
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const744 ::uint8_t* CreateSessionResponse::_InternalSerialize(
745 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
746 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.CreateSessionResponse)
747 ::uint32_t cached_has_bits = 0;
748 (void) cached_has_bits;
749
750 // string session_handle = 1;
751 if (!this->_internal_session_handle().empty()) {
752 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
753 this->_internal_session_handle().data(), static_cast<int>(this->_internal_session_handle().length()),
754 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
755 "tensorflow.CreateSessionResponse.session_handle");
756 target = stream->WriteStringMaybeAliased(
757 1, this->_internal_session_handle(), target);
758 }
759
760 // int64 graph_version = 2;
761 if (this->_internal_graph_version() != 0) {
762 target = stream->EnsureSpace(target);
763 target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_graph_version(), target);
764 }
765
766 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
767 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
768 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
769 }
770 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.CreateSessionResponse)
771 return target;
772 }
773
ByteSizeLong() const774 size_t CreateSessionResponse::ByteSizeLong() const {
775 // @@protoc_insertion_point(message_byte_size_start:tensorflow.CreateSessionResponse)
776 size_t total_size = 0;
777
778 ::uint32_t cached_has_bits = 0;
779 // Prevent compiler warnings about cached_has_bits being unused
780 (void) cached_has_bits;
781
782 // string session_handle = 1;
783 if (!this->_internal_session_handle().empty()) {
784 total_size += 1 +
785 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
786 this->_internal_session_handle());
787 }
788
789 // int64 graph_version = 2;
790 if (this->_internal_graph_version() != 0) {
791 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_graph_version());
792 }
793
794 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
795 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
796 }
797 int cached_size = ::_pbi::ToCachedSize(total_size);
798 SetCachedSize(cached_size);
799 return total_size;
800 }
801
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)802 void CreateSessionResponse::CheckTypeAndMergeFrom(
803 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
804 MergeFrom(*::_pbi::DownCast<const CreateSessionResponse*>(
805 &from));
806 }
807
MergeFrom(const CreateSessionResponse & from)808 void CreateSessionResponse::MergeFrom(const CreateSessionResponse& from) {
809 CreateSessionResponse* const _this = this;
810 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.CreateSessionResponse)
811 GOOGLE_DCHECK_NE(&from, _this);
812 ::uint32_t cached_has_bits = 0;
813 (void) cached_has_bits;
814
815 if (!from._internal_session_handle().empty()) {
816 _this->_internal_set_session_handle(from._internal_session_handle());
817 }
818 if (from._internal_graph_version() != 0) {
819 _this->_internal_set_graph_version(from._internal_graph_version());
820 }
821 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
822 }
823
CopyFrom(const CreateSessionResponse & from)824 void CreateSessionResponse::CopyFrom(const CreateSessionResponse& from) {
825 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.CreateSessionResponse)
826 if (&from == this) return;
827 Clear();
828 MergeFrom(from);
829 }
830
IsInitialized() const831 bool CreateSessionResponse::IsInitialized() const {
832 return true;
833 }
834
InternalSwap(CreateSessionResponse * other)835 void CreateSessionResponse::InternalSwap(CreateSessionResponse* other) {
836 using std::swap;
837 auto* lhs_arena = GetArenaForAllocation();
838 auto* rhs_arena = other->GetArenaForAllocation();
839 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
840 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
841 &_impl_.session_handle_, lhs_arena,
842 &other->_impl_.session_handle_, rhs_arena
843 );
844 swap(_impl_.graph_version_, other->_impl_.graph_version_);
845 }
846
GetTypeName() const847 std::string CreateSessionResponse::GetTypeName() const {
848 return "tensorflow.CreateSessionResponse";
849 }
850
851
852 // ===================================================================
853
854 class ExtendSessionRequest::_Internal {
855 public:
856 static const ::tensorflow::GraphDef& graph_def(const ExtendSessionRequest* msg);
857 };
858
859 const ::tensorflow::GraphDef&
graph_def(const ExtendSessionRequest * msg)860 ExtendSessionRequest::_Internal::graph_def(const ExtendSessionRequest* msg) {
861 return *msg->_impl_.graph_def_;
862 }
clear_graph_def()863 void ExtendSessionRequest::clear_graph_def() {
864 if (GetArenaForAllocation() == nullptr && _impl_.graph_def_ != nullptr) {
865 delete _impl_.graph_def_;
866 }
867 _impl_.graph_def_ = nullptr;
868 }
ExtendSessionRequest(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)869 ExtendSessionRequest::ExtendSessionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
870 bool is_message_owned)
871 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
872 SharedCtor(arena, is_message_owned);
873 // @@protoc_insertion_point(arena_constructor:tensorflow.ExtendSessionRequest)
874 }
ExtendSessionRequest(const ExtendSessionRequest & from)875 ExtendSessionRequest::ExtendSessionRequest(const ExtendSessionRequest& from)
876 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
877 ExtendSessionRequest* const _this = this; (void)_this;
878 new (&_impl_) Impl_{
879 decltype(_impl_.session_handle_){}
880 , decltype(_impl_.graph_def_){nullptr}
881 , decltype(_impl_.current_graph_version_){}
882 , /*decltype(_impl_._cached_size_)*/{}};
883
884 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
885 _impl_.session_handle_.InitDefault();
886 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
887 _impl_.session_handle_.Set("", GetArenaForAllocation());
888 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
889 if (!from._internal_session_handle().empty()) {
890 _this->_impl_.session_handle_.Set(from._internal_session_handle(),
891 _this->GetArenaForAllocation());
892 }
893 if (from._internal_has_graph_def()) {
894 _this->_impl_.graph_def_ = new ::tensorflow::GraphDef(*from._impl_.graph_def_);
895 }
896 _this->_impl_.current_graph_version_ = from._impl_.current_graph_version_;
897 // @@protoc_insertion_point(copy_constructor:tensorflow.ExtendSessionRequest)
898 }
899
SharedCtor(::_pb::Arena * arena,bool is_message_owned)900 inline void ExtendSessionRequest::SharedCtor(
901 ::_pb::Arena* arena, bool is_message_owned) {
902 (void)arena;
903 (void)is_message_owned;
904 new (&_impl_) Impl_{
905 decltype(_impl_.session_handle_){}
906 , decltype(_impl_.graph_def_){nullptr}
907 , decltype(_impl_.current_graph_version_){::int64_t{0}}
908 , /*decltype(_impl_._cached_size_)*/{}
909 };
910 _impl_.session_handle_.InitDefault();
911 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
912 _impl_.session_handle_.Set("", GetArenaForAllocation());
913 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
914 }
915
~ExtendSessionRequest()916 ExtendSessionRequest::~ExtendSessionRequest() {
917 // @@protoc_insertion_point(destructor:tensorflow.ExtendSessionRequest)
918 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
919 (void)arena;
920 return;
921 }
922 SharedDtor();
923 }
924
SharedDtor()925 inline void ExtendSessionRequest::SharedDtor() {
926 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
927 _impl_.session_handle_.Destroy();
928 if (this != internal_default_instance()) delete _impl_.graph_def_;
929 }
930
SetCachedSize(int size) const931 void ExtendSessionRequest::SetCachedSize(int size) const {
932 _impl_._cached_size_.Set(size);
933 }
934
Clear()935 void ExtendSessionRequest::Clear() {
936 // @@protoc_insertion_point(message_clear_start:tensorflow.ExtendSessionRequest)
937 ::uint32_t cached_has_bits = 0;
938 // Prevent compiler warnings about cached_has_bits being unused
939 (void) cached_has_bits;
940
941 _impl_.session_handle_.ClearToEmpty();
942 if (GetArenaForAllocation() == nullptr && _impl_.graph_def_ != nullptr) {
943 delete _impl_.graph_def_;
944 }
945 _impl_.graph_def_ = nullptr;
946 _impl_.current_graph_version_ = ::int64_t{0};
947 _internal_metadata_.Clear<std::string>();
948 }
949
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)950 const char* ExtendSessionRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
951 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
952 while (!ctx->Done(&ptr)) {
953 ::uint32_t tag;
954 ptr = ::_pbi::ReadTag(ptr, &tag);
955 switch (tag >> 3) {
956 // string session_handle = 1;
957 case 1:
958 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
959 auto str = _internal_mutable_session_handle();
960 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
961 CHK_(ptr);
962 CHK_(::_pbi::VerifyUTF8(str, nullptr));
963 } else {
964 goto handle_unusual;
965 }
966 continue;
967 // .tensorflow.GraphDef graph_def = 2;
968 case 2:
969 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
970 ptr = ctx->ParseMessage(_internal_mutable_graph_def(), ptr);
971 CHK_(ptr);
972 } else {
973 goto handle_unusual;
974 }
975 continue;
976 // int64 current_graph_version = 3;
977 case 3:
978 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
979 _impl_.current_graph_version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
980 CHK_(ptr);
981 } else {
982 goto handle_unusual;
983 }
984 continue;
985 default:
986 goto handle_unusual;
987 } // switch
988 handle_unusual:
989 if ((tag == 0) || ((tag & 7) == 4)) {
990 CHK_(ptr);
991 ctx->SetLastTag(tag);
992 goto message_done;
993 }
994 ptr = UnknownFieldParse(
995 tag,
996 _internal_metadata_.mutable_unknown_fields<std::string>(),
997 ptr, ctx);
998 CHK_(ptr != nullptr);
999 } // while
1000 message_done:
1001 return ptr;
1002 failure:
1003 ptr = nullptr;
1004 goto message_done;
1005 #undef CHK_
1006 }
1007
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1008 ::uint8_t* ExtendSessionRequest::_InternalSerialize(
1009 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1010 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.ExtendSessionRequest)
1011 ::uint32_t cached_has_bits = 0;
1012 (void) cached_has_bits;
1013
1014 // string session_handle = 1;
1015 if (!this->_internal_session_handle().empty()) {
1016 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1017 this->_internal_session_handle().data(), static_cast<int>(this->_internal_session_handle().length()),
1018 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1019 "tensorflow.ExtendSessionRequest.session_handle");
1020 target = stream->WriteStringMaybeAliased(
1021 1, this->_internal_session_handle(), target);
1022 }
1023
1024 // .tensorflow.GraphDef graph_def = 2;
1025 if (this->_internal_has_graph_def()) {
1026 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1027 InternalWriteMessage(2, _Internal::graph_def(this),
1028 _Internal::graph_def(this).GetCachedSize(), target, stream);
1029 }
1030
1031 // int64 current_graph_version = 3;
1032 if (this->_internal_current_graph_version() != 0) {
1033 target = stream->EnsureSpace(target);
1034 target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_current_graph_version(), target);
1035 }
1036
1037 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1038 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1039 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1040 }
1041 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.ExtendSessionRequest)
1042 return target;
1043 }
1044
ByteSizeLong() const1045 size_t ExtendSessionRequest::ByteSizeLong() const {
1046 // @@protoc_insertion_point(message_byte_size_start:tensorflow.ExtendSessionRequest)
1047 size_t total_size = 0;
1048
1049 ::uint32_t cached_has_bits = 0;
1050 // Prevent compiler warnings about cached_has_bits being unused
1051 (void) cached_has_bits;
1052
1053 // string session_handle = 1;
1054 if (!this->_internal_session_handle().empty()) {
1055 total_size += 1 +
1056 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1057 this->_internal_session_handle());
1058 }
1059
1060 // .tensorflow.GraphDef graph_def = 2;
1061 if (this->_internal_has_graph_def()) {
1062 total_size += 1 +
1063 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1064 *_impl_.graph_def_);
1065 }
1066
1067 // int64 current_graph_version = 3;
1068 if (this->_internal_current_graph_version() != 0) {
1069 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_current_graph_version());
1070 }
1071
1072 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1073 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1074 }
1075 int cached_size = ::_pbi::ToCachedSize(total_size);
1076 SetCachedSize(cached_size);
1077 return total_size;
1078 }
1079
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1080 void ExtendSessionRequest::CheckTypeAndMergeFrom(
1081 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1082 MergeFrom(*::_pbi::DownCast<const ExtendSessionRequest*>(
1083 &from));
1084 }
1085
MergeFrom(const ExtendSessionRequest & from)1086 void ExtendSessionRequest::MergeFrom(const ExtendSessionRequest& from) {
1087 ExtendSessionRequest* const _this = this;
1088 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.ExtendSessionRequest)
1089 GOOGLE_DCHECK_NE(&from, _this);
1090 ::uint32_t cached_has_bits = 0;
1091 (void) cached_has_bits;
1092
1093 if (!from._internal_session_handle().empty()) {
1094 _this->_internal_set_session_handle(from._internal_session_handle());
1095 }
1096 if (from._internal_has_graph_def()) {
1097 _this->_internal_mutable_graph_def()->::tensorflow::GraphDef::MergeFrom(
1098 from._internal_graph_def());
1099 }
1100 if (from._internal_current_graph_version() != 0) {
1101 _this->_internal_set_current_graph_version(from._internal_current_graph_version());
1102 }
1103 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1104 }
1105
CopyFrom(const ExtendSessionRequest & from)1106 void ExtendSessionRequest::CopyFrom(const ExtendSessionRequest& from) {
1107 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.ExtendSessionRequest)
1108 if (&from == this) return;
1109 Clear();
1110 MergeFrom(from);
1111 }
1112
IsInitialized() const1113 bool ExtendSessionRequest::IsInitialized() const {
1114 return true;
1115 }
1116
InternalSwap(ExtendSessionRequest * other)1117 void ExtendSessionRequest::InternalSwap(ExtendSessionRequest* other) {
1118 using std::swap;
1119 auto* lhs_arena = GetArenaForAllocation();
1120 auto* rhs_arena = other->GetArenaForAllocation();
1121 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1122 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1123 &_impl_.session_handle_, lhs_arena,
1124 &other->_impl_.session_handle_, rhs_arena
1125 );
1126 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1127 PROTOBUF_FIELD_OFFSET(ExtendSessionRequest, _impl_.current_graph_version_)
1128 + sizeof(ExtendSessionRequest::_impl_.current_graph_version_) // NOLINT
1129 - PROTOBUF_FIELD_OFFSET(ExtendSessionRequest, _impl_.graph_def_)>(
1130 reinterpret_cast<char*>(&_impl_.graph_def_),
1131 reinterpret_cast<char*>(&other->_impl_.graph_def_));
1132 }
1133
GetTypeName() const1134 std::string ExtendSessionRequest::GetTypeName() const {
1135 return "tensorflow.ExtendSessionRequest";
1136 }
1137
1138
1139 // ===================================================================
1140
1141 class ExtendSessionResponse::_Internal {
1142 public:
1143 };
1144
ExtendSessionResponse(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1145 ExtendSessionResponse::ExtendSessionResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1146 bool is_message_owned)
1147 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1148 SharedCtor(arena, is_message_owned);
1149 // @@protoc_insertion_point(arena_constructor:tensorflow.ExtendSessionResponse)
1150 }
ExtendSessionResponse(const ExtendSessionResponse & from)1151 ExtendSessionResponse::ExtendSessionResponse(const ExtendSessionResponse& from)
1152 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1153 ExtendSessionResponse* const _this = this; (void)_this;
1154 new (&_impl_) Impl_{
1155 decltype(_impl_.new_graph_version_){}
1156 , /*decltype(_impl_._cached_size_)*/{}};
1157
1158 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1159 _this->_impl_.new_graph_version_ = from._impl_.new_graph_version_;
1160 // @@protoc_insertion_point(copy_constructor:tensorflow.ExtendSessionResponse)
1161 }
1162
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1163 inline void ExtendSessionResponse::SharedCtor(
1164 ::_pb::Arena* arena, bool is_message_owned) {
1165 (void)arena;
1166 (void)is_message_owned;
1167 new (&_impl_) Impl_{
1168 decltype(_impl_.new_graph_version_){::int64_t{0}}
1169 , /*decltype(_impl_._cached_size_)*/{}
1170 };
1171 }
1172
~ExtendSessionResponse()1173 ExtendSessionResponse::~ExtendSessionResponse() {
1174 // @@protoc_insertion_point(destructor:tensorflow.ExtendSessionResponse)
1175 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1176 (void)arena;
1177 return;
1178 }
1179 SharedDtor();
1180 }
1181
SharedDtor()1182 inline void ExtendSessionResponse::SharedDtor() {
1183 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1184 }
1185
SetCachedSize(int size) const1186 void ExtendSessionResponse::SetCachedSize(int size) const {
1187 _impl_._cached_size_.Set(size);
1188 }
1189
Clear()1190 void ExtendSessionResponse::Clear() {
1191 // @@protoc_insertion_point(message_clear_start:tensorflow.ExtendSessionResponse)
1192 ::uint32_t cached_has_bits = 0;
1193 // Prevent compiler warnings about cached_has_bits being unused
1194 (void) cached_has_bits;
1195
1196 _impl_.new_graph_version_ = ::int64_t{0};
1197 _internal_metadata_.Clear<std::string>();
1198 }
1199
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1200 const char* ExtendSessionResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1201 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1202 while (!ctx->Done(&ptr)) {
1203 ::uint32_t tag;
1204 ptr = ::_pbi::ReadTag(ptr, &tag);
1205 switch (tag >> 3) {
1206 // int64 new_graph_version = 4;
1207 case 4:
1208 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1209 _impl_.new_graph_version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1210 CHK_(ptr);
1211 } else {
1212 goto handle_unusual;
1213 }
1214 continue;
1215 default:
1216 goto handle_unusual;
1217 } // switch
1218 handle_unusual:
1219 if ((tag == 0) || ((tag & 7) == 4)) {
1220 CHK_(ptr);
1221 ctx->SetLastTag(tag);
1222 goto message_done;
1223 }
1224 ptr = UnknownFieldParse(
1225 tag,
1226 _internal_metadata_.mutable_unknown_fields<std::string>(),
1227 ptr, ctx);
1228 CHK_(ptr != nullptr);
1229 } // while
1230 message_done:
1231 return ptr;
1232 failure:
1233 ptr = nullptr;
1234 goto message_done;
1235 #undef CHK_
1236 }
1237
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1238 ::uint8_t* ExtendSessionResponse::_InternalSerialize(
1239 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1240 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.ExtendSessionResponse)
1241 ::uint32_t cached_has_bits = 0;
1242 (void) cached_has_bits;
1243
1244 // int64 new_graph_version = 4;
1245 if (this->_internal_new_graph_version() != 0) {
1246 target = stream->EnsureSpace(target);
1247 target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_new_graph_version(), target);
1248 }
1249
1250 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1251 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1252 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1253 }
1254 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.ExtendSessionResponse)
1255 return target;
1256 }
1257
ByteSizeLong() const1258 size_t ExtendSessionResponse::ByteSizeLong() const {
1259 // @@protoc_insertion_point(message_byte_size_start:tensorflow.ExtendSessionResponse)
1260 size_t total_size = 0;
1261
1262 ::uint32_t cached_has_bits = 0;
1263 // Prevent compiler warnings about cached_has_bits being unused
1264 (void) cached_has_bits;
1265
1266 // int64 new_graph_version = 4;
1267 if (this->_internal_new_graph_version() != 0) {
1268 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_new_graph_version());
1269 }
1270
1271 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1272 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1273 }
1274 int cached_size = ::_pbi::ToCachedSize(total_size);
1275 SetCachedSize(cached_size);
1276 return total_size;
1277 }
1278
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1279 void ExtendSessionResponse::CheckTypeAndMergeFrom(
1280 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1281 MergeFrom(*::_pbi::DownCast<const ExtendSessionResponse*>(
1282 &from));
1283 }
1284
MergeFrom(const ExtendSessionResponse & from)1285 void ExtendSessionResponse::MergeFrom(const ExtendSessionResponse& from) {
1286 ExtendSessionResponse* const _this = this;
1287 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.ExtendSessionResponse)
1288 GOOGLE_DCHECK_NE(&from, _this);
1289 ::uint32_t cached_has_bits = 0;
1290 (void) cached_has_bits;
1291
1292 if (from._internal_new_graph_version() != 0) {
1293 _this->_internal_set_new_graph_version(from._internal_new_graph_version());
1294 }
1295 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1296 }
1297
CopyFrom(const ExtendSessionResponse & from)1298 void ExtendSessionResponse::CopyFrom(const ExtendSessionResponse& from) {
1299 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.ExtendSessionResponse)
1300 if (&from == this) return;
1301 Clear();
1302 MergeFrom(from);
1303 }
1304
IsInitialized() const1305 bool ExtendSessionResponse::IsInitialized() const {
1306 return true;
1307 }
1308
InternalSwap(ExtendSessionResponse * other)1309 void ExtendSessionResponse::InternalSwap(ExtendSessionResponse* other) {
1310 using std::swap;
1311 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1312 swap(_impl_.new_graph_version_, other->_impl_.new_graph_version_);
1313 }
1314
GetTypeName() const1315 std::string ExtendSessionResponse::GetTypeName() const {
1316 return "tensorflow.ExtendSessionResponse";
1317 }
1318
1319
1320 // ===================================================================
1321
1322 class RunStepRequest::_Internal {
1323 public:
1324 static const ::tensorflow::RunOptions& options(const RunStepRequest* msg);
1325 };
1326
1327 const ::tensorflow::RunOptions&
options(const RunStepRequest * msg)1328 RunStepRequest::_Internal::options(const RunStepRequest* msg) {
1329 return *msg->_impl_.options_;
1330 }
clear_feed()1331 void RunStepRequest::clear_feed() {
1332 _impl_.feed_.Clear();
1333 }
clear_options()1334 void RunStepRequest::clear_options() {
1335 if (GetArenaForAllocation() == nullptr && _impl_.options_ != nullptr) {
1336 delete _impl_.options_;
1337 }
1338 _impl_.options_ = nullptr;
1339 }
RunStepRequest(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1340 RunStepRequest::RunStepRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1341 bool is_message_owned)
1342 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1343 SharedCtor(arena, is_message_owned);
1344 // @@protoc_insertion_point(arena_constructor:tensorflow.RunStepRequest)
1345 }
RunStepRequest(const RunStepRequest & from)1346 RunStepRequest::RunStepRequest(const RunStepRequest& from)
1347 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1348 RunStepRequest* const _this = this; (void)_this;
1349 new (&_impl_) Impl_{
1350 decltype(_impl_.feed_){from._impl_.feed_}
1351 , decltype(_impl_.fetch_){from._impl_.fetch_}
1352 , decltype(_impl_.target_){from._impl_.target_}
1353 , decltype(_impl_.session_handle_){}
1354 , decltype(_impl_.partial_run_handle_){}
1355 , decltype(_impl_.options_){nullptr}
1356 , decltype(_impl_.request_id_){}
1357 , decltype(_impl_.store_errors_in_response_body_){}
1358 , /*decltype(_impl_._cached_size_)*/{}};
1359
1360 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1361 _impl_.session_handle_.InitDefault();
1362 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1363 _impl_.session_handle_.Set("", GetArenaForAllocation());
1364 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1365 if (!from._internal_session_handle().empty()) {
1366 _this->_impl_.session_handle_.Set(from._internal_session_handle(),
1367 _this->GetArenaForAllocation());
1368 }
1369 _impl_.partial_run_handle_.InitDefault();
1370 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1371 _impl_.partial_run_handle_.Set("", GetArenaForAllocation());
1372 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1373 if (!from._internal_partial_run_handle().empty()) {
1374 _this->_impl_.partial_run_handle_.Set(from._internal_partial_run_handle(),
1375 _this->GetArenaForAllocation());
1376 }
1377 if (from._internal_has_options()) {
1378 _this->_impl_.options_ = new ::tensorflow::RunOptions(*from._impl_.options_);
1379 }
1380 ::memcpy(&_impl_.request_id_, &from._impl_.request_id_,
1381 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.store_errors_in_response_body_) -
1382 reinterpret_cast<char*>(&_impl_.request_id_)) + sizeof(_impl_.store_errors_in_response_body_));
1383 // @@protoc_insertion_point(copy_constructor:tensorflow.RunStepRequest)
1384 }
1385
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1386 inline void RunStepRequest::SharedCtor(
1387 ::_pb::Arena* arena, bool is_message_owned) {
1388 (void)arena;
1389 (void)is_message_owned;
1390 new (&_impl_) Impl_{
1391 decltype(_impl_.feed_){arena}
1392 , decltype(_impl_.fetch_){arena}
1393 , decltype(_impl_.target_){arena}
1394 , decltype(_impl_.session_handle_){}
1395 , decltype(_impl_.partial_run_handle_){}
1396 , decltype(_impl_.options_){nullptr}
1397 , decltype(_impl_.request_id_){::int64_t{0}}
1398 , decltype(_impl_.store_errors_in_response_body_){false}
1399 , /*decltype(_impl_._cached_size_)*/{}
1400 };
1401 _impl_.session_handle_.InitDefault();
1402 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1403 _impl_.session_handle_.Set("", GetArenaForAllocation());
1404 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1405 _impl_.partial_run_handle_.InitDefault();
1406 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1407 _impl_.partial_run_handle_.Set("", GetArenaForAllocation());
1408 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1409 }
1410
~RunStepRequest()1411 RunStepRequest::~RunStepRequest() {
1412 // @@protoc_insertion_point(destructor:tensorflow.RunStepRequest)
1413 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1414 (void)arena;
1415 return;
1416 }
1417 SharedDtor();
1418 }
1419
SharedDtor()1420 inline void RunStepRequest::SharedDtor() {
1421 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1422 _impl_.feed_.~RepeatedPtrField();
1423 _impl_.fetch_.~RepeatedPtrField();
1424 _impl_.target_.~RepeatedPtrField();
1425 _impl_.session_handle_.Destroy();
1426 _impl_.partial_run_handle_.Destroy();
1427 if (this != internal_default_instance()) delete _impl_.options_;
1428 }
1429
SetCachedSize(int size) const1430 void RunStepRequest::SetCachedSize(int size) const {
1431 _impl_._cached_size_.Set(size);
1432 }
1433
Clear()1434 void RunStepRequest::Clear() {
1435 // @@protoc_insertion_point(message_clear_start:tensorflow.RunStepRequest)
1436 ::uint32_t cached_has_bits = 0;
1437 // Prevent compiler warnings about cached_has_bits being unused
1438 (void) cached_has_bits;
1439
1440 _impl_.feed_.Clear();
1441 _impl_.fetch_.Clear();
1442 _impl_.target_.Clear();
1443 _impl_.session_handle_.ClearToEmpty();
1444 _impl_.partial_run_handle_.ClearToEmpty();
1445 if (GetArenaForAllocation() == nullptr && _impl_.options_ != nullptr) {
1446 delete _impl_.options_;
1447 }
1448 _impl_.options_ = nullptr;
1449 ::memset(&_impl_.request_id_, 0, static_cast<size_t>(
1450 reinterpret_cast<char*>(&_impl_.store_errors_in_response_body_) -
1451 reinterpret_cast<char*>(&_impl_.request_id_)) + sizeof(_impl_.store_errors_in_response_body_));
1452 _internal_metadata_.Clear<std::string>();
1453 }
1454
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1455 const char* RunStepRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1456 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1457 while (!ctx->Done(&ptr)) {
1458 ::uint32_t tag;
1459 ptr = ::_pbi::ReadTag(ptr, &tag);
1460 switch (tag >> 3) {
1461 // string session_handle = 1;
1462 case 1:
1463 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1464 auto str = _internal_mutable_session_handle();
1465 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1466 CHK_(ptr);
1467 CHK_(::_pbi::VerifyUTF8(str, nullptr));
1468 } else {
1469 goto handle_unusual;
1470 }
1471 continue;
1472 // repeated .tensorflow.NamedTensorProto feed = 2;
1473 case 2:
1474 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1475 ptr -= 1;
1476 do {
1477 ptr += 1;
1478 ptr = ctx->ParseMessage(_internal_add_feed(), ptr);
1479 CHK_(ptr);
1480 if (!ctx->DataAvailable(ptr)) break;
1481 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
1482 } else {
1483 goto handle_unusual;
1484 }
1485 continue;
1486 // repeated string fetch = 3;
1487 case 3:
1488 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
1489 ptr -= 1;
1490 do {
1491 ptr += 1;
1492 auto str = _internal_add_fetch();
1493 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1494 CHK_(ptr);
1495 CHK_(::_pbi::VerifyUTF8(str, nullptr));
1496 if (!ctx->DataAvailable(ptr)) break;
1497 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
1498 } else {
1499 goto handle_unusual;
1500 }
1501 continue;
1502 // repeated string target = 4;
1503 case 4:
1504 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
1505 ptr -= 1;
1506 do {
1507 ptr += 1;
1508 auto str = _internal_add_target();
1509 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1510 CHK_(ptr);
1511 CHK_(::_pbi::VerifyUTF8(str, nullptr));
1512 if (!ctx->DataAvailable(ptr)) break;
1513 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
1514 } else {
1515 goto handle_unusual;
1516 }
1517 continue;
1518 // .tensorflow.RunOptions options = 5;
1519 case 5:
1520 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
1521 ptr = ctx->ParseMessage(_internal_mutable_options(), ptr);
1522 CHK_(ptr);
1523 } else {
1524 goto handle_unusual;
1525 }
1526 continue;
1527 // string partial_run_handle = 6;
1528 case 6:
1529 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
1530 auto str = _internal_mutable_partial_run_handle();
1531 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1532 CHK_(ptr);
1533 CHK_(::_pbi::VerifyUTF8(str, nullptr));
1534 } else {
1535 goto handle_unusual;
1536 }
1537 continue;
1538 // bool store_errors_in_response_body = 7;
1539 case 7:
1540 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
1541 _impl_.store_errors_in_response_body_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1542 CHK_(ptr);
1543 } else {
1544 goto handle_unusual;
1545 }
1546 continue;
1547 // int64 request_id = 8;
1548 case 8:
1549 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 64)) {
1550 _impl_.request_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1551 CHK_(ptr);
1552 } else {
1553 goto handle_unusual;
1554 }
1555 continue;
1556 default:
1557 goto handle_unusual;
1558 } // switch
1559 handle_unusual:
1560 if ((tag == 0) || ((tag & 7) == 4)) {
1561 CHK_(ptr);
1562 ctx->SetLastTag(tag);
1563 goto message_done;
1564 }
1565 ptr = UnknownFieldParse(
1566 tag,
1567 _internal_metadata_.mutable_unknown_fields<std::string>(),
1568 ptr, ctx);
1569 CHK_(ptr != nullptr);
1570 } // while
1571 message_done:
1572 return ptr;
1573 failure:
1574 ptr = nullptr;
1575 goto message_done;
1576 #undef CHK_
1577 }
1578
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1579 ::uint8_t* RunStepRequest::_InternalSerialize(
1580 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1581 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.RunStepRequest)
1582 ::uint32_t cached_has_bits = 0;
1583 (void) cached_has_bits;
1584
1585 // string session_handle = 1;
1586 if (!this->_internal_session_handle().empty()) {
1587 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1588 this->_internal_session_handle().data(), static_cast<int>(this->_internal_session_handle().length()),
1589 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1590 "tensorflow.RunStepRequest.session_handle");
1591 target = stream->WriteStringMaybeAliased(
1592 1, this->_internal_session_handle(), target);
1593 }
1594
1595 // repeated .tensorflow.NamedTensorProto feed = 2;
1596 for (unsigned i = 0,
1597 n = static_cast<unsigned>(this->_internal_feed_size()); i < n; i++) {
1598 const auto& repfield = this->_internal_feed(i);
1599 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1600 InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
1601 }
1602
1603 // repeated string fetch = 3;
1604 for (int i = 0, n = this->_internal_fetch_size(); i < n; i++) {
1605 const auto& s = this->_internal_fetch(i);
1606 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1607 s.data(), static_cast<int>(s.length()),
1608 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1609 "tensorflow.RunStepRequest.fetch");
1610 target = stream->WriteString(3, s, target);
1611 }
1612
1613 // repeated string target = 4;
1614 for (int i = 0, n = this->_internal_target_size(); i < n; i++) {
1615 const auto& s = this->_internal_target(i);
1616 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1617 s.data(), static_cast<int>(s.length()),
1618 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1619 "tensorflow.RunStepRequest.target");
1620 target = stream->WriteString(4, s, target);
1621 }
1622
1623 // .tensorflow.RunOptions options = 5;
1624 if (this->_internal_has_options()) {
1625 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1626 InternalWriteMessage(5, _Internal::options(this),
1627 _Internal::options(this).GetCachedSize(), target, stream);
1628 }
1629
1630 // string partial_run_handle = 6;
1631 if (!this->_internal_partial_run_handle().empty()) {
1632 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1633 this->_internal_partial_run_handle().data(), static_cast<int>(this->_internal_partial_run_handle().length()),
1634 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1635 "tensorflow.RunStepRequest.partial_run_handle");
1636 target = stream->WriteStringMaybeAliased(
1637 6, this->_internal_partial_run_handle(), target);
1638 }
1639
1640 // bool store_errors_in_response_body = 7;
1641 if (this->_internal_store_errors_in_response_body() != 0) {
1642 target = stream->EnsureSpace(target);
1643 target = ::_pbi::WireFormatLite::WriteBoolToArray(7, this->_internal_store_errors_in_response_body(), target);
1644 }
1645
1646 // int64 request_id = 8;
1647 if (this->_internal_request_id() != 0) {
1648 target = stream->EnsureSpace(target);
1649 target = ::_pbi::WireFormatLite::WriteInt64ToArray(8, this->_internal_request_id(), target);
1650 }
1651
1652 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1653 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1654 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1655 }
1656 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.RunStepRequest)
1657 return target;
1658 }
1659
ByteSizeLong() const1660 size_t RunStepRequest::ByteSizeLong() const {
1661 // @@protoc_insertion_point(message_byte_size_start:tensorflow.RunStepRequest)
1662 size_t total_size = 0;
1663
1664 ::uint32_t cached_has_bits = 0;
1665 // Prevent compiler warnings about cached_has_bits being unused
1666 (void) cached_has_bits;
1667
1668 // repeated .tensorflow.NamedTensorProto feed = 2;
1669 total_size += 1UL * this->_internal_feed_size();
1670 for (const auto& msg : this->_impl_.feed_) {
1671 total_size +=
1672 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
1673 }
1674
1675 // repeated string fetch = 3;
1676 total_size += 1 *
1677 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.fetch_.size());
1678 for (int i = 0, n = _impl_.fetch_.size(); i < n; i++) {
1679 total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1680 _impl_.fetch_.Get(i));
1681 }
1682
1683 // repeated string target = 4;
1684 total_size += 1 *
1685 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.target_.size());
1686 for (int i = 0, n = _impl_.target_.size(); i < n; i++) {
1687 total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1688 _impl_.target_.Get(i));
1689 }
1690
1691 // string session_handle = 1;
1692 if (!this->_internal_session_handle().empty()) {
1693 total_size += 1 +
1694 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1695 this->_internal_session_handle());
1696 }
1697
1698 // string partial_run_handle = 6;
1699 if (!this->_internal_partial_run_handle().empty()) {
1700 total_size += 1 +
1701 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1702 this->_internal_partial_run_handle());
1703 }
1704
1705 // .tensorflow.RunOptions options = 5;
1706 if (this->_internal_has_options()) {
1707 total_size += 1 +
1708 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1709 *_impl_.options_);
1710 }
1711
1712 // int64 request_id = 8;
1713 if (this->_internal_request_id() != 0) {
1714 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_request_id());
1715 }
1716
1717 // bool store_errors_in_response_body = 7;
1718 if (this->_internal_store_errors_in_response_body() != 0) {
1719 total_size += 1 + 1;
1720 }
1721
1722 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1723 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1724 }
1725 int cached_size = ::_pbi::ToCachedSize(total_size);
1726 SetCachedSize(cached_size);
1727 return total_size;
1728 }
1729
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1730 void RunStepRequest::CheckTypeAndMergeFrom(
1731 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1732 MergeFrom(*::_pbi::DownCast<const RunStepRequest*>(
1733 &from));
1734 }
1735
MergeFrom(const RunStepRequest & from)1736 void RunStepRequest::MergeFrom(const RunStepRequest& from) {
1737 RunStepRequest* const _this = this;
1738 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.RunStepRequest)
1739 GOOGLE_DCHECK_NE(&from, _this);
1740 ::uint32_t cached_has_bits = 0;
1741 (void) cached_has_bits;
1742
1743 _this->_impl_.feed_.MergeFrom(from._impl_.feed_);
1744 _this->_impl_.fetch_.MergeFrom(from._impl_.fetch_);
1745 _this->_impl_.target_.MergeFrom(from._impl_.target_);
1746 if (!from._internal_session_handle().empty()) {
1747 _this->_internal_set_session_handle(from._internal_session_handle());
1748 }
1749 if (!from._internal_partial_run_handle().empty()) {
1750 _this->_internal_set_partial_run_handle(from._internal_partial_run_handle());
1751 }
1752 if (from._internal_has_options()) {
1753 _this->_internal_mutable_options()->::tensorflow::RunOptions::MergeFrom(
1754 from._internal_options());
1755 }
1756 if (from._internal_request_id() != 0) {
1757 _this->_internal_set_request_id(from._internal_request_id());
1758 }
1759 if (from._internal_store_errors_in_response_body() != 0) {
1760 _this->_internal_set_store_errors_in_response_body(from._internal_store_errors_in_response_body());
1761 }
1762 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1763 }
1764
CopyFrom(const RunStepRequest & from)1765 void RunStepRequest::CopyFrom(const RunStepRequest& from) {
1766 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.RunStepRequest)
1767 if (&from == this) return;
1768 Clear();
1769 MergeFrom(from);
1770 }
1771
IsInitialized() const1772 bool RunStepRequest::IsInitialized() const {
1773 return true;
1774 }
1775
InternalSwap(RunStepRequest * other)1776 void RunStepRequest::InternalSwap(RunStepRequest* other) {
1777 using std::swap;
1778 auto* lhs_arena = GetArenaForAllocation();
1779 auto* rhs_arena = other->GetArenaForAllocation();
1780 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1781 _impl_.feed_.InternalSwap(&other->_impl_.feed_);
1782 _impl_.fetch_.InternalSwap(&other->_impl_.fetch_);
1783 _impl_.target_.InternalSwap(&other->_impl_.target_);
1784 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1785 &_impl_.session_handle_, lhs_arena,
1786 &other->_impl_.session_handle_, rhs_arena
1787 );
1788 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1789 &_impl_.partial_run_handle_, lhs_arena,
1790 &other->_impl_.partial_run_handle_, rhs_arena
1791 );
1792 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1793 PROTOBUF_FIELD_OFFSET(RunStepRequest, _impl_.store_errors_in_response_body_)
1794 + sizeof(RunStepRequest::_impl_.store_errors_in_response_body_) // NOLINT
1795 - PROTOBUF_FIELD_OFFSET(RunStepRequest, _impl_.options_)>(
1796 reinterpret_cast<char*>(&_impl_.options_),
1797 reinterpret_cast<char*>(&other->_impl_.options_));
1798 }
1799
GetTypeName() const1800 std::string RunStepRequest::GetTypeName() const {
1801 return "tensorflow.RunStepRequest";
1802 }
1803
1804
1805 // ===================================================================
1806
1807 class RunStepResponse::_Internal {
1808 public:
1809 static const ::tensorflow::RunMetadata& metadata(const RunStepResponse* msg);
1810 };
1811
1812 const ::tensorflow::RunMetadata&
metadata(const RunStepResponse * msg)1813 RunStepResponse::_Internal::metadata(const RunStepResponse* msg) {
1814 return *msg->_impl_.metadata_;
1815 }
clear_tensor()1816 void RunStepResponse::clear_tensor() {
1817 _impl_.tensor_.Clear();
1818 }
clear_metadata()1819 void RunStepResponse::clear_metadata() {
1820 if (GetArenaForAllocation() == nullptr && _impl_.metadata_ != nullptr) {
1821 delete _impl_.metadata_;
1822 }
1823 _impl_.metadata_ = nullptr;
1824 }
RunStepResponse(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1825 RunStepResponse::RunStepResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1826 bool is_message_owned)
1827 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1828 SharedCtor(arena, is_message_owned);
1829 // @@protoc_insertion_point(arena_constructor:tensorflow.RunStepResponse)
1830 }
RunStepResponse(const RunStepResponse & from)1831 RunStepResponse::RunStepResponse(const RunStepResponse& from)
1832 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1833 RunStepResponse* const _this = this; (void)_this;
1834 new (&_impl_) Impl_{
1835 decltype(_impl_.tensor_){from._impl_.tensor_}
1836 , decltype(_impl_.status_error_message_){}
1837 , decltype(_impl_.metadata_){nullptr}
1838 , decltype(_impl_.status_code_){}
1839 , /*decltype(_impl_._cached_size_)*/{}};
1840
1841 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1842 _impl_.status_error_message_.InitDefault();
1843 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1844 _impl_.status_error_message_.Set("", GetArenaForAllocation());
1845 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1846 if (!from._internal_status_error_message().empty()) {
1847 _this->_impl_.status_error_message_.Set(from._internal_status_error_message(),
1848 _this->GetArenaForAllocation());
1849 }
1850 if (from._internal_has_metadata()) {
1851 _this->_impl_.metadata_ = new ::tensorflow::RunMetadata(*from._impl_.metadata_);
1852 }
1853 _this->_impl_.status_code_ = from._impl_.status_code_;
1854 // @@protoc_insertion_point(copy_constructor:tensorflow.RunStepResponse)
1855 }
1856
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1857 inline void RunStepResponse::SharedCtor(
1858 ::_pb::Arena* arena, bool is_message_owned) {
1859 (void)arena;
1860 (void)is_message_owned;
1861 new (&_impl_) Impl_{
1862 decltype(_impl_.tensor_){arena}
1863 , decltype(_impl_.status_error_message_){}
1864 , decltype(_impl_.metadata_){nullptr}
1865 , decltype(_impl_.status_code_){0}
1866 , /*decltype(_impl_._cached_size_)*/{}
1867 };
1868 _impl_.status_error_message_.InitDefault();
1869 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1870 _impl_.status_error_message_.Set("", GetArenaForAllocation());
1871 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1872 }
1873
~RunStepResponse()1874 RunStepResponse::~RunStepResponse() {
1875 // @@protoc_insertion_point(destructor:tensorflow.RunStepResponse)
1876 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1877 (void)arena;
1878 return;
1879 }
1880 SharedDtor();
1881 }
1882
SharedDtor()1883 inline void RunStepResponse::SharedDtor() {
1884 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1885 _impl_.tensor_.~RepeatedPtrField();
1886 _impl_.status_error_message_.Destroy();
1887 if (this != internal_default_instance()) delete _impl_.metadata_;
1888 }
1889
SetCachedSize(int size) const1890 void RunStepResponse::SetCachedSize(int size) const {
1891 _impl_._cached_size_.Set(size);
1892 }
1893
Clear()1894 void RunStepResponse::Clear() {
1895 // @@protoc_insertion_point(message_clear_start:tensorflow.RunStepResponse)
1896 ::uint32_t cached_has_bits = 0;
1897 // Prevent compiler warnings about cached_has_bits being unused
1898 (void) cached_has_bits;
1899
1900 _impl_.tensor_.Clear();
1901 _impl_.status_error_message_.ClearToEmpty();
1902 if (GetArenaForAllocation() == nullptr && _impl_.metadata_ != nullptr) {
1903 delete _impl_.metadata_;
1904 }
1905 _impl_.metadata_ = nullptr;
1906 _impl_.status_code_ = 0;
1907 _internal_metadata_.Clear<std::string>();
1908 }
1909
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1910 const char* RunStepResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1911 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1912 while (!ctx->Done(&ptr)) {
1913 ::uint32_t tag;
1914 ptr = ::_pbi::ReadTag(ptr, &tag);
1915 switch (tag >> 3) {
1916 // repeated .tensorflow.NamedTensorProto tensor = 1;
1917 case 1:
1918 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1919 ptr -= 1;
1920 do {
1921 ptr += 1;
1922 ptr = ctx->ParseMessage(_internal_add_tensor(), ptr);
1923 CHK_(ptr);
1924 if (!ctx->DataAvailable(ptr)) break;
1925 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
1926 } else {
1927 goto handle_unusual;
1928 }
1929 continue;
1930 // .tensorflow.RunMetadata metadata = 2;
1931 case 2:
1932 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1933 ptr = ctx->ParseMessage(_internal_mutable_metadata(), ptr);
1934 CHK_(ptr);
1935 } else {
1936 goto handle_unusual;
1937 }
1938 continue;
1939 // .tensorflow.error.Code status_code = 3;
1940 case 3:
1941 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1942 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1943 CHK_(ptr);
1944 _internal_set_status_code(static_cast<::tensorflow::error::Code>(val));
1945 } else {
1946 goto handle_unusual;
1947 }
1948 continue;
1949 // string status_error_message = 4;
1950 case 4:
1951 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
1952 auto str = _internal_mutable_status_error_message();
1953 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1954 CHK_(ptr);
1955 CHK_(::_pbi::VerifyUTF8(str, nullptr));
1956 } else {
1957 goto handle_unusual;
1958 }
1959 continue;
1960 default:
1961 goto handle_unusual;
1962 } // switch
1963 handle_unusual:
1964 if ((tag == 0) || ((tag & 7) == 4)) {
1965 CHK_(ptr);
1966 ctx->SetLastTag(tag);
1967 goto message_done;
1968 }
1969 ptr = UnknownFieldParse(
1970 tag,
1971 _internal_metadata_.mutable_unknown_fields<std::string>(),
1972 ptr, ctx);
1973 CHK_(ptr != nullptr);
1974 } // while
1975 message_done:
1976 return ptr;
1977 failure:
1978 ptr = nullptr;
1979 goto message_done;
1980 #undef CHK_
1981 }
1982
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1983 ::uint8_t* RunStepResponse::_InternalSerialize(
1984 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1985 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.RunStepResponse)
1986 ::uint32_t cached_has_bits = 0;
1987 (void) cached_has_bits;
1988
1989 // repeated .tensorflow.NamedTensorProto tensor = 1;
1990 for (unsigned i = 0,
1991 n = static_cast<unsigned>(this->_internal_tensor_size()); i < n; i++) {
1992 const auto& repfield = this->_internal_tensor(i);
1993 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1994 InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
1995 }
1996
1997 // .tensorflow.RunMetadata metadata = 2;
1998 if (this->_internal_has_metadata()) {
1999 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
2000 InternalWriteMessage(2, _Internal::metadata(this),
2001 _Internal::metadata(this).GetCachedSize(), target, stream);
2002 }
2003
2004 // .tensorflow.error.Code status_code = 3;
2005 if (this->_internal_status_code() != 0) {
2006 target = stream->EnsureSpace(target);
2007 target = ::_pbi::WireFormatLite::WriteEnumToArray(
2008 3, this->_internal_status_code(), target);
2009 }
2010
2011 // string status_error_message = 4;
2012 if (!this->_internal_status_error_message().empty()) {
2013 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
2014 this->_internal_status_error_message().data(), static_cast<int>(this->_internal_status_error_message().length()),
2015 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
2016 "tensorflow.RunStepResponse.status_error_message");
2017 target = stream->WriteStringMaybeAliased(
2018 4, this->_internal_status_error_message(), target);
2019 }
2020
2021 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2022 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2023 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2024 }
2025 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.RunStepResponse)
2026 return target;
2027 }
2028
ByteSizeLong() const2029 size_t RunStepResponse::ByteSizeLong() const {
2030 // @@protoc_insertion_point(message_byte_size_start:tensorflow.RunStepResponse)
2031 size_t total_size = 0;
2032
2033 ::uint32_t cached_has_bits = 0;
2034 // Prevent compiler warnings about cached_has_bits being unused
2035 (void) cached_has_bits;
2036
2037 // repeated .tensorflow.NamedTensorProto tensor = 1;
2038 total_size += 1UL * this->_internal_tensor_size();
2039 for (const auto& msg : this->_impl_.tensor_) {
2040 total_size +=
2041 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
2042 }
2043
2044 // string status_error_message = 4;
2045 if (!this->_internal_status_error_message().empty()) {
2046 total_size += 1 +
2047 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2048 this->_internal_status_error_message());
2049 }
2050
2051 // .tensorflow.RunMetadata metadata = 2;
2052 if (this->_internal_has_metadata()) {
2053 total_size += 1 +
2054 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
2055 *_impl_.metadata_);
2056 }
2057
2058 // .tensorflow.error.Code status_code = 3;
2059 if (this->_internal_status_code() != 0) {
2060 total_size += 1 +
2061 ::_pbi::WireFormatLite::EnumSize(this->_internal_status_code());
2062 }
2063
2064 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2065 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2066 }
2067 int cached_size = ::_pbi::ToCachedSize(total_size);
2068 SetCachedSize(cached_size);
2069 return total_size;
2070 }
2071
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2072 void RunStepResponse::CheckTypeAndMergeFrom(
2073 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2074 MergeFrom(*::_pbi::DownCast<const RunStepResponse*>(
2075 &from));
2076 }
2077
MergeFrom(const RunStepResponse & from)2078 void RunStepResponse::MergeFrom(const RunStepResponse& from) {
2079 RunStepResponse* const _this = this;
2080 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.RunStepResponse)
2081 GOOGLE_DCHECK_NE(&from, _this);
2082 ::uint32_t cached_has_bits = 0;
2083 (void) cached_has_bits;
2084
2085 _this->_impl_.tensor_.MergeFrom(from._impl_.tensor_);
2086 if (!from._internal_status_error_message().empty()) {
2087 _this->_internal_set_status_error_message(from._internal_status_error_message());
2088 }
2089 if (from._internal_has_metadata()) {
2090 _this->_internal_mutable_metadata()->::tensorflow::RunMetadata::MergeFrom(
2091 from._internal_metadata());
2092 }
2093 if (from._internal_status_code() != 0) {
2094 _this->_internal_set_status_code(from._internal_status_code());
2095 }
2096 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2097 }
2098
CopyFrom(const RunStepResponse & from)2099 void RunStepResponse::CopyFrom(const RunStepResponse& from) {
2100 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.RunStepResponse)
2101 if (&from == this) return;
2102 Clear();
2103 MergeFrom(from);
2104 }
2105
IsInitialized() const2106 bool RunStepResponse::IsInitialized() const {
2107 return true;
2108 }
2109
InternalSwap(RunStepResponse * other)2110 void RunStepResponse::InternalSwap(RunStepResponse* other) {
2111 using std::swap;
2112 auto* lhs_arena = GetArenaForAllocation();
2113 auto* rhs_arena = other->GetArenaForAllocation();
2114 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2115 _impl_.tensor_.InternalSwap(&other->_impl_.tensor_);
2116 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2117 &_impl_.status_error_message_, lhs_arena,
2118 &other->_impl_.status_error_message_, rhs_arena
2119 );
2120 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2121 PROTOBUF_FIELD_OFFSET(RunStepResponse, _impl_.status_code_)
2122 + sizeof(RunStepResponse::_impl_.status_code_) // NOLINT
2123 - PROTOBUF_FIELD_OFFSET(RunStepResponse, _impl_.metadata_)>(
2124 reinterpret_cast<char*>(&_impl_.metadata_),
2125 reinterpret_cast<char*>(&other->_impl_.metadata_));
2126 }
2127
GetTypeName() const2128 std::string RunStepResponse::GetTypeName() const {
2129 return "tensorflow.RunStepResponse";
2130 }
2131
2132
2133 // ===================================================================
2134
2135 class PartialRunSetupRequest::_Internal {
2136 public:
2137 };
2138
PartialRunSetupRequest(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2139 PartialRunSetupRequest::PartialRunSetupRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2140 bool is_message_owned)
2141 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2142 SharedCtor(arena, is_message_owned);
2143 // @@protoc_insertion_point(arena_constructor:tensorflow.PartialRunSetupRequest)
2144 }
PartialRunSetupRequest(const PartialRunSetupRequest & from)2145 PartialRunSetupRequest::PartialRunSetupRequest(const PartialRunSetupRequest& from)
2146 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2147 PartialRunSetupRequest* const _this = this; (void)_this;
2148 new (&_impl_) Impl_{
2149 decltype(_impl_.feed_){from._impl_.feed_}
2150 , decltype(_impl_.fetch_){from._impl_.fetch_}
2151 , decltype(_impl_.target_){from._impl_.target_}
2152 , decltype(_impl_.session_handle_){}
2153 , decltype(_impl_.request_id_){}
2154 , /*decltype(_impl_._cached_size_)*/{}};
2155
2156 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2157 _impl_.session_handle_.InitDefault();
2158 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2159 _impl_.session_handle_.Set("", GetArenaForAllocation());
2160 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2161 if (!from._internal_session_handle().empty()) {
2162 _this->_impl_.session_handle_.Set(from._internal_session_handle(),
2163 _this->GetArenaForAllocation());
2164 }
2165 _this->_impl_.request_id_ = from._impl_.request_id_;
2166 // @@protoc_insertion_point(copy_constructor:tensorflow.PartialRunSetupRequest)
2167 }
2168
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2169 inline void PartialRunSetupRequest::SharedCtor(
2170 ::_pb::Arena* arena, bool is_message_owned) {
2171 (void)arena;
2172 (void)is_message_owned;
2173 new (&_impl_) Impl_{
2174 decltype(_impl_.feed_){arena}
2175 , decltype(_impl_.fetch_){arena}
2176 , decltype(_impl_.target_){arena}
2177 , decltype(_impl_.session_handle_){}
2178 , decltype(_impl_.request_id_){::int64_t{0}}
2179 , /*decltype(_impl_._cached_size_)*/{}
2180 };
2181 _impl_.session_handle_.InitDefault();
2182 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2183 _impl_.session_handle_.Set("", GetArenaForAllocation());
2184 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2185 }
2186
~PartialRunSetupRequest()2187 PartialRunSetupRequest::~PartialRunSetupRequest() {
2188 // @@protoc_insertion_point(destructor:tensorflow.PartialRunSetupRequest)
2189 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2190 (void)arena;
2191 return;
2192 }
2193 SharedDtor();
2194 }
2195
SharedDtor()2196 inline void PartialRunSetupRequest::SharedDtor() {
2197 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2198 _impl_.feed_.~RepeatedPtrField();
2199 _impl_.fetch_.~RepeatedPtrField();
2200 _impl_.target_.~RepeatedPtrField();
2201 _impl_.session_handle_.Destroy();
2202 }
2203
SetCachedSize(int size) const2204 void PartialRunSetupRequest::SetCachedSize(int size) const {
2205 _impl_._cached_size_.Set(size);
2206 }
2207
Clear()2208 void PartialRunSetupRequest::Clear() {
2209 // @@protoc_insertion_point(message_clear_start:tensorflow.PartialRunSetupRequest)
2210 ::uint32_t cached_has_bits = 0;
2211 // Prevent compiler warnings about cached_has_bits being unused
2212 (void) cached_has_bits;
2213
2214 _impl_.feed_.Clear();
2215 _impl_.fetch_.Clear();
2216 _impl_.target_.Clear();
2217 _impl_.session_handle_.ClearToEmpty();
2218 _impl_.request_id_ = ::int64_t{0};
2219 _internal_metadata_.Clear<std::string>();
2220 }
2221
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2222 const char* PartialRunSetupRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2223 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2224 while (!ctx->Done(&ptr)) {
2225 ::uint32_t tag;
2226 ptr = ::_pbi::ReadTag(ptr, &tag);
2227 switch (tag >> 3) {
2228 // string session_handle = 1;
2229 case 1:
2230 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
2231 auto str = _internal_mutable_session_handle();
2232 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2233 CHK_(ptr);
2234 CHK_(::_pbi::VerifyUTF8(str, nullptr));
2235 } else {
2236 goto handle_unusual;
2237 }
2238 continue;
2239 // repeated string feed = 2;
2240 case 2:
2241 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
2242 ptr -= 1;
2243 do {
2244 ptr += 1;
2245 auto str = _internal_add_feed();
2246 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2247 CHK_(ptr);
2248 CHK_(::_pbi::VerifyUTF8(str, nullptr));
2249 if (!ctx->DataAvailable(ptr)) break;
2250 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
2251 } else {
2252 goto handle_unusual;
2253 }
2254 continue;
2255 // repeated string fetch = 3;
2256 case 3:
2257 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
2258 ptr -= 1;
2259 do {
2260 ptr += 1;
2261 auto str = _internal_add_fetch();
2262 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2263 CHK_(ptr);
2264 CHK_(::_pbi::VerifyUTF8(str, nullptr));
2265 if (!ctx->DataAvailable(ptr)) break;
2266 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
2267 } else {
2268 goto handle_unusual;
2269 }
2270 continue;
2271 // repeated string target = 4;
2272 case 4:
2273 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
2274 ptr -= 1;
2275 do {
2276 ptr += 1;
2277 auto str = _internal_add_target();
2278 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2279 CHK_(ptr);
2280 CHK_(::_pbi::VerifyUTF8(str, nullptr));
2281 if (!ctx->DataAvailable(ptr)) break;
2282 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
2283 } else {
2284 goto handle_unusual;
2285 }
2286 continue;
2287 // int64 request_id = 5;
2288 case 5:
2289 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
2290 _impl_.request_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2291 CHK_(ptr);
2292 } else {
2293 goto handle_unusual;
2294 }
2295 continue;
2296 default:
2297 goto handle_unusual;
2298 } // switch
2299 handle_unusual:
2300 if ((tag == 0) || ((tag & 7) == 4)) {
2301 CHK_(ptr);
2302 ctx->SetLastTag(tag);
2303 goto message_done;
2304 }
2305 ptr = UnknownFieldParse(
2306 tag,
2307 _internal_metadata_.mutable_unknown_fields<std::string>(),
2308 ptr, ctx);
2309 CHK_(ptr != nullptr);
2310 } // while
2311 message_done:
2312 return ptr;
2313 failure:
2314 ptr = nullptr;
2315 goto message_done;
2316 #undef CHK_
2317 }
2318
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2319 ::uint8_t* PartialRunSetupRequest::_InternalSerialize(
2320 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2321 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.PartialRunSetupRequest)
2322 ::uint32_t cached_has_bits = 0;
2323 (void) cached_has_bits;
2324
2325 // string session_handle = 1;
2326 if (!this->_internal_session_handle().empty()) {
2327 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
2328 this->_internal_session_handle().data(), static_cast<int>(this->_internal_session_handle().length()),
2329 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
2330 "tensorflow.PartialRunSetupRequest.session_handle");
2331 target = stream->WriteStringMaybeAliased(
2332 1, this->_internal_session_handle(), target);
2333 }
2334
2335 // repeated string feed = 2;
2336 for (int i = 0, n = this->_internal_feed_size(); i < n; i++) {
2337 const auto& s = this->_internal_feed(i);
2338 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
2339 s.data(), static_cast<int>(s.length()),
2340 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
2341 "tensorflow.PartialRunSetupRequest.feed");
2342 target = stream->WriteString(2, s, target);
2343 }
2344
2345 // repeated string fetch = 3;
2346 for (int i = 0, n = this->_internal_fetch_size(); i < n; i++) {
2347 const auto& s = this->_internal_fetch(i);
2348 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
2349 s.data(), static_cast<int>(s.length()),
2350 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
2351 "tensorflow.PartialRunSetupRequest.fetch");
2352 target = stream->WriteString(3, s, target);
2353 }
2354
2355 // repeated string target = 4;
2356 for (int i = 0, n = this->_internal_target_size(); i < n; i++) {
2357 const auto& s = this->_internal_target(i);
2358 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
2359 s.data(), static_cast<int>(s.length()),
2360 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
2361 "tensorflow.PartialRunSetupRequest.target");
2362 target = stream->WriteString(4, s, target);
2363 }
2364
2365 // int64 request_id = 5;
2366 if (this->_internal_request_id() != 0) {
2367 target = stream->EnsureSpace(target);
2368 target = ::_pbi::WireFormatLite::WriteInt64ToArray(5, this->_internal_request_id(), target);
2369 }
2370
2371 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2372 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2373 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2374 }
2375 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.PartialRunSetupRequest)
2376 return target;
2377 }
2378
ByteSizeLong() const2379 size_t PartialRunSetupRequest::ByteSizeLong() const {
2380 // @@protoc_insertion_point(message_byte_size_start:tensorflow.PartialRunSetupRequest)
2381 size_t total_size = 0;
2382
2383 ::uint32_t cached_has_bits = 0;
2384 // Prevent compiler warnings about cached_has_bits being unused
2385 (void) cached_has_bits;
2386
2387 // repeated string feed = 2;
2388 total_size += 1 *
2389 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.feed_.size());
2390 for (int i = 0, n = _impl_.feed_.size(); i < n; i++) {
2391 total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2392 _impl_.feed_.Get(i));
2393 }
2394
2395 // repeated string fetch = 3;
2396 total_size += 1 *
2397 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.fetch_.size());
2398 for (int i = 0, n = _impl_.fetch_.size(); i < n; i++) {
2399 total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2400 _impl_.fetch_.Get(i));
2401 }
2402
2403 // repeated string target = 4;
2404 total_size += 1 *
2405 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.target_.size());
2406 for (int i = 0, n = _impl_.target_.size(); i < n; i++) {
2407 total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2408 _impl_.target_.Get(i));
2409 }
2410
2411 // string session_handle = 1;
2412 if (!this->_internal_session_handle().empty()) {
2413 total_size += 1 +
2414 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2415 this->_internal_session_handle());
2416 }
2417
2418 // int64 request_id = 5;
2419 if (this->_internal_request_id() != 0) {
2420 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_request_id());
2421 }
2422
2423 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2424 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2425 }
2426 int cached_size = ::_pbi::ToCachedSize(total_size);
2427 SetCachedSize(cached_size);
2428 return total_size;
2429 }
2430
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2431 void PartialRunSetupRequest::CheckTypeAndMergeFrom(
2432 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2433 MergeFrom(*::_pbi::DownCast<const PartialRunSetupRequest*>(
2434 &from));
2435 }
2436
MergeFrom(const PartialRunSetupRequest & from)2437 void PartialRunSetupRequest::MergeFrom(const PartialRunSetupRequest& from) {
2438 PartialRunSetupRequest* const _this = this;
2439 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.PartialRunSetupRequest)
2440 GOOGLE_DCHECK_NE(&from, _this);
2441 ::uint32_t cached_has_bits = 0;
2442 (void) cached_has_bits;
2443
2444 _this->_impl_.feed_.MergeFrom(from._impl_.feed_);
2445 _this->_impl_.fetch_.MergeFrom(from._impl_.fetch_);
2446 _this->_impl_.target_.MergeFrom(from._impl_.target_);
2447 if (!from._internal_session_handle().empty()) {
2448 _this->_internal_set_session_handle(from._internal_session_handle());
2449 }
2450 if (from._internal_request_id() != 0) {
2451 _this->_internal_set_request_id(from._internal_request_id());
2452 }
2453 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2454 }
2455
CopyFrom(const PartialRunSetupRequest & from)2456 void PartialRunSetupRequest::CopyFrom(const PartialRunSetupRequest& from) {
2457 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.PartialRunSetupRequest)
2458 if (&from == this) return;
2459 Clear();
2460 MergeFrom(from);
2461 }
2462
IsInitialized() const2463 bool PartialRunSetupRequest::IsInitialized() const {
2464 return true;
2465 }
2466
InternalSwap(PartialRunSetupRequest * other)2467 void PartialRunSetupRequest::InternalSwap(PartialRunSetupRequest* other) {
2468 using std::swap;
2469 auto* lhs_arena = GetArenaForAllocation();
2470 auto* rhs_arena = other->GetArenaForAllocation();
2471 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2472 _impl_.feed_.InternalSwap(&other->_impl_.feed_);
2473 _impl_.fetch_.InternalSwap(&other->_impl_.fetch_);
2474 _impl_.target_.InternalSwap(&other->_impl_.target_);
2475 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2476 &_impl_.session_handle_, lhs_arena,
2477 &other->_impl_.session_handle_, rhs_arena
2478 );
2479 swap(_impl_.request_id_, other->_impl_.request_id_);
2480 }
2481
GetTypeName() const2482 std::string PartialRunSetupRequest::GetTypeName() const {
2483 return "tensorflow.PartialRunSetupRequest";
2484 }
2485
2486
2487 // ===================================================================
2488
2489 class PartialRunSetupResponse::_Internal {
2490 public:
2491 };
2492
PartialRunSetupResponse(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2493 PartialRunSetupResponse::PartialRunSetupResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2494 bool is_message_owned)
2495 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2496 SharedCtor(arena, is_message_owned);
2497 // @@protoc_insertion_point(arena_constructor:tensorflow.PartialRunSetupResponse)
2498 }
PartialRunSetupResponse(const PartialRunSetupResponse & from)2499 PartialRunSetupResponse::PartialRunSetupResponse(const PartialRunSetupResponse& from)
2500 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2501 PartialRunSetupResponse* const _this = this; (void)_this;
2502 new (&_impl_) Impl_{
2503 decltype(_impl_.partial_run_handle_){}
2504 , /*decltype(_impl_._cached_size_)*/{}};
2505
2506 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2507 _impl_.partial_run_handle_.InitDefault();
2508 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2509 _impl_.partial_run_handle_.Set("", GetArenaForAllocation());
2510 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2511 if (!from._internal_partial_run_handle().empty()) {
2512 _this->_impl_.partial_run_handle_.Set(from._internal_partial_run_handle(),
2513 _this->GetArenaForAllocation());
2514 }
2515 // @@protoc_insertion_point(copy_constructor:tensorflow.PartialRunSetupResponse)
2516 }
2517
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2518 inline void PartialRunSetupResponse::SharedCtor(
2519 ::_pb::Arena* arena, bool is_message_owned) {
2520 (void)arena;
2521 (void)is_message_owned;
2522 new (&_impl_) Impl_{
2523 decltype(_impl_.partial_run_handle_){}
2524 , /*decltype(_impl_._cached_size_)*/{}
2525 };
2526 _impl_.partial_run_handle_.InitDefault();
2527 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2528 _impl_.partial_run_handle_.Set("", GetArenaForAllocation());
2529 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2530 }
2531
~PartialRunSetupResponse()2532 PartialRunSetupResponse::~PartialRunSetupResponse() {
2533 // @@protoc_insertion_point(destructor:tensorflow.PartialRunSetupResponse)
2534 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2535 (void)arena;
2536 return;
2537 }
2538 SharedDtor();
2539 }
2540
SharedDtor()2541 inline void PartialRunSetupResponse::SharedDtor() {
2542 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2543 _impl_.partial_run_handle_.Destroy();
2544 }
2545
SetCachedSize(int size) const2546 void PartialRunSetupResponse::SetCachedSize(int size) const {
2547 _impl_._cached_size_.Set(size);
2548 }
2549
Clear()2550 void PartialRunSetupResponse::Clear() {
2551 // @@protoc_insertion_point(message_clear_start:tensorflow.PartialRunSetupResponse)
2552 ::uint32_t cached_has_bits = 0;
2553 // Prevent compiler warnings about cached_has_bits being unused
2554 (void) cached_has_bits;
2555
2556 _impl_.partial_run_handle_.ClearToEmpty();
2557 _internal_metadata_.Clear<std::string>();
2558 }
2559
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2560 const char* PartialRunSetupResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2561 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2562 while (!ctx->Done(&ptr)) {
2563 ::uint32_t tag;
2564 ptr = ::_pbi::ReadTag(ptr, &tag);
2565 switch (tag >> 3) {
2566 // string partial_run_handle = 1;
2567 case 1:
2568 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
2569 auto str = _internal_mutable_partial_run_handle();
2570 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2571 CHK_(ptr);
2572 CHK_(::_pbi::VerifyUTF8(str, nullptr));
2573 } else {
2574 goto handle_unusual;
2575 }
2576 continue;
2577 default:
2578 goto handle_unusual;
2579 } // switch
2580 handle_unusual:
2581 if ((tag == 0) || ((tag & 7) == 4)) {
2582 CHK_(ptr);
2583 ctx->SetLastTag(tag);
2584 goto message_done;
2585 }
2586 ptr = UnknownFieldParse(
2587 tag,
2588 _internal_metadata_.mutable_unknown_fields<std::string>(),
2589 ptr, ctx);
2590 CHK_(ptr != nullptr);
2591 } // while
2592 message_done:
2593 return ptr;
2594 failure:
2595 ptr = nullptr;
2596 goto message_done;
2597 #undef CHK_
2598 }
2599
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2600 ::uint8_t* PartialRunSetupResponse::_InternalSerialize(
2601 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2602 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.PartialRunSetupResponse)
2603 ::uint32_t cached_has_bits = 0;
2604 (void) cached_has_bits;
2605
2606 // string partial_run_handle = 1;
2607 if (!this->_internal_partial_run_handle().empty()) {
2608 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
2609 this->_internal_partial_run_handle().data(), static_cast<int>(this->_internal_partial_run_handle().length()),
2610 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
2611 "tensorflow.PartialRunSetupResponse.partial_run_handle");
2612 target = stream->WriteStringMaybeAliased(
2613 1, this->_internal_partial_run_handle(), target);
2614 }
2615
2616 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2617 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2618 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2619 }
2620 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.PartialRunSetupResponse)
2621 return target;
2622 }
2623
ByteSizeLong() const2624 size_t PartialRunSetupResponse::ByteSizeLong() const {
2625 // @@protoc_insertion_point(message_byte_size_start:tensorflow.PartialRunSetupResponse)
2626 size_t total_size = 0;
2627
2628 ::uint32_t cached_has_bits = 0;
2629 // Prevent compiler warnings about cached_has_bits being unused
2630 (void) cached_has_bits;
2631
2632 // string partial_run_handle = 1;
2633 if (!this->_internal_partial_run_handle().empty()) {
2634 total_size += 1 +
2635 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2636 this->_internal_partial_run_handle());
2637 }
2638
2639 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2640 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2641 }
2642 int cached_size = ::_pbi::ToCachedSize(total_size);
2643 SetCachedSize(cached_size);
2644 return total_size;
2645 }
2646
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2647 void PartialRunSetupResponse::CheckTypeAndMergeFrom(
2648 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2649 MergeFrom(*::_pbi::DownCast<const PartialRunSetupResponse*>(
2650 &from));
2651 }
2652
MergeFrom(const PartialRunSetupResponse & from)2653 void PartialRunSetupResponse::MergeFrom(const PartialRunSetupResponse& from) {
2654 PartialRunSetupResponse* const _this = this;
2655 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.PartialRunSetupResponse)
2656 GOOGLE_DCHECK_NE(&from, _this);
2657 ::uint32_t cached_has_bits = 0;
2658 (void) cached_has_bits;
2659
2660 if (!from._internal_partial_run_handle().empty()) {
2661 _this->_internal_set_partial_run_handle(from._internal_partial_run_handle());
2662 }
2663 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2664 }
2665
CopyFrom(const PartialRunSetupResponse & from)2666 void PartialRunSetupResponse::CopyFrom(const PartialRunSetupResponse& from) {
2667 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.PartialRunSetupResponse)
2668 if (&from == this) return;
2669 Clear();
2670 MergeFrom(from);
2671 }
2672
IsInitialized() const2673 bool PartialRunSetupResponse::IsInitialized() const {
2674 return true;
2675 }
2676
InternalSwap(PartialRunSetupResponse * other)2677 void PartialRunSetupResponse::InternalSwap(PartialRunSetupResponse* other) {
2678 using std::swap;
2679 auto* lhs_arena = GetArenaForAllocation();
2680 auto* rhs_arena = other->GetArenaForAllocation();
2681 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2682 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2683 &_impl_.partial_run_handle_, lhs_arena,
2684 &other->_impl_.partial_run_handle_, rhs_arena
2685 );
2686 }
2687
GetTypeName() const2688 std::string PartialRunSetupResponse::GetTypeName() const {
2689 return "tensorflow.PartialRunSetupResponse";
2690 }
2691
2692
2693 // ===================================================================
2694
2695 class CloseSessionRequest::_Internal {
2696 public:
2697 };
2698
CloseSessionRequest(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2699 CloseSessionRequest::CloseSessionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2700 bool is_message_owned)
2701 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2702 SharedCtor(arena, is_message_owned);
2703 // @@protoc_insertion_point(arena_constructor:tensorflow.CloseSessionRequest)
2704 }
CloseSessionRequest(const CloseSessionRequest & from)2705 CloseSessionRequest::CloseSessionRequest(const CloseSessionRequest& from)
2706 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2707 CloseSessionRequest* const _this = this; (void)_this;
2708 new (&_impl_) Impl_{
2709 decltype(_impl_.session_handle_){}
2710 , /*decltype(_impl_._cached_size_)*/{}};
2711
2712 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2713 _impl_.session_handle_.InitDefault();
2714 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2715 _impl_.session_handle_.Set("", GetArenaForAllocation());
2716 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2717 if (!from._internal_session_handle().empty()) {
2718 _this->_impl_.session_handle_.Set(from._internal_session_handle(),
2719 _this->GetArenaForAllocation());
2720 }
2721 // @@protoc_insertion_point(copy_constructor:tensorflow.CloseSessionRequest)
2722 }
2723
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2724 inline void CloseSessionRequest::SharedCtor(
2725 ::_pb::Arena* arena, bool is_message_owned) {
2726 (void)arena;
2727 (void)is_message_owned;
2728 new (&_impl_) Impl_{
2729 decltype(_impl_.session_handle_){}
2730 , /*decltype(_impl_._cached_size_)*/{}
2731 };
2732 _impl_.session_handle_.InitDefault();
2733 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2734 _impl_.session_handle_.Set("", GetArenaForAllocation());
2735 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2736 }
2737
~CloseSessionRequest()2738 CloseSessionRequest::~CloseSessionRequest() {
2739 // @@protoc_insertion_point(destructor:tensorflow.CloseSessionRequest)
2740 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2741 (void)arena;
2742 return;
2743 }
2744 SharedDtor();
2745 }
2746
SharedDtor()2747 inline void CloseSessionRequest::SharedDtor() {
2748 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2749 _impl_.session_handle_.Destroy();
2750 }
2751
SetCachedSize(int size) const2752 void CloseSessionRequest::SetCachedSize(int size) const {
2753 _impl_._cached_size_.Set(size);
2754 }
2755
Clear()2756 void CloseSessionRequest::Clear() {
2757 // @@protoc_insertion_point(message_clear_start:tensorflow.CloseSessionRequest)
2758 ::uint32_t cached_has_bits = 0;
2759 // Prevent compiler warnings about cached_has_bits being unused
2760 (void) cached_has_bits;
2761
2762 _impl_.session_handle_.ClearToEmpty();
2763 _internal_metadata_.Clear<std::string>();
2764 }
2765
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2766 const char* CloseSessionRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2767 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2768 while (!ctx->Done(&ptr)) {
2769 ::uint32_t tag;
2770 ptr = ::_pbi::ReadTag(ptr, &tag);
2771 switch (tag >> 3) {
2772 // string session_handle = 1;
2773 case 1:
2774 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
2775 auto str = _internal_mutable_session_handle();
2776 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2777 CHK_(ptr);
2778 CHK_(::_pbi::VerifyUTF8(str, nullptr));
2779 } else {
2780 goto handle_unusual;
2781 }
2782 continue;
2783 default:
2784 goto handle_unusual;
2785 } // switch
2786 handle_unusual:
2787 if ((tag == 0) || ((tag & 7) == 4)) {
2788 CHK_(ptr);
2789 ctx->SetLastTag(tag);
2790 goto message_done;
2791 }
2792 ptr = UnknownFieldParse(
2793 tag,
2794 _internal_metadata_.mutable_unknown_fields<std::string>(),
2795 ptr, ctx);
2796 CHK_(ptr != nullptr);
2797 } // while
2798 message_done:
2799 return ptr;
2800 failure:
2801 ptr = nullptr;
2802 goto message_done;
2803 #undef CHK_
2804 }
2805
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2806 ::uint8_t* CloseSessionRequest::_InternalSerialize(
2807 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2808 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.CloseSessionRequest)
2809 ::uint32_t cached_has_bits = 0;
2810 (void) cached_has_bits;
2811
2812 // string session_handle = 1;
2813 if (!this->_internal_session_handle().empty()) {
2814 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
2815 this->_internal_session_handle().data(), static_cast<int>(this->_internal_session_handle().length()),
2816 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
2817 "tensorflow.CloseSessionRequest.session_handle");
2818 target = stream->WriteStringMaybeAliased(
2819 1, this->_internal_session_handle(), target);
2820 }
2821
2822 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2823 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2824 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2825 }
2826 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.CloseSessionRequest)
2827 return target;
2828 }
2829
ByteSizeLong() const2830 size_t CloseSessionRequest::ByteSizeLong() const {
2831 // @@protoc_insertion_point(message_byte_size_start:tensorflow.CloseSessionRequest)
2832 size_t total_size = 0;
2833
2834 ::uint32_t cached_has_bits = 0;
2835 // Prevent compiler warnings about cached_has_bits being unused
2836 (void) cached_has_bits;
2837
2838 // string session_handle = 1;
2839 if (!this->_internal_session_handle().empty()) {
2840 total_size += 1 +
2841 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2842 this->_internal_session_handle());
2843 }
2844
2845 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2846 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2847 }
2848 int cached_size = ::_pbi::ToCachedSize(total_size);
2849 SetCachedSize(cached_size);
2850 return total_size;
2851 }
2852
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2853 void CloseSessionRequest::CheckTypeAndMergeFrom(
2854 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2855 MergeFrom(*::_pbi::DownCast<const CloseSessionRequest*>(
2856 &from));
2857 }
2858
MergeFrom(const CloseSessionRequest & from)2859 void CloseSessionRequest::MergeFrom(const CloseSessionRequest& from) {
2860 CloseSessionRequest* const _this = this;
2861 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.CloseSessionRequest)
2862 GOOGLE_DCHECK_NE(&from, _this);
2863 ::uint32_t cached_has_bits = 0;
2864 (void) cached_has_bits;
2865
2866 if (!from._internal_session_handle().empty()) {
2867 _this->_internal_set_session_handle(from._internal_session_handle());
2868 }
2869 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2870 }
2871
CopyFrom(const CloseSessionRequest & from)2872 void CloseSessionRequest::CopyFrom(const CloseSessionRequest& from) {
2873 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.CloseSessionRequest)
2874 if (&from == this) return;
2875 Clear();
2876 MergeFrom(from);
2877 }
2878
IsInitialized() const2879 bool CloseSessionRequest::IsInitialized() const {
2880 return true;
2881 }
2882
InternalSwap(CloseSessionRequest * other)2883 void CloseSessionRequest::InternalSwap(CloseSessionRequest* other) {
2884 using std::swap;
2885 auto* lhs_arena = GetArenaForAllocation();
2886 auto* rhs_arena = other->GetArenaForAllocation();
2887 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2888 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2889 &_impl_.session_handle_, lhs_arena,
2890 &other->_impl_.session_handle_, rhs_arena
2891 );
2892 }
2893
GetTypeName() const2894 std::string CloseSessionRequest::GetTypeName() const {
2895 return "tensorflow.CloseSessionRequest";
2896 }
2897
2898
2899 // ===================================================================
2900
2901 class CloseSessionResponse::_Internal {
2902 public:
2903 };
2904
CloseSessionResponse(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2905 CloseSessionResponse::CloseSessionResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2906 bool is_message_owned)
2907 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2908 SharedCtor(arena, is_message_owned);
2909 // @@protoc_insertion_point(arena_constructor:tensorflow.CloseSessionResponse)
2910 }
CloseSessionResponse(const CloseSessionResponse & from)2911 CloseSessionResponse::CloseSessionResponse(const CloseSessionResponse& from)
2912 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2913 CloseSessionResponse* const _this = this; (void)_this;
2914 new (&_impl_) Impl_{
2915 /*decltype(_impl_._cached_size_)*/{}};
2916
2917 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2918 // @@protoc_insertion_point(copy_constructor:tensorflow.CloseSessionResponse)
2919 }
2920
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2921 inline void CloseSessionResponse::SharedCtor(
2922 ::_pb::Arena* arena, bool is_message_owned) {
2923 (void)arena;
2924 (void)is_message_owned;
2925 new (&_impl_) Impl_{
2926 /*decltype(_impl_._cached_size_)*/{}
2927 };
2928 }
2929
~CloseSessionResponse()2930 CloseSessionResponse::~CloseSessionResponse() {
2931 // @@protoc_insertion_point(destructor:tensorflow.CloseSessionResponse)
2932 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2933 (void)arena;
2934 return;
2935 }
2936 SharedDtor();
2937 }
2938
SharedDtor()2939 inline void CloseSessionResponse::SharedDtor() {
2940 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2941 }
2942
SetCachedSize(int size) const2943 void CloseSessionResponse::SetCachedSize(int size) const {
2944 _impl_._cached_size_.Set(size);
2945 }
2946
Clear()2947 void CloseSessionResponse::Clear() {
2948 // @@protoc_insertion_point(message_clear_start:tensorflow.CloseSessionResponse)
2949 ::uint32_t cached_has_bits = 0;
2950 // Prevent compiler warnings about cached_has_bits being unused
2951 (void) cached_has_bits;
2952
2953 _internal_metadata_.Clear<std::string>();
2954 }
2955
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2956 const char* CloseSessionResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2957 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2958 while (!ctx->Done(&ptr)) {
2959 ::uint32_t tag;
2960 ptr = ::_pbi::ReadTag(ptr, &tag);
2961 if ((tag == 0) || ((tag & 7) == 4)) {
2962 CHK_(ptr);
2963 ctx->SetLastTag(tag);
2964 goto message_done;
2965 }
2966 ptr = UnknownFieldParse(
2967 tag,
2968 _internal_metadata_.mutable_unknown_fields<std::string>(),
2969 ptr, ctx);
2970 CHK_(ptr != nullptr);
2971 } // while
2972 message_done:
2973 return ptr;
2974 failure:
2975 ptr = nullptr;
2976 goto message_done;
2977 #undef CHK_
2978 }
2979
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2980 ::uint8_t* CloseSessionResponse::_InternalSerialize(
2981 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2982 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.CloseSessionResponse)
2983 ::uint32_t cached_has_bits = 0;
2984 (void) cached_has_bits;
2985
2986 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2987 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2988 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2989 }
2990 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.CloseSessionResponse)
2991 return target;
2992 }
2993
ByteSizeLong() const2994 size_t CloseSessionResponse::ByteSizeLong() const {
2995 // @@protoc_insertion_point(message_byte_size_start:tensorflow.CloseSessionResponse)
2996 size_t total_size = 0;
2997
2998 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2999 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3000 }
3001 int cached_size = ::_pbi::ToCachedSize(total_size);
3002 SetCachedSize(cached_size);
3003 return total_size;
3004 }
3005
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3006 void CloseSessionResponse::CheckTypeAndMergeFrom(
3007 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3008 MergeFrom(*::_pbi::DownCast<const CloseSessionResponse*>(
3009 &from));
3010 }
3011
MergeFrom(const CloseSessionResponse & from)3012 void CloseSessionResponse::MergeFrom(const CloseSessionResponse& from) {
3013 CloseSessionResponse* const _this = this;
3014 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.CloseSessionResponse)
3015 GOOGLE_DCHECK_NE(&from, _this);
3016 ::uint32_t cached_has_bits = 0;
3017 (void) cached_has_bits;
3018
3019 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3020 }
3021
CopyFrom(const CloseSessionResponse & from)3022 void CloseSessionResponse::CopyFrom(const CloseSessionResponse& from) {
3023 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.CloseSessionResponse)
3024 if (&from == this) return;
3025 Clear();
3026 MergeFrom(from);
3027 }
3028
IsInitialized() const3029 bool CloseSessionResponse::IsInitialized() const {
3030 return true;
3031 }
3032
InternalSwap(CloseSessionResponse * other)3033 void CloseSessionResponse::InternalSwap(CloseSessionResponse* other) {
3034 using std::swap;
3035 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3036 }
3037
GetTypeName() const3038 std::string CloseSessionResponse::GetTypeName() const {
3039 return "tensorflow.CloseSessionResponse";
3040 }
3041
3042
3043 // ===================================================================
3044
3045 class ResetRequest::_Internal {
3046 public:
3047 };
3048
ResetRequest(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3049 ResetRequest::ResetRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3050 bool is_message_owned)
3051 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3052 SharedCtor(arena, is_message_owned);
3053 // @@protoc_insertion_point(arena_constructor:tensorflow.ResetRequest)
3054 }
ResetRequest(const ResetRequest & from)3055 ResetRequest::ResetRequest(const ResetRequest& from)
3056 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3057 ResetRequest* const _this = this; (void)_this;
3058 new (&_impl_) Impl_{
3059 decltype(_impl_.container_){from._impl_.container_}
3060 , decltype(_impl_.device_filters_){from._impl_.device_filters_}
3061 , /*decltype(_impl_._cached_size_)*/{}};
3062
3063 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3064 // @@protoc_insertion_point(copy_constructor:tensorflow.ResetRequest)
3065 }
3066
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3067 inline void ResetRequest::SharedCtor(
3068 ::_pb::Arena* arena, bool is_message_owned) {
3069 (void)arena;
3070 (void)is_message_owned;
3071 new (&_impl_) Impl_{
3072 decltype(_impl_.container_){arena}
3073 , decltype(_impl_.device_filters_){arena}
3074 , /*decltype(_impl_._cached_size_)*/{}
3075 };
3076 }
3077
~ResetRequest()3078 ResetRequest::~ResetRequest() {
3079 // @@protoc_insertion_point(destructor:tensorflow.ResetRequest)
3080 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3081 (void)arena;
3082 return;
3083 }
3084 SharedDtor();
3085 }
3086
SharedDtor()3087 inline void ResetRequest::SharedDtor() {
3088 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3089 _impl_.container_.~RepeatedPtrField();
3090 _impl_.device_filters_.~RepeatedPtrField();
3091 }
3092
SetCachedSize(int size) const3093 void ResetRequest::SetCachedSize(int size) const {
3094 _impl_._cached_size_.Set(size);
3095 }
3096
Clear()3097 void ResetRequest::Clear() {
3098 // @@protoc_insertion_point(message_clear_start:tensorflow.ResetRequest)
3099 ::uint32_t cached_has_bits = 0;
3100 // Prevent compiler warnings about cached_has_bits being unused
3101 (void) cached_has_bits;
3102
3103 _impl_.container_.Clear();
3104 _impl_.device_filters_.Clear();
3105 _internal_metadata_.Clear<std::string>();
3106 }
3107
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3108 const char* ResetRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3109 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3110 while (!ctx->Done(&ptr)) {
3111 ::uint32_t tag;
3112 ptr = ::_pbi::ReadTag(ptr, &tag);
3113 switch (tag >> 3) {
3114 // repeated string container = 1;
3115 case 1:
3116 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
3117 ptr -= 1;
3118 do {
3119 ptr += 1;
3120 auto str = _internal_add_container();
3121 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
3122 CHK_(ptr);
3123 CHK_(::_pbi::VerifyUTF8(str, nullptr));
3124 if (!ctx->DataAvailable(ptr)) break;
3125 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
3126 } else {
3127 goto handle_unusual;
3128 }
3129 continue;
3130 // repeated string device_filters = 2;
3131 case 2:
3132 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
3133 ptr -= 1;
3134 do {
3135 ptr += 1;
3136 auto str = _internal_add_device_filters();
3137 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
3138 CHK_(ptr);
3139 CHK_(::_pbi::VerifyUTF8(str, nullptr));
3140 if (!ctx->DataAvailable(ptr)) break;
3141 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
3142 } else {
3143 goto handle_unusual;
3144 }
3145 continue;
3146 default:
3147 goto handle_unusual;
3148 } // switch
3149 handle_unusual:
3150 if ((tag == 0) || ((tag & 7) == 4)) {
3151 CHK_(ptr);
3152 ctx->SetLastTag(tag);
3153 goto message_done;
3154 }
3155 ptr = UnknownFieldParse(
3156 tag,
3157 _internal_metadata_.mutable_unknown_fields<std::string>(),
3158 ptr, ctx);
3159 CHK_(ptr != nullptr);
3160 } // while
3161 message_done:
3162 return ptr;
3163 failure:
3164 ptr = nullptr;
3165 goto message_done;
3166 #undef CHK_
3167 }
3168
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3169 ::uint8_t* ResetRequest::_InternalSerialize(
3170 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3171 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.ResetRequest)
3172 ::uint32_t cached_has_bits = 0;
3173 (void) cached_has_bits;
3174
3175 // repeated string container = 1;
3176 for (int i = 0, n = this->_internal_container_size(); i < n; i++) {
3177 const auto& s = this->_internal_container(i);
3178 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
3179 s.data(), static_cast<int>(s.length()),
3180 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
3181 "tensorflow.ResetRequest.container");
3182 target = stream->WriteString(1, s, target);
3183 }
3184
3185 // repeated string device_filters = 2;
3186 for (int i = 0, n = this->_internal_device_filters_size(); i < n; i++) {
3187 const auto& s = this->_internal_device_filters(i);
3188 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
3189 s.data(), static_cast<int>(s.length()),
3190 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
3191 "tensorflow.ResetRequest.device_filters");
3192 target = stream->WriteString(2, s, target);
3193 }
3194
3195 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3196 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3197 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3198 }
3199 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.ResetRequest)
3200 return target;
3201 }
3202
ByteSizeLong() const3203 size_t ResetRequest::ByteSizeLong() const {
3204 // @@protoc_insertion_point(message_byte_size_start:tensorflow.ResetRequest)
3205 size_t total_size = 0;
3206
3207 ::uint32_t cached_has_bits = 0;
3208 // Prevent compiler warnings about cached_has_bits being unused
3209 (void) cached_has_bits;
3210
3211 // repeated string container = 1;
3212 total_size += 1 *
3213 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.container_.size());
3214 for (int i = 0, n = _impl_.container_.size(); i < n; i++) {
3215 total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
3216 _impl_.container_.Get(i));
3217 }
3218
3219 // repeated string device_filters = 2;
3220 total_size += 1 *
3221 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.device_filters_.size());
3222 for (int i = 0, n = _impl_.device_filters_.size(); i < n; i++) {
3223 total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
3224 _impl_.device_filters_.Get(i));
3225 }
3226
3227 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3228 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3229 }
3230 int cached_size = ::_pbi::ToCachedSize(total_size);
3231 SetCachedSize(cached_size);
3232 return total_size;
3233 }
3234
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3235 void ResetRequest::CheckTypeAndMergeFrom(
3236 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3237 MergeFrom(*::_pbi::DownCast<const ResetRequest*>(
3238 &from));
3239 }
3240
MergeFrom(const ResetRequest & from)3241 void ResetRequest::MergeFrom(const ResetRequest& from) {
3242 ResetRequest* const _this = this;
3243 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.ResetRequest)
3244 GOOGLE_DCHECK_NE(&from, _this);
3245 ::uint32_t cached_has_bits = 0;
3246 (void) cached_has_bits;
3247
3248 _this->_impl_.container_.MergeFrom(from._impl_.container_);
3249 _this->_impl_.device_filters_.MergeFrom(from._impl_.device_filters_);
3250 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3251 }
3252
CopyFrom(const ResetRequest & from)3253 void ResetRequest::CopyFrom(const ResetRequest& from) {
3254 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.ResetRequest)
3255 if (&from == this) return;
3256 Clear();
3257 MergeFrom(from);
3258 }
3259
IsInitialized() const3260 bool ResetRequest::IsInitialized() const {
3261 return true;
3262 }
3263
InternalSwap(ResetRequest * other)3264 void ResetRequest::InternalSwap(ResetRequest* other) {
3265 using std::swap;
3266 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3267 _impl_.container_.InternalSwap(&other->_impl_.container_);
3268 _impl_.device_filters_.InternalSwap(&other->_impl_.device_filters_);
3269 }
3270
GetTypeName() const3271 std::string ResetRequest::GetTypeName() const {
3272 return "tensorflow.ResetRequest";
3273 }
3274
3275
3276 // ===================================================================
3277
3278 class ResetResponse::_Internal {
3279 public:
3280 };
3281
ResetResponse(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3282 ResetResponse::ResetResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3283 bool is_message_owned)
3284 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3285 SharedCtor(arena, is_message_owned);
3286 // @@protoc_insertion_point(arena_constructor:tensorflow.ResetResponse)
3287 }
ResetResponse(const ResetResponse & from)3288 ResetResponse::ResetResponse(const ResetResponse& from)
3289 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3290 ResetResponse* const _this = this; (void)_this;
3291 new (&_impl_) Impl_{
3292 /*decltype(_impl_._cached_size_)*/{}};
3293
3294 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3295 // @@protoc_insertion_point(copy_constructor:tensorflow.ResetResponse)
3296 }
3297
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3298 inline void ResetResponse::SharedCtor(
3299 ::_pb::Arena* arena, bool is_message_owned) {
3300 (void)arena;
3301 (void)is_message_owned;
3302 new (&_impl_) Impl_{
3303 /*decltype(_impl_._cached_size_)*/{}
3304 };
3305 }
3306
~ResetResponse()3307 ResetResponse::~ResetResponse() {
3308 // @@protoc_insertion_point(destructor:tensorflow.ResetResponse)
3309 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3310 (void)arena;
3311 return;
3312 }
3313 SharedDtor();
3314 }
3315
SharedDtor()3316 inline void ResetResponse::SharedDtor() {
3317 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3318 }
3319
SetCachedSize(int size) const3320 void ResetResponse::SetCachedSize(int size) const {
3321 _impl_._cached_size_.Set(size);
3322 }
3323
Clear()3324 void ResetResponse::Clear() {
3325 // @@protoc_insertion_point(message_clear_start:tensorflow.ResetResponse)
3326 ::uint32_t cached_has_bits = 0;
3327 // Prevent compiler warnings about cached_has_bits being unused
3328 (void) cached_has_bits;
3329
3330 _internal_metadata_.Clear<std::string>();
3331 }
3332
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3333 const char* ResetResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3334 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3335 while (!ctx->Done(&ptr)) {
3336 ::uint32_t tag;
3337 ptr = ::_pbi::ReadTag(ptr, &tag);
3338 if ((tag == 0) || ((tag & 7) == 4)) {
3339 CHK_(ptr);
3340 ctx->SetLastTag(tag);
3341 goto message_done;
3342 }
3343 ptr = UnknownFieldParse(
3344 tag,
3345 _internal_metadata_.mutable_unknown_fields<std::string>(),
3346 ptr, ctx);
3347 CHK_(ptr != nullptr);
3348 } // while
3349 message_done:
3350 return ptr;
3351 failure:
3352 ptr = nullptr;
3353 goto message_done;
3354 #undef CHK_
3355 }
3356
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3357 ::uint8_t* ResetResponse::_InternalSerialize(
3358 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3359 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.ResetResponse)
3360 ::uint32_t cached_has_bits = 0;
3361 (void) cached_has_bits;
3362
3363 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3364 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3365 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3366 }
3367 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.ResetResponse)
3368 return target;
3369 }
3370
ByteSizeLong() const3371 size_t ResetResponse::ByteSizeLong() const {
3372 // @@protoc_insertion_point(message_byte_size_start:tensorflow.ResetResponse)
3373 size_t total_size = 0;
3374
3375 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3376 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3377 }
3378 int cached_size = ::_pbi::ToCachedSize(total_size);
3379 SetCachedSize(cached_size);
3380 return total_size;
3381 }
3382
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3383 void ResetResponse::CheckTypeAndMergeFrom(
3384 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3385 MergeFrom(*::_pbi::DownCast<const ResetResponse*>(
3386 &from));
3387 }
3388
MergeFrom(const ResetResponse & from)3389 void ResetResponse::MergeFrom(const ResetResponse& from) {
3390 ResetResponse* const _this = this;
3391 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.ResetResponse)
3392 GOOGLE_DCHECK_NE(&from, _this);
3393 ::uint32_t cached_has_bits = 0;
3394 (void) cached_has_bits;
3395
3396 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3397 }
3398
CopyFrom(const ResetResponse & from)3399 void ResetResponse::CopyFrom(const ResetResponse& from) {
3400 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.ResetResponse)
3401 if (&from == this) return;
3402 Clear();
3403 MergeFrom(from);
3404 }
3405
IsInitialized() const3406 bool ResetResponse::IsInitialized() const {
3407 return true;
3408 }
3409
InternalSwap(ResetResponse * other)3410 void ResetResponse::InternalSwap(ResetResponse* other) {
3411 using std::swap;
3412 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3413 }
3414
GetTypeName() const3415 std::string ResetResponse::GetTypeName() const {
3416 return "tensorflow.ResetResponse";
3417 }
3418
3419
3420 // ===================================================================
3421
3422 class ListDevicesRequest::_Internal {
3423 public:
3424 };
3425
ListDevicesRequest(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3426 ListDevicesRequest::ListDevicesRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3427 bool is_message_owned)
3428 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3429 SharedCtor(arena, is_message_owned);
3430 // @@protoc_insertion_point(arena_constructor:tensorflow.ListDevicesRequest)
3431 }
ListDevicesRequest(const ListDevicesRequest & from)3432 ListDevicesRequest::ListDevicesRequest(const ListDevicesRequest& from)
3433 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3434 ListDevicesRequest* const _this = this; (void)_this;
3435 new (&_impl_) Impl_{
3436 decltype(_impl_.session_handle_){}
3437 , /*decltype(_impl_._cached_size_)*/{}};
3438
3439 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3440 _impl_.session_handle_.InitDefault();
3441 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3442 _impl_.session_handle_.Set("", GetArenaForAllocation());
3443 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3444 if (!from._internal_session_handle().empty()) {
3445 _this->_impl_.session_handle_.Set(from._internal_session_handle(),
3446 _this->GetArenaForAllocation());
3447 }
3448 // @@protoc_insertion_point(copy_constructor:tensorflow.ListDevicesRequest)
3449 }
3450
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3451 inline void ListDevicesRequest::SharedCtor(
3452 ::_pb::Arena* arena, bool is_message_owned) {
3453 (void)arena;
3454 (void)is_message_owned;
3455 new (&_impl_) Impl_{
3456 decltype(_impl_.session_handle_){}
3457 , /*decltype(_impl_._cached_size_)*/{}
3458 };
3459 _impl_.session_handle_.InitDefault();
3460 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3461 _impl_.session_handle_.Set("", GetArenaForAllocation());
3462 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3463 }
3464
~ListDevicesRequest()3465 ListDevicesRequest::~ListDevicesRequest() {
3466 // @@protoc_insertion_point(destructor:tensorflow.ListDevicesRequest)
3467 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3468 (void)arena;
3469 return;
3470 }
3471 SharedDtor();
3472 }
3473
SharedDtor()3474 inline void ListDevicesRequest::SharedDtor() {
3475 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3476 _impl_.session_handle_.Destroy();
3477 }
3478
SetCachedSize(int size) const3479 void ListDevicesRequest::SetCachedSize(int size) const {
3480 _impl_._cached_size_.Set(size);
3481 }
3482
Clear()3483 void ListDevicesRequest::Clear() {
3484 // @@protoc_insertion_point(message_clear_start:tensorflow.ListDevicesRequest)
3485 ::uint32_t cached_has_bits = 0;
3486 // Prevent compiler warnings about cached_has_bits being unused
3487 (void) cached_has_bits;
3488
3489 _impl_.session_handle_.ClearToEmpty();
3490 _internal_metadata_.Clear<std::string>();
3491 }
3492
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3493 const char* ListDevicesRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3494 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3495 while (!ctx->Done(&ptr)) {
3496 ::uint32_t tag;
3497 ptr = ::_pbi::ReadTag(ptr, &tag);
3498 switch (tag >> 3) {
3499 // string session_handle = 1;
3500 case 1:
3501 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
3502 auto str = _internal_mutable_session_handle();
3503 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
3504 CHK_(ptr);
3505 CHK_(::_pbi::VerifyUTF8(str, nullptr));
3506 } else {
3507 goto handle_unusual;
3508 }
3509 continue;
3510 default:
3511 goto handle_unusual;
3512 } // switch
3513 handle_unusual:
3514 if ((tag == 0) || ((tag & 7) == 4)) {
3515 CHK_(ptr);
3516 ctx->SetLastTag(tag);
3517 goto message_done;
3518 }
3519 ptr = UnknownFieldParse(
3520 tag,
3521 _internal_metadata_.mutable_unknown_fields<std::string>(),
3522 ptr, ctx);
3523 CHK_(ptr != nullptr);
3524 } // while
3525 message_done:
3526 return ptr;
3527 failure:
3528 ptr = nullptr;
3529 goto message_done;
3530 #undef CHK_
3531 }
3532
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3533 ::uint8_t* ListDevicesRequest::_InternalSerialize(
3534 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3535 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.ListDevicesRequest)
3536 ::uint32_t cached_has_bits = 0;
3537 (void) cached_has_bits;
3538
3539 // string session_handle = 1;
3540 if (!this->_internal_session_handle().empty()) {
3541 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
3542 this->_internal_session_handle().data(), static_cast<int>(this->_internal_session_handle().length()),
3543 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
3544 "tensorflow.ListDevicesRequest.session_handle");
3545 target = stream->WriteStringMaybeAliased(
3546 1, this->_internal_session_handle(), target);
3547 }
3548
3549 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3550 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3551 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3552 }
3553 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.ListDevicesRequest)
3554 return target;
3555 }
3556
ByteSizeLong() const3557 size_t ListDevicesRequest::ByteSizeLong() const {
3558 // @@protoc_insertion_point(message_byte_size_start:tensorflow.ListDevicesRequest)
3559 size_t total_size = 0;
3560
3561 ::uint32_t cached_has_bits = 0;
3562 // Prevent compiler warnings about cached_has_bits being unused
3563 (void) cached_has_bits;
3564
3565 // string session_handle = 1;
3566 if (!this->_internal_session_handle().empty()) {
3567 total_size += 1 +
3568 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
3569 this->_internal_session_handle());
3570 }
3571
3572 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3573 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3574 }
3575 int cached_size = ::_pbi::ToCachedSize(total_size);
3576 SetCachedSize(cached_size);
3577 return total_size;
3578 }
3579
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3580 void ListDevicesRequest::CheckTypeAndMergeFrom(
3581 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3582 MergeFrom(*::_pbi::DownCast<const ListDevicesRequest*>(
3583 &from));
3584 }
3585
MergeFrom(const ListDevicesRequest & from)3586 void ListDevicesRequest::MergeFrom(const ListDevicesRequest& from) {
3587 ListDevicesRequest* const _this = this;
3588 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.ListDevicesRequest)
3589 GOOGLE_DCHECK_NE(&from, _this);
3590 ::uint32_t cached_has_bits = 0;
3591 (void) cached_has_bits;
3592
3593 if (!from._internal_session_handle().empty()) {
3594 _this->_internal_set_session_handle(from._internal_session_handle());
3595 }
3596 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3597 }
3598
CopyFrom(const ListDevicesRequest & from)3599 void ListDevicesRequest::CopyFrom(const ListDevicesRequest& from) {
3600 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.ListDevicesRequest)
3601 if (&from == this) return;
3602 Clear();
3603 MergeFrom(from);
3604 }
3605
IsInitialized() const3606 bool ListDevicesRequest::IsInitialized() const {
3607 return true;
3608 }
3609
InternalSwap(ListDevicesRequest * other)3610 void ListDevicesRequest::InternalSwap(ListDevicesRequest* other) {
3611 using std::swap;
3612 auto* lhs_arena = GetArenaForAllocation();
3613 auto* rhs_arena = other->GetArenaForAllocation();
3614 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3615 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
3616 &_impl_.session_handle_, lhs_arena,
3617 &other->_impl_.session_handle_, rhs_arena
3618 );
3619 }
3620
GetTypeName() const3621 std::string ListDevicesRequest::GetTypeName() const {
3622 return "tensorflow.ListDevicesRequest";
3623 }
3624
3625
3626 // ===================================================================
3627
3628 class ListDevicesResponse::_Internal {
3629 public:
3630 };
3631
clear_local_device()3632 void ListDevicesResponse::clear_local_device() {
3633 _impl_.local_device_.Clear();
3634 }
clear_remote_device()3635 void ListDevicesResponse::clear_remote_device() {
3636 _impl_.remote_device_.Clear();
3637 }
ListDevicesResponse(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3638 ListDevicesResponse::ListDevicesResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3639 bool is_message_owned)
3640 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3641 SharedCtor(arena, is_message_owned);
3642 // @@protoc_insertion_point(arena_constructor:tensorflow.ListDevicesResponse)
3643 }
ListDevicesResponse(const ListDevicesResponse & from)3644 ListDevicesResponse::ListDevicesResponse(const ListDevicesResponse& from)
3645 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3646 ListDevicesResponse* const _this = this; (void)_this;
3647 new (&_impl_) Impl_{
3648 decltype(_impl_.local_device_){from._impl_.local_device_}
3649 , decltype(_impl_.remote_device_){from._impl_.remote_device_}
3650 , /*decltype(_impl_._cached_size_)*/{}};
3651
3652 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3653 // @@protoc_insertion_point(copy_constructor:tensorflow.ListDevicesResponse)
3654 }
3655
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3656 inline void ListDevicesResponse::SharedCtor(
3657 ::_pb::Arena* arena, bool is_message_owned) {
3658 (void)arena;
3659 (void)is_message_owned;
3660 new (&_impl_) Impl_{
3661 decltype(_impl_.local_device_){arena}
3662 , decltype(_impl_.remote_device_){arena}
3663 , /*decltype(_impl_._cached_size_)*/{}
3664 };
3665 }
3666
~ListDevicesResponse()3667 ListDevicesResponse::~ListDevicesResponse() {
3668 // @@protoc_insertion_point(destructor:tensorflow.ListDevicesResponse)
3669 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3670 (void)arena;
3671 return;
3672 }
3673 SharedDtor();
3674 }
3675
SharedDtor()3676 inline void ListDevicesResponse::SharedDtor() {
3677 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3678 _impl_.local_device_.~RepeatedPtrField();
3679 _impl_.remote_device_.~RepeatedPtrField();
3680 }
3681
SetCachedSize(int size) const3682 void ListDevicesResponse::SetCachedSize(int size) const {
3683 _impl_._cached_size_.Set(size);
3684 }
3685
Clear()3686 void ListDevicesResponse::Clear() {
3687 // @@protoc_insertion_point(message_clear_start:tensorflow.ListDevicesResponse)
3688 ::uint32_t cached_has_bits = 0;
3689 // Prevent compiler warnings about cached_has_bits being unused
3690 (void) cached_has_bits;
3691
3692 _impl_.local_device_.Clear();
3693 _impl_.remote_device_.Clear();
3694 _internal_metadata_.Clear<std::string>();
3695 }
3696
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3697 const char* ListDevicesResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3698 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3699 while (!ctx->Done(&ptr)) {
3700 ::uint32_t tag;
3701 ptr = ::_pbi::ReadTag(ptr, &tag);
3702 switch (tag >> 3) {
3703 // repeated .tensorflow.DeviceAttributes local_device = 1;
3704 case 1:
3705 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
3706 ptr -= 1;
3707 do {
3708 ptr += 1;
3709 ptr = ctx->ParseMessage(_internal_add_local_device(), ptr);
3710 CHK_(ptr);
3711 if (!ctx->DataAvailable(ptr)) break;
3712 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
3713 } else {
3714 goto handle_unusual;
3715 }
3716 continue;
3717 // repeated .tensorflow.DeviceAttributes remote_device = 2;
3718 case 2:
3719 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
3720 ptr -= 1;
3721 do {
3722 ptr += 1;
3723 ptr = ctx->ParseMessage(_internal_add_remote_device(), ptr);
3724 CHK_(ptr);
3725 if (!ctx->DataAvailable(ptr)) break;
3726 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
3727 } else {
3728 goto handle_unusual;
3729 }
3730 continue;
3731 default:
3732 goto handle_unusual;
3733 } // switch
3734 handle_unusual:
3735 if ((tag == 0) || ((tag & 7) == 4)) {
3736 CHK_(ptr);
3737 ctx->SetLastTag(tag);
3738 goto message_done;
3739 }
3740 ptr = UnknownFieldParse(
3741 tag,
3742 _internal_metadata_.mutable_unknown_fields<std::string>(),
3743 ptr, ctx);
3744 CHK_(ptr != nullptr);
3745 } // while
3746 message_done:
3747 return ptr;
3748 failure:
3749 ptr = nullptr;
3750 goto message_done;
3751 #undef CHK_
3752 }
3753
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3754 ::uint8_t* ListDevicesResponse::_InternalSerialize(
3755 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3756 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.ListDevicesResponse)
3757 ::uint32_t cached_has_bits = 0;
3758 (void) cached_has_bits;
3759
3760 // repeated .tensorflow.DeviceAttributes local_device = 1;
3761 for (unsigned i = 0,
3762 n = static_cast<unsigned>(this->_internal_local_device_size()); i < n; i++) {
3763 const auto& repfield = this->_internal_local_device(i);
3764 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
3765 InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
3766 }
3767
3768 // repeated .tensorflow.DeviceAttributes remote_device = 2;
3769 for (unsigned i = 0,
3770 n = static_cast<unsigned>(this->_internal_remote_device_size()); i < n; i++) {
3771 const auto& repfield = this->_internal_remote_device(i);
3772 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
3773 InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
3774 }
3775
3776 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3777 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3778 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3779 }
3780 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.ListDevicesResponse)
3781 return target;
3782 }
3783
ByteSizeLong() const3784 size_t ListDevicesResponse::ByteSizeLong() const {
3785 // @@protoc_insertion_point(message_byte_size_start:tensorflow.ListDevicesResponse)
3786 size_t total_size = 0;
3787
3788 ::uint32_t cached_has_bits = 0;
3789 // Prevent compiler warnings about cached_has_bits being unused
3790 (void) cached_has_bits;
3791
3792 // repeated .tensorflow.DeviceAttributes local_device = 1;
3793 total_size += 1UL * this->_internal_local_device_size();
3794 for (const auto& msg : this->_impl_.local_device_) {
3795 total_size +=
3796 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
3797 }
3798
3799 // repeated .tensorflow.DeviceAttributes remote_device = 2;
3800 total_size += 1UL * this->_internal_remote_device_size();
3801 for (const auto& msg : this->_impl_.remote_device_) {
3802 total_size +=
3803 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
3804 }
3805
3806 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3807 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3808 }
3809 int cached_size = ::_pbi::ToCachedSize(total_size);
3810 SetCachedSize(cached_size);
3811 return total_size;
3812 }
3813
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3814 void ListDevicesResponse::CheckTypeAndMergeFrom(
3815 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3816 MergeFrom(*::_pbi::DownCast<const ListDevicesResponse*>(
3817 &from));
3818 }
3819
MergeFrom(const ListDevicesResponse & from)3820 void ListDevicesResponse::MergeFrom(const ListDevicesResponse& from) {
3821 ListDevicesResponse* const _this = this;
3822 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.ListDevicesResponse)
3823 GOOGLE_DCHECK_NE(&from, _this);
3824 ::uint32_t cached_has_bits = 0;
3825 (void) cached_has_bits;
3826
3827 _this->_impl_.local_device_.MergeFrom(from._impl_.local_device_);
3828 _this->_impl_.remote_device_.MergeFrom(from._impl_.remote_device_);
3829 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3830 }
3831
CopyFrom(const ListDevicesResponse & from)3832 void ListDevicesResponse::CopyFrom(const ListDevicesResponse& from) {
3833 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.ListDevicesResponse)
3834 if (&from == this) return;
3835 Clear();
3836 MergeFrom(from);
3837 }
3838
IsInitialized() const3839 bool ListDevicesResponse::IsInitialized() const {
3840 return true;
3841 }
3842
InternalSwap(ListDevicesResponse * other)3843 void ListDevicesResponse::InternalSwap(ListDevicesResponse* other) {
3844 using std::swap;
3845 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3846 _impl_.local_device_.InternalSwap(&other->_impl_.local_device_);
3847 _impl_.remote_device_.InternalSwap(&other->_impl_.remote_device_);
3848 }
3849
GetTypeName() const3850 std::string ListDevicesResponse::GetTypeName() const {
3851 return "tensorflow.ListDevicesResponse";
3852 }
3853
3854
3855 // ===================================================================
3856
3857 class MakeCallableRequest::_Internal {
3858 public:
3859 static const ::tensorflow::CallableOptions& options(const MakeCallableRequest* msg);
3860 };
3861
3862 const ::tensorflow::CallableOptions&
options(const MakeCallableRequest * msg)3863 MakeCallableRequest::_Internal::options(const MakeCallableRequest* msg) {
3864 return *msg->_impl_.options_;
3865 }
clear_options()3866 void MakeCallableRequest::clear_options() {
3867 if (GetArenaForAllocation() == nullptr && _impl_.options_ != nullptr) {
3868 delete _impl_.options_;
3869 }
3870 _impl_.options_ = nullptr;
3871 }
MakeCallableRequest(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3872 MakeCallableRequest::MakeCallableRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3873 bool is_message_owned)
3874 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3875 SharedCtor(arena, is_message_owned);
3876 // @@protoc_insertion_point(arena_constructor:tensorflow.MakeCallableRequest)
3877 }
MakeCallableRequest(const MakeCallableRequest & from)3878 MakeCallableRequest::MakeCallableRequest(const MakeCallableRequest& from)
3879 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3880 MakeCallableRequest* const _this = this; (void)_this;
3881 new (&_impl_) Impl_{
3882 decltype(_impl_.session_handle_){}
3883 , decltype(_impl_.options_){nullptr}
3884 , decltype(_impl_.request_id_){}
3885 , /*decltype(_impl_._cached_size_)*/{}};
3886
3887 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3888 _impl_.session_handle_.InitDefault();
3889 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3890 _impl_.session_handle_.Set("", GetArenaForAllocation());
3891 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3892 if (!from._internal_session_handle().empty()) {
3893 _this->_impl_.session_handle_.Set(from._internal_session_handle(),
3894 _this->GetArenaForAllocation());
3895 }
3896 if (from._internal_has_options()) {
3897 _this->_impl_.options_ = new ::tensorflow::CallableOptions(*from._impl_.options_);
3898 }
3899 _this->_impl_.request_id_ = from._impl_.request_id_;
3900 // @@protoc_insertion_point(copy_constructor:tensorflow.MakeCallableRequest)
3901 }
3902
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3903 inline void MakeCallableRequest::SharedCtor(
3904 ::_pb::Arena* arena, bool is_message_owned) {
3905 (void)arena;
3906 (void)is_message_owned;
3907 new (&_impl_) Impl_{
3908 decltype(_impl_.session_handle_){}
3909 , decltype(_impl_.options_){nullptr}
3910 , decltype(_impl_.request_id_){::int64_t{0}}
3911 , /*decltype(_impl_._cached_size_)*/{}
3912 };
3913 _impl_.session_handle_.InitDefault();
3914 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3915 _impl_.session_handle_.Set("", GetArenaForAllocation());
3916 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3917 }
3918
~MakeCallableRequest()3919 MakeCallableRequest::~MakeCallableRequest() {
3920 // @@protoc_insertion_point(destructor:tensorflow.MakeCallableRequest)
3921 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3922 (void)arena;
3923 return;
3924 }
3925 SharedDtor();
3926 }
3927
SharedDtor()3928 inline void MakeCallableRequest::SharedDtor() {
3929 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3930 _impl_.session_handle_.Destroy();
3931 if (this != internal_default_instance()) delete _impl_.options_;
3932 }
3933
SetCachedSize(int size) const3934 void MakeCallableRequest::SetCachedSize(int size) const {
3935 _impl_._cached_size_.Set(size);
3936 }
3937
Clear()3938 void MakeCallableRequest::Clear() {
3939 // @@protoc_insertion_point(message_clear_start:tensorflow.MakeCallableRequest)
3940 ::uint32_t cached_has_bits = 0;
3941 // Prevent compiler warnings about cached_has_bits being unused
3942 (void) cached_has_bits;
3943
3944 _impl_.session_handle_.ClearToEmpty();
3945 if (GetArenaForAllocation() == nullptr && _impl_.options_ != nullptr) {
3946 delete _impl_.options_;
3947 }
3948 _impl_.options_ = nullptr;
3949 _impl_.request_id_ = ::int64_t{0};
3950 _internal_metadata_.Clear<std::string>();
3951 }
3952
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3953 const char* MakeCallableRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3954 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3955 while (!ctx->Done(&ptr)) {
3956 ::uint32_t tag;
3957 ptr = ::_pbi::ReadTag(ptr, &tag);
3958 switch (tag >> 3) {
3959 // string session_handle = 1;
3960 case 1:
3961 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
3962 auto str = _internal_mutable_session_handle();
3963 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
3964 CHK_(ptr);
3965 CHK_(::_pbi::VerifyUTF8(str, nullptr));
3966 } else {
3967 goto handle_unusual;
3968 }
3969 continue;
3970 // .tensorflow.CallableOptions options = 2;
3971 case 2:
3972 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
3973 ptr = ctx->ParseMessage(_internal_mutable_options(), ptr);
3974 CHK_(ptr);
3975 } else {
3976 goto handle_unusual;
3977 }
3978 continue;
3979 // int64 request_id = 3;
3980 case 3:
3981 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
3982 _impl_.request_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
3983 CHK_(ptr);
3984 } else {
3985 goto handle_unusual;
3986 }
3987 continue;
3988 default:
3989 goto handle_unusual;
3990 } // switch
3991 handle_unusual:
3992 if ((tag == 0) || ((tag & 7) == 4)) {
3993 CHK_(ptr);
3994 ctx->SetLastTag(tag);
3995 goto message_done;
3996 }
3997 ptr = UnknownFieldParse(
3998 tag,
3999 _internal_metadata_.mutable_unknown_fields<std::string>(),
4000 ptr, ctx);
4001 CHK_(ptr != nullptr);
4002 } // while
4003 message_done:
4004 return ptr;
4005 failure:
4006 ptr = nullptr;
4007 goto message_done;
4008 #undef CHK_
4009 }
4010
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const4011 ::uint8_t* MakeCallableRequest::_InternalSerialize(
4012 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
4013 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.MakeCallableRequest)
4014 ::uint32_t cached_has_bits = 0;
4015 (void) cached_has_bits;
4016
4017 // string session_handle = 1;
4018 if (!this->_internal_session_handle().empty()) {
4019 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
4020 this->_internal_session_handle().data(), static_cast<int>(this->_internal_session_handle().length()),
4021 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
4022 "tensorflow.MakeCallableRequest.session_handle");
4023 target = stream->WriteStringMaybeAliased(
4024 1, this->_internal_session_handle(), target);
4025 }
4026
4027 // .tensorflow.CallableOptions options = 2;
4028 if (this->_internal_has_options()) {
4029 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
4030 InternalWriteMessage(2, _Internal::options(this),
4031 _Internal::options(this).GetCachedSize(), target, stream);
4032 }
4033
4034 // int64 request_id = 3;
4035 if (this->_internal_request_id() != 0) {
4036 target = stream->EnsureSpace(target);
4037 target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_request_id(), target);
4038 }
4039
4040 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4041 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
4042 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
4043 }
4044 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.MakeCallableRequest)
4045 return target;
4046 }
4047
ByteSizeLong() const4048 size_t MakeCallableRequest::ByteSizeLong() const {
4049 // @@protoc_insertion_point(message_byte_size_start:tensorflow.MakeCallableRequest)
4050 size_t total_size = 0;
4051
4052 ::uint32_t cached_has_bits = 0;
4053 // Prevent compiler warnings about cached_has_bits being unused
4054 (void) cached_has_bits;
4055
4056 // string session_handle = 1;
4057 if (!this->_internal_session_handle().empty()) {
4058 total_size += 1 +
4059 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
4060 this->_internal_session_handle());
4061 }
4062
4063 // .tensorflow.CallableOptions options = 2;
4064 if (this->_internal_has_options()) {
4065 total_size += 1 +
4066 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
4067 *_impl_.options_);
4068 }
4069
4070 // int64 request_id = 3;
4071 if (this->_internal_request_id() != 0) {
4072 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_request_id());
4073 }
4074
4075 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4076 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
4077 }
4078 int cached_size = ::_pbi::ToCachedSize(total_size);
4079 SetCachedSize(cached_size);
4080 return total_size;
4081 }
4082
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)4083 void MakeCallableRequest::CheckTypeAndMergeFrom(
4084 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
4085 MergeFrom(*::_pbi::DownCast<const MakeCallableRequest*>(
4086 &from));
4087 }
4088
MergeFrom(const MakeCallableRequest & from)4089 void MakeCallableRequest::MergeFrom(const MakeCallableRequest& from) {
4090 MakeCallableRequest* const _this = this;
4091 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.MakeCallableRequest)
4092 GOOGLE_DCHECK_NE(&from, _this);
4093 ::uint32_t cached_has_bits = 0;
4094 (void) cached_has_bits;
4095
4096 if (!from._internal_session_handle().empty()) {
4097 _this->_internal_set_session_handle(from._internal_session_handle());
4098 }
4099 if (from._internal_has_options()) {
4100 _this->_internal_mutable_options()->::tensorflow::CallableOptions::MergeFrom(
4101 from._internal_options());
4102 }
4103 if (from._internal_request_id() != 0) {
4104 _this->_internal_set_request_id(from._internal_request_id());
4105 }
4106 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4107 }
4108
CopyFrom(const MakeCallableRequest & from)4109 void MakeCallableRequest::CopyFrom(const MakeCallableRequest& from) {
4110 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.MakeCallableRequest)
4111 if (&from == this) return;
4112 Clear();
4113 MergeFrom(from);
4114 }
4115
IsInitialized() const4116 bool MakeCallableRequest::IsInitialized() const {
4117 return true;
4118 }
4119
InternalSwap(MakeCallableRequest * other)4120 void MakeCallableRequest::InternalSwap(MakeCallableRequest* other) {
4121 using std::swap;
4122 auto* lhs_arena = GetArenaForAllocation();
4123 auto* rhs_arena = other->GetArenaForAllocation();
4124 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
4125 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
4126 &_impl_.session_handle_, lhs_arena,
4127 &other->_impl_.session_handle_, rhs_arena
4128 );
4129 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
4130 PROTOBUF_FIELD_OFFSET(MakeCallableRequest, _impl_.request_id_)
4131 + sizeof(MakeCallableRequest::_impl_.request_id_) // NOLINT
4132 - PROTOBUF_FIELD_OFFSET(MakeCallableRequest, _impl_.options_)>(
4133 reinterpret_cast<char*>(&_impl_.options_),
4134 reinterpret_cast<char*>(&other->_impl_.options_));
4135 }
4136
GetTypeName() const4137 std::string MakeCallableRequest::GetTypeName() const {
4138 return "tensorflow.MakeCallableRequest";
4139 }
4140
4141
4142 // ===================================================================
4143
4144 class MakeCallableResponse::_Internal {
4145 public:
4146 };
4147
MakeCallableResponse(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)4148 MakeCallableResponse::MakeCallableResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4149 bool is_message_owned)
4150 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
4151 SharedCtor(arena, is_message_owned);
4152 // @@protoc_insertion_point(arena_constructor:tensorflow.MakeCallableResponse)
4153 }
MakeCallableResponse(const MakeCallableResponse & from)4154 MakeCallableResponse::MakeCallableResponse(const MakeCallableResponse& from)
4155 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
4156 MakeCallableResponse* const _this = this; (void)_this;
4157 new (&_impl_) Impl_{
4158 decltype(_impl_.handle_){}
4159 , /*decltype(_impl_._cached_size_)*/{}};
4160
4161 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4162 _this->_impl_.handle_ = from._impl_.handle_;
4163 // @@protoc_insertion_point(copy_constructor:tensorflow.MakeCallableResponse)
4164 }
4165
SharedCtor(::_pb::Arena * arena,bool is_message_owned)4166 inline void MakeCallableResponse::SharedCtor(
4167 ::_pb::Arena* arena, bool is_message_owned) {
4168 (void)arena;
4169 (void)is_message_owned;
4170 new (&_impl_) Impl_{
4171 decltype(_impl_.handle_){::int64_t{0}}
4172 , /*decltype(_impl_._cached_size_)*/{}
4173 };
4174 }
4175
~MakeCallableResponse()4176 MakeCallableResponse::~MakeCallableResponse() {
4177 // @@protoc_insertion_point(destructor:tensorflow.MakeCallableResponse)
4178 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
4179 (void)arena;
4180 return;
4181 }
4182 SharedDtor();
4183 }
4184
SharedDtor()4185 inline void MakeCallableResponse::SharedDtor() {
4186 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
4187 }
4188
SetCachedSize(int size) const4189 void MakeCallableResponse::SetCachedSize(int size) const {
4190 _impl_._cached_size_.Set(size);
4191 }
4192
Clear()4193 void MakeCallableResponse::Clear() {
4194 // @@protoc_insertion_point(message_clear_start:tensorflow.MakeCallableResponse)
4195 ::uint32_t cached_has_bits = 0;
4196 // Prevent compiler warnings about cached_has_bits being unused
4197 (void) cached_has_bits;
4198
4199 _impl_.handle_ = ::int64_t{0};
4200 _internal_metadata_.Clear<std::string>();
4201 }
4202
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)4203 const char* MakeCallableResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
4204 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
4205 while (!ctx->Done(&ptr)) {
4206 ::uint32_t tag;
4207 ptr = ::_pbi::ReadTag(ptr, &tag);
4208 switch (tag >> 3) {
4209 // int64 handle = 1;
4210 case 1:
4211 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
4212 _impl_.handle_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4213 CHK_(ptr);
4214 } else {
4215 goto handle_unusual;
4216 }
4217 continue;
4218 default:
4219 goto handle_unusual;
4220 } // switch
4221 handle_unusual:
4222 if ((tag == 0) || ((tag & 7) == 4)) {
4223 CHK_(ptr);
4224 ctx->SetLastTag(tag);
4225 goto message_done;
4226 }
4227 ptr = UnknownFieldParse(
4228 tag,
4229 _internal_metadata_.mutable_unknown_fields<std::string>(),
4230 ptr, ctx);
4231 CHK_(ptr != nullptr);
4232 } // while
4233 message_done:
4234 return ptr;
4235 failure:
4236 ptr = nullptr;
4237 goto message_done;
4238 #undef CHK_
4239 }
4240
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const4241 ::uint8_t* MakeCallableResponse::_InternalSerialize(
4242 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
4243 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.MakeCallableResponse)
4244 ::uint32_t cached_has_bits = 0;
4245 (void) cached_has_bits;
4246
4247 // int64 handle = 1;
4248 if (this->_internal_handle() != 0) {
4249 target = stream->EnsureSpace(target);
4250 target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_handle(), target);
4251 }
4252
4253 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4254 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
4255 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
4256 }
4257 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.MakeCallableResponse)
4258 return target;
4259 }
4260
ByteSizeLong() const4261 size_t MakeCallableResponse::ByteSizeLong() const {
4262 // @@protoc_insertion_point(message_byte_size_start:tensorflow.MakeCallableResponse)
4263 size_t total_size = 0;
4264
4265 ::uint32_t cached_has_bits = 0;
4266 // Prevent compiler warnings about cached_has_bits being unused
4267 (void) cached_has_bits;
4268
4269 // int64 handle = 1;
4270 if (this->_internal_handle() != 0) {
4271 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_handle());
4272 }
4273
4274 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4275 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
4276 }
4277 int cached_size = ::_pbi::ToCachedSize(total_size);
4278 SetCachedSize(cached_size);
4279 return total_size;
4280 }
4281
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)4282 void MakeCallableResponse::CheckTypeAndMergeFrom(
4283 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
4284 MergeFrom(*::_pbi::DownCast<const MakeCallableResponse*>(
4285 &from));
4286 }
4287
MergeFrom(const MakeCallableResponse & from)4288 void MakeCallableResponse::MergeFrom(const MakeCallableResponse& from) {
4289 MakeCallableResponse* const _this = this;
4290 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.MakeCallableResponse)
4291 GOOGLE_DCHECK_NE(&from, _this);
4292 ::uint32_t cached_has_bits = 0;
4293 (void) cached_has_bits;
4294
4295 if (from._internal_handle() != 0) {
4296 _this->_internal_set_handle(from._internal_handle());
4297 }
4298 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4299 }
4300
CopyFrom(const MakeCallableResponse & from)4301 void MakeCallableResponse::CopyFrom(const MakeCallableResponse& from) {
4302 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.MakeCallableResponse)
4303 if (&from == this) return;
4304 Clear();
4305 MergeFrom(from);
4306 }
4307
IsInitialized() const4308 bool MakeCallableResponse::IsInitialized() const {
4309 return true;
4310 }
4311
InternalSwap(MakeCallableResponse * other)4312 void MakeCallableResponse::InternalSwap(MakeCallableResponse* other) {
4313 using std::swap;
4314 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
4315 swap(_impl_.handle_, other->_impl_.handle_);
4316 }
4317
GetTypeName() const4318 std::string MakeCallableResponse::GetTypeName() const {
4319 return "tensorflow.MakeCallableResponse";
4320 }
4321
4322
4323 // ===================================================================
4324
4325 class RunCallableRequest::_Internal {
4326 public:
4327 };
4328
clear_feed()4329 void RunCallableRequest::clear_feed() {
4330 _impl_.feed_.Clear();
4331 }
RunCallableRequest(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)4332 RunCallableRequest::RunCallableRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4333 bool is_message_owned)
4334 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
4335 SharedCtor(arena, is_message_owned);
4336 // @@protoc_insertion_point(arena_constructor:tensorflow.RunCallableRequest)
4337 }
RunCallableRequest(const RunCallableRequest & from)4338 RunCallableRequest::RunCallableRequest(const RunCallableRequest& from)
4339 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
4340 RunCallableRequest* const _this = this; (void)_this;
4341 new (&_impl_) Impl_{
4342 decltype(_impl_.feed_){from._impl_.feed_}
4343 , decltype(_impl_.session_handle_){}
4344 , decltype(_impl_.handle_){}
4345 , decltype(_impl_.request_id_){}
4346 , /*decltype(_impl_._cached_size_)*/{}};
4347
4348 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4349 _impl_.session_handle_.InitDefault();
4350 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4351 _impl_.session_handle_.Set("", GetArenaForAllocation());
4352 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4353 if (!from._internal_session_handle().empty()) {
4354 _this->_impl_.session_handle_.Set(from._internal_session_handle(),
4355 _this->GetArenaForAllocation());
4356 }
4357 ::memcpy(&_impl_.handle_, &from._impl_.handle_,
4358 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.request_id_) -
4359 reinterpret_cast<char*>(&_impl_.handle_)) + sizeof(_impl_.request_id_));
4360 // @@protoc_insertion_point(copy_constructor:tensorflow.RunCallableRequest)
4361 }
4362
SharedCtor(::_pb::Arena * arena,bool is_message_owned)4363 inline void RunCallableRequest::SharedCtor(
4364 ::_pb::Arena* arena, bool is_message_owned) {
4365 (void)arena;
4366 (void)is_message_owned;
4367 new (&_impl_) Impl_{
4368 decltype(_impl_.feed_){arena}
4369 , decltype(_impl_.session_handle_){}
4370 , decltype(_impl_.handle_){::int64_t{0}}
4371 , decltype(_impl_.request_id_){::int64_t{0}}
4372 , /*decltype(_impl_._cached_size_)*/{}
4373 };
4374 _impl_.session_handle_.InitDefault();
4375 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4376 _impl_.session_handle_.Set("", GetArenaForAllocation());
4377 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4378 }
4379
~RunCallableRequest()4380 RunCallableRequest::~RunCallableRequest() {
4381 // @@protoc_insertion_point(destructor:tensorflow.RunCallableRequest)
4382 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
4383 (void)arena;
4384 return;
4385 }
4386 SharedDtor();
4387 }
4388
SharedDtor()4389 inline void RunCallableRequest::SharedDtor() {
4390 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
4391 _impl_.feed_.~RepeatedPtrField();
4392 _impl_.session_handle_.Destroy();
4393 }
4394
SetCachedSize(int size) const4395 void RunCallableRequest::SetCachedSize(int size) const {
4396 _impl_._cached_size_.Set(size);
4397 }
4398
Clear()4399 void RunCallableRequest::Clear() {
4400 // @@protoc_insertion_point(message_clear_start:tensorflow.RunCallableRequest)
4401 ::uint32_t cached_has_bits = 0;
4402 // Prevent compiler warnings about cached_has_bits being unused
4403 (void) cached_has_bits;
4404
4405 _impl_.feed_.Clear();
4406 _impl_.session_handle_.ClearToEmpty();
4407 ::memset(&_impl_.handle_, 0, static_cast<size_t>(
4408 reinterpret_cast<char*>(&_impl_.request_id_) -
4409 reinterpret_cast<char*>(&_impl_.handle_)) + sizeof(_impl_.request_id_));
4410 _internal_metadata_.Clear<std::string>();
4411 }
4412
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)4413 const char* RunCallableRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
4414 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
4415 while (!ctx->Done(&ptr)) {
4416 ::uint32_t tag;
4417 ptr = ::_pbi::ReadTag(ptr, &tag);
4418 switch (tag >> 3) {
4419 // string session_handle = 1;
4420 case 1:
4421 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
4422 auto str = _internal_mutable_session_handle();
4423 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
4424 CHK_(ptr);
4425 CHK_(::_pbi::VerifyUTF8(str, nullptr));
4426 } else {
4427 goto handle_unusual;
4428 }
4429 continue;
4430 // int64 handle = 2;
4431 case 2:
4432 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
4433 _impl_.handle_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4434 CHK_(ptr);
4435 } else {
4436 goto handle_unusual;
4437 }
4438 continue;
4439 // repeated .tensorflow.TensorProto feed = 3;
4440 case 3:
4441 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
4442 ptr -= 1;
4443 do {
4444 ptr += 1;
4445 ptr = ctx->ParseMessage(_internal_add_feed(), ptr);
4446 CHK_(ptr);
4447 if (!ctx->DataAvailable(ptr)) break;
4448 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
4449 } else {
4450 goto handle_unusual;
4451 }
4452 continue;
4453 // int64 request_id = 4;
4454 case 4:
4455 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
4456 _impl_.request_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4457 CHK_(ptr);
4458 } else {
4459 goto handle_unusual;
4460 }
4461 continue;
4462 default:
4463 goto handle_unusual;
4464 } // switch
4465 handle_unusual:
4466 if ((tag == 0) || ((tag & 7) == 4)) {
4467 CHK_(ptr);
4468 ctx->SetLastTag(tag);
4469 goto message_done;
4470 }
4471 ptr = UnknownFieldParse(
4472 tag,
4473 _internal_metadata_.mutable_unknown_fields<std::string>(),
4474 ptr, ctx);
4475 CHK_(ptr != nullptr);
4476 } // while
4477 message_done:
4478 return ptr;
4479 failure:
4480 ptr = nullptr;
4481 goto message_done;
4482 #undef CHK_
4483 }
4484
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const4485 ::uint8_t* RunCallableRequest::_InternalSerialize(
4486 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
4487 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.RunCallableRequest)
4488 ::uint32_t cached_has_bits = 0;
4489 (void) cached_has_bits;
4490
4491 // string session_handle = 1;
4492 if (!this->_internal_session_handle().empty()) {
4493 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
4494 this->_internal_session_handle().data(), static_cast<int>(this->_internal_session_handle().length()),
4495 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
4496 "tensorflow.RunCallableRequest.session_handle");
4497 target = stream->WriteStringMaybeAliased(
4498 1, this->_internal_session_handle(), target);
4499 }
4500
4501 // int64 handle = 2;
4502 if (this->_internal_handle() != 0) {
4503 target = stream->EnsureSpace(target);
4504 target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_handle(), target);
4505 }
4506
4507 // repeated .tensorflow.TensorProto feed = 3;
4508 for (unsigned i = 0,
4509 n = static_cast<unsigned>(this->_internal_feed_size()); i < n; i++) {
4510 const auto& repfield = this->_internal_feed(i);
4511 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
4512 InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream);
4513 }
4514
4515 // int64 request_id = 4;
4516 if (this->_internal_request_id() != 0) {
4517 target = stream->EnsureSpace(target);
4518 target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_request_id(), target);
4519 }
4520
4521 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4522 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
4523 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
4524 }
4525 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.RunCallableRequest)
4526 return target;
4527 }
4528
ByteSizeLong() const4529 size_t RunCallableRequest::ByteSizeLong() const {
4530 // @@protoc_insertion_point(message_byte_size_start:tensorflow.RunCallableRequest)
4531 size_t total_size = 0;
4532
4533 ::uint32_t cached_has_bits = 0;
4534 // Prevent compiler warnings about cached_has_bits being unused
4535 (void) cached_has_bits;
4536
4537 // repeated .tensorflow.TensorProto feed = 3;
4538 total_size += 1UL * this->_internal_feed_size();
4539 for (const auto& msg : this->_impl_.feed_) {
4540 total_size +=
4541 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
4542 }
4543
4544 // string session_handle = 1;
4545 if (!this->_internal_session_handle().empty()) {
4546 total_size += 1 +
4547 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
4548 this->_internal_session_handle());
4549 }
4550
4551 // int64 handle = 2;
4552 if (this->_internal_handle() != 0) {
4553 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_handle());
4554 }
4555
4556 // int64 request_id = 4;
4557 if (this->_internal_request_id() != 0) {
4558 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_request_id());
4559 }
4560
4561 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4562 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
4563 }
4564 int cached_size = ::_pbi::ToCachedSize(total_size);
4565 SetCachedSize(cached_size);
4566 return total_size;
4567 }
4568
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)4569 void RunCallableRequest::CheckTypeAndMergeFrom(
4570 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
4571 MergeFrom(*::_pbi::DownCast<const RunCallableRequest*>(
4572 &from));
4573 }
4574
MergeFrom(const RunCallableRequest & from)4575 void RunCallableRequest::MergeFrom(const RunCallableRequest& from) {
4576 RunCallableRequest* const _this = this;
4577 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.RunCallableRequest)
4578 GOOGLE_DCHECK_NE(&from, _this);
4579 ::uint32_t cached_has_bits = 0;
4580 (void) cached_has_bits;
4581
4582 _this->_impl_.feed_.MergeFrom(from._impl_.feed_);
4583 if (!from._internal_session_handle().empty()) {
4584 _this->_internal_set_session_handle(from._internal_session_handle());
4585 }
4586 if (from._internal_handle() != 0) {
4587 _this->_internal_set_handle(from._internal_handle());
4588 }
4589 if (from._internal_request_id() != 0) {
4590 _this->_internal_set_request_id(from._internal_request_id());
4591 }
4592 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4593 }
4594
CopyFrom(const RunCallableRequest & from)4595 void RunCallableRequest::CopyFrom(const RunCallableRequest& from) {
4596 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.RunCallableRequest)
4597 if (&from == this) return;
4598 Clear();
4599 MergeFrom(from);
4600 }
4601
IsInitialized() const4602 bool RunCallableRequest::IsInitialized() const {
4603 return true;
4604 }
4605
InternalSwap(RunCallableRequest * other)4606 void RunCallableRequest::InternalSwap(RunCallableRequest* other) {
4607 using std::swap;
4608 auto* lhs_arena = GetArenaForAllocation();
4609 auto* rhs_arena = other->GetArenaForAllocation();
4610 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
4611 _impl_.feed_.InternalSwap(&other->_impl_.feed_);
4612 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
4613 &_impl_.session_handle_, lhs_arena,
4614 &other->_impl_.session_handle_, rhs_arena
4615 );
4616 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
4617 PROTOBUF_FIELD_OFFSET(RunCallableRequest, _impl_.request_id_)
4618 + sizeof(RunCallableRequest::_impl_.request_id_) // NOLINT
4619 - PROTOBUF_FIELD_OFFSET(RunCallableRequest, _impl_.handle_)>(
4620 reinterpret_cast<char*>(&_impl_.handle_),
4621 reinterpret_cast<char*>(&other->_impl_.handle_));
4622 }
4623
GetTypeName() const4624 std::string RunCallableRequest::GetTypeName() const {
4625 return "tensorflow.RunCallableRequest";
4626 }
4627
4628
4629 // ===================================================================
4630
4631 class RunCallableResponse::_Internal {
4632 public:
4633 static const ::tensorflow::RunMetadata& metadata(const RunCallableResponse* msg);
4634 };
4635
4636 const ::tensorflow::RunMetadata&
metadata(const RunCallableResponse * msg)4637 RunCallableResponse::_Internal::metadata(const RunCallableResponse* msg) {
4638 return *msg->_impl_.metadata_;
4639 }
clear_fetch()4640 void RunCallableResponse::clear_fetch() {
4641 _impl_.fetch_.Clear();
4642 }
clear_metadata()4643 void RunCallableResponse::clear_metadata() {
4644 if (GetArenaForAllocation() == nullptr && _impl_.metadata_ != nullptr) {
4645 delete _impl_.metadata_;
4646 }
4647 _impl_.metadata_ = nullptr;
4648 }
RunCallableResponse(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)4649 RunCallableResponse::RunCallableResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4650 bool is_message_owned)
4651 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
4652 SharedCtor(arena, is_message_owned);
4653 // @@protoc_insertion_point(arena_constructor:tensorflow.RunCallableResponse)
4654 }
RunCallableResponse(const RunCallableResponse & from)4655 RunCallableResponse::RunCallableResponse(const RunCallableResponse& from)
4656 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
4657 RunCallableResponse* const _this = this; (void)_this;
4658 new (&_impl_) Impl_{
4659 decltype(_impl_.fetch_){from._impl_.fetch_}
4660 , decltype(_impl_.metadata_){nullptr}
4661 , /*decltype(_impl_._cached_size_)*/{}};
4662
4663 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4664 if (from._internal_has_metadata()) {
4665 _this->_impl_.metadata_ = new ::tensorflow::RunMetadata(*from._impl_.metadata_);
4666 }
4667 // @@protoc_insertion_point(copy_constructor:tensorflow.RunCallableResponse)
4668 }
4669
SharedCtor(::_pb::Arena * arena,bool is_message_owned)4670 inline void RunCallableResponse::SharedCtor(
4671 ::_pb::Arena* arena, bool is_message_owned) {
4672 (void)arena;
4673 (void)is_message_owned;
4674 new (&_impl_) Impl_{
4675 decltype(_impl_.fetch_){arena}
4676 , decltype(_impl_.metadata_){nullptr}
4677 , /*decltype(_impl_._cached_size_)*/{}
4678 };
4679 }
4680
~RunCallableResponse()4681 RunCallableResponse::~RunCallableResponse() {
4682 // @@protoc_insertion_point(destructor:tensorflow.RunCallableResponse)
4683 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
4684 (void)arena;
4685 return;
4686 }
4687 SharedDtor();
4688 }
4689
SharedDtor()4690 inline void RunCallableResponse::SharedDtor() {
4691 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
4692 _impl_.fetch_.~RepeatedPtrField();
4693 if (this != internal_default_instance()) delete _impl_.metadata_;
4694 }
4695
SetCachedSize(int size) const4696 void RunCallableResponse::SetCachedSize(int size) const {
4697 _impl_._cached_size_.Set(size);
4698 }
4699
Clear()4700 void RunCallableResponse::Clear() {
4701 // @@protoc_insertion_point(message_clear_start:tensorflow.RunCallableResponse)
4702 ::uint32_t cached_has_bits = 0;
4703 // Prevent compiler warnings about cached_has_bits being unused
4704 (void) cached_has_bits;
4705
4706 _impl_.fetch_.Clear();
4707 if (GetArenaForAllocation() == nullptr && _impl_.metadata_ != nullptr) {
4708 delete _impl_.metadata_;
4709 }
4710 _impl_.metadata_ = nullptr;
4711 _internal_metadata_.Clear<std::string>();
4712 }
4713
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)4714 const char* RunCallableResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
4715 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
4716 while (!ctx->Done(&ptr)) {
4717 ::uint32_t tag;
4718 ptr = ::_pbi::ReadTag(ptr, &tag);
4719 switch (tag >> 3) {
4720 // repeated .tensorflow.TensorProto fetch = 1;
4721 case 1:
4722 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
4723 ptr -= 1;
4724 do {
4725 ptr += 1;
4726 ptr = ctx->ParseMessage(_internal_add_fetch(), ptr);
4727 CHK_(ptr);
4728 if (!ctx->DataAvailable(ptr)) break;
4729 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
4730 } else {
4731 goto handle_unusual;
4732 }
4733 continue;
4734 // .tensorflow.RunMetadata metadata = 2;
4735 case 2:
4736 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
4737 ptr = ctx->ParseMessage(_internal_mutable_metadata(), ptr);
4738 CHK_(ptr);
4739 } else {
4740 goto handle_unusual;
4741 }
4742 continue;
4743 default:
4744 goto handle_unusual;
4745 } // switch
4746 handle_unusual:
4747 if ((tag == 0) || ((tag & 7) == 4)) {
4748 CHK_(ptr);
4749 ctx->SetLastTag(tag);
4750 goto message_done;
4751 }
4752 ptr = UnknownFieldParse(
4753 tag,
4754 _internal_metadata_.mutable_unknown_fields<std::string>(),
4755 ptr, ctx);
4756 CHK_(ptr != nullptr);
4757 } // while
4758 message_done:
4759 return ptr;
4760 failure:
4761 ptr = nullptr;
4762 goto message_done;
4763 #undef CHK_
4764 }
4765
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const4766 ::uint8_t* RunCallableResponse::_InternalSerialize(
4767 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
4768 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.RunCallableResponse)
4769 ::uint32_t cached_has_bits = 0;
4770 (void) cached_has_bits;
4771
4772 // repeated .tensorflow.TensorProto fetch = 1;
4773 for (unsigned i = 0,
4774 n = static_cast<unsigned>(this->_internal_fetch_size()); i < n; i++) {
4775 const auto& repfield = this->_internal_fetch(i);
4776 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
4777 InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
4778 }
4779
4780 // .tensorflow.RunMetadata metadata = 2;
4781 if (this->_internal_has_metadata()) {
4782 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
4783 InternalWriteMessage(2, _Internal::metadata(this),
4784 _Internal::metadata(this).GetCachedSize(), target, stream);
4785 }
4786
4787 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4788 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
4789 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
4790 }
4791 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.RunCallableResponse)
4792 return target;
4793 }
4794
ByteSizeLong() const4795 size_t RunCallableResponse::ByteSizeLong() const {
4796 // @@protoc_insertion_point(message_byte_size_start:tensorflow.RunCallableResponse)
4797 size_t total_size = 0;
4798
4799 ::uint32_t cached_has_bits = 0;
4800 // Prevent compiler warnings about cached_has_bits being unused
4801 (void) cached_has_bits;
4802
4803 // repeated .tensorflow.TensorProto fetch = 1;
4804 total_size += 1UL * this->_internal_fetch_size();
4805 for (const auto& msg : this->_impl_.fetch_) {
4806 total_size +=
4807 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
4808 }
4809
4810 // .tensorflow.RunMetadata metadata = 2;
4811 if (this->_internal_has_metadata()) {
4812 total_size += 1 +
4813 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
4814 *_impl_.metadata_);
4815 }
4816
4817 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4818 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
4819 }
4820 int cached_size = ::_pbi::ToCachedSize(total_size);
4821 SetCachedSize(cached_size);
4822 return total_size;
4823 }
4824
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)4825 void RunCallableResponse::CheckTypeAndMergeFrom(
4826 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
4827 MergeFrom(*::_pbi::DownCast<const RunCallableResponse*>(
4828 &from));
4829 }
4830
MergeFrom(const RunCallableResponse & from)4831 void RunCallableResponse::MergeFrom(const RunCallableResponse& from) {
4832 RunCallableResponse* const _this = this;
4833 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.RunCallableResponse)
4834 GOOGLE_DCHECK_NE(&from, _this);
4835 ::uint32_t cached_has_bits = 0;
4836 (void) cached_has_bits;
4837
4838 _this->_impl_.fetch_.MergeFrom(from._impl_.fetch_);
4839 if (from._internal_has_metadata()) {
4840 _this->_internal_mutable_metadata()->::tensorflow::RunMetadata::MergeFrom(
4841 from._internal_metadata());
4842 }
4843 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4844 }
4845
CopyFrom(const RunCallableResponse & from)4846 void RunCallableResponse::CopyFrom(const RunCallableResponse& from) {
4847 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.RunCallableResponse)
4848 if (&from == this) return;
4849 Clear();
4850 MergeFrom(from);
4851 }
4852
IsInitialized() const4853 bool RunCallableResponse::IsInitialized() const {
4854 return true;
4855 }
4856
InternalSwap(RunCallableResponse * other)4857 void RunCallableResponse::InternalSwap(RunCallableResponse* other) {
4858 using std::swap;
4859 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
4860 _impl_.fetch_.InternalSwap(&other->_impl_.fetch_);
4861 swap(_impl_.metadata_, other->_impl_.metadata_);
4862 }
4863
GetTypeName() const4864 std::string RunCallableResponse::GetTypeName() const {
4865 return "tensorflow.RunCallableResponse";
4866 }
4867
4868
4869 // ===================================================================
4870
4871 class ReleaseCallableRequest::_Internal {
4872 public:
4873 };
4874
ReleaseCallableRequest(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)4875 ReleaseCallableRequest::ReleaseCallableRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4876 bool is_message_owned)
4877 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
4878 SharedCtor(arena, is_message_owned);
4879 // @@protoc_insertion_point(arena_constructor:tensorflow.ReleaseCallableRequest)
4880 }
ReleaseCallableRequest(const ReleaseCallableRequest & from)4881 ReleaseCallableRequest::ReleaseCallableRequest(const ReleaseCallableRequest& from)
4882 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
4883 ReleaseCallableRequest* const _this = this; (void)_this;
4884 new (&_impl_) Impl_{
4885 decltype(_impl_.session_handle_){}
4886 , decltype(_impl_.handle_){}
4887 , /*decltype(_impl_._cached_size_)*/{}};
4888
4889 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4890 _impl_.session_handle_.InitDefault();
4891 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4892 _impl_.session_handle_.Set("", GetArenaForAllocation());
4893 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4894 if (!from._internal_session_handle().empty()) {
4895 _this->_impl_.session_handle_.Set(from._internal_session_handle(),
4896 _this->GetArenaForAllocation());
4897 }
4898 _this->_impl_.handle_ = from._impl_.handle_;
4899 // @@protoc_insertion_point(copy_constructor:tensorflow.ReleaseCallableRequest)
4900 }
4901
SharedCtor(::_pb::Arena * arena,bool is_message_owned)4902 inline void ReleaseCallableRequest::SharedCtor(
4903 ::_pb::Arena* arena, bool is_message_owned) {
4904 (void)arena;
4905 (void)is_message_owned;
4906 new (&_impl_) Impl_{
4907 decltype(_impl_.session_handle_){}
4908 , decltype(_impl_.handle_){::int64_t{0}}
4909 , /*decltype(_impl_._cached_size_)*/{}
4910 };
4911 _impl_.session_handle_.InitDefault();
4912 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4913 _impl_.session_handle_.Set("", GetArenaForAllocation());
4914 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4915 }
4916
~ReleaseCallableRequest()4917 ReleaseCallableRequest::~ReleaseCallableRequest() {
4918 // @@protoc_insertion_point(destructor:tensorflow.ReleaseCallableRequest)
4919 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
4920 (void)arena;
4921 return;
4922 }
4923 SharedDtor();
4924 }
4925
SharedDtor()4926 inline void ReleaseCallableRequest::SharedDtor() {
4927 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
4928 _impl_.session_handle_.Destroy();
4929 }
4930
SetCachedSize(int size) const4931 void ReleaseCallableRequest::SetCachedSize(int size) const {
4932 _impl_._cached_size_.Set(size);
4933 }
4934
Clear()4935 void ReleaseCallableRequest::Clear() {
4936 // @@protoc_insertion_point(message_clear_start:tensorflow.ReleaseCallableRequest)
4937 ::uint32_t cached_has_bits = 0;
4938 // Prevent compiler warnings about cached_has_bits being unused
4939 (void) cached_has_bits;
4940
4941 _impl_.session_handle_.ClearToEmpty();
4942 _impl_.handle_ = ::int64_t{0};
4943 _internal_metadata_.Clear<std::string>();
4944 }
4945
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)4946 const char* ReleaseCallableRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
4947 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
4948 while (!ctx->Done(&ptr)) {
4949 ::uint32_t tag;
4950 ptr = ::_pbi::ReadTag(ptr, &tag);
4951 switch (tag >> 3) {
4952 // string session_handle = 1;
4953 case 1:
4954 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
4955 auto str = _internal_mutable_session_handle();
4956 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
4957 CHK_(ptr);
4958 CHK_(::_pbi::VerifyUTF8(str, nullptr));
4959 } else {
4960 goto handle_unusual;
4961 }
4962 continue;
4963 // int64 handle = 2;
4964 case 2:
4965 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
4966 _impl_.handle_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4967 CHK_(ptr);
4968 } else {
4969 goto handle_unusual;
4970 }
4971 continue;
4972 default:
4973 goto handle_unusual;
4974 } // switch
4975 handle_unusual:
4976 if ((tag == 0) || ((tag & 7) == 4)) {
4977 CHK_(ptr);
4978 ctx->SetLastTag(tag);
4979 goto message_done;
4980 }
4981 ptr = UnknownFieldParse(
4982 tag,
4983 _internal_metadata_.mutable_unknown_fields<std::string>(),
4984 ptr, ctx);
4985 CHK_(ptr != nullptr);
4986 } // while
4987 message_done:
4988 return ptr;
4989 failure:
4990 ptr = nullptr;
4991 goto message_done;
4992 #undef CHK_
4993 }
4994
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const4995 ::uint8_t* ReleaseCallableRequest::_InternalSerialize(
4996 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
4997 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.ReleaseCallableRequest)
4998 ::uint32_t cached_has_bits = 0;
4999 (void) cached_has_bits;
5000
5001 // string session_handle = 1;
5002 if (!this->_internal_session_handle().empty()) {
5003 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
5004 this->_internal_session_handle().data(), static_cast<int>(this->_internal_session_handle().length()),
5005 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
5006 "tensorflow.ReleaseCallableRequest.session_handle");
5007 target = stream->WriteStringMaybeAliased(
5008 1, this->_internal_session_handle(), target);
5009 }
5010
5011 // int64 handle = 2;
5012 if (this->_internal_handle() != 0) {
5013 target = stream->EnsureSpace(target);
5014 target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_handle(), target);
5015 }
5016
5017 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5018 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
5019 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
5020 }
5021 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.ReleaseCallableRequest)
5022 return target;
5023 }
5024
ByteSizeLong() const5025 size_t ReleaseCallableRequest::ByteSizeLong() const {
5026 // @@protoc_insertion_point(message_byte_size_start:tensorflow.ReleaseCallableRequest)
5027 size_t total_size = 0;
5028
5029 ::uint32_t cached_has_bits = 0;
5030 // Prevent compiler warnings about cached_has_bits being unused
5031 (void) cached_has_bits;
5032
5033 // string session_handle = 1;
5034 if (!this->_internal_session_handle().empty()) {
5035 total_size += 1 +
5036 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
5037 this->_internal_session_handle());
5038 }
5039
5040 // int64 handle = 2;
5041 if (this->_internal_handle() != 0) {
5042 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_handle());
5043 }
5044
5045 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5046 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
5047 }
5048 int cached_size = ::_pbi::ToCachedSize(total_size);
5049 SetCachedSize(cached_size);
5050 return total_size;
5051 }
5052
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)5053 void ReleaseCallableRequest::CheckTypeAndMergeFrom(
5054 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
5055 MergeFrom(*::_pbi::DownCast<const ReleaseCallableRequest*>(
5056 &from));
5057 }
5058
MergeFrom(const ReleaseCallableRequest & from)5059 void ReleaseCallableRequest::MergeFrom(const ReleaseCallableRequest& from) {
5060 ReleaseCallableRequest* const _this = this;
5061 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.ReleaseCallableRequest)
5062 GOOGLE_DCHECK_NE(&from, _this);
5063 ::uint32_t cached_has_bits = 0;
5064 (void) cached_has_bits;
5065
5066 if (!from._internal_session_handle().empty()) {
5067 _this->_internal_set_session_handle(from._internal_session_handle());
5068 }
5069 if (from._internal_handle() != 0) {
5070 _this->_internal_set_handle(from._internal_handle());
5071 }
5072 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5073 }
5074
CopyFrom(const ReleaseCallableRequest & from)5075 void ReleaseCallableRequest::CopyFrom(const ReleaseCallableRequest& from) {
5076 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.ReleaseCallableRequest)
5077 if (&from == this) return;
5078 Clear();
5079 MergeFrom(from);
5080 }
5081
IsInitialized() const5082 bool ReleaseCallableRequest::IsInitialized() const {
5083 return true;
5084 }
5085
InternalSwap(ReleaseCallableRequest * other)5086 void ReleaseCallableRequest::InternalSwap(ReleaseCallableRequest* other) {
5087 using std::swap;
5088 auto* lhs_arena = GetArenaForAllocation();
5089 auto* rhs_arena = other->GetArenaForAllocation();
5090 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
5091 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
5092 &_impl_.session_handle_, lhs_arena,
5093 &other->_impl_.session_handle_, rhs_arena
5094 );
5095 swap(_impl_.handle_, other->_impl_.handle_);
5096 }
5097
GetTypeName() const5098 std::string ReleaseCallableRequest::GetTypeName() const {
5099 return "tensorflow.ReleaseCallableRequest";
5100 }
5101
5102
5103 // ===================================================================
5104
5105 class ReleaseCallableResponse::_Internal {
5106 public:
5107 };
5108
ReleaseCallableResponse(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)5109 ReleaseCallableResponse::ReleaseCallableResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
5110 bool is_message_owned)
5111 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
5112 SharedCtor(arena, is_message_owned);
5113 // @@protoc_insertion_point(arena_constructor:tensorflow.ReleaseCallableResponse)
5114 }
ReleaseCallableResponse(const ReleaseCallableResponse & from)5115 ReleaseCallableResponse::ReleaseCallableResponse(const ReleaseCallableResponse& from)
5116 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
5117 ReleaseCallableResponse* const _this = this; (void)_this;
5118 new (&_impl_) Impl_{
5119 /*decltype(_impl_._cached_size_)*/{}};
5120
5121 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5122 // @@protoc_insertion_point(copy_constructor:tensorflow.ReleaseCallableResponse)
5123 }
5124
SharedCtor(::_pb::Arena * arena,bool is_message_owned)5125 inline void ReleaseCallableResponse::SharedCtor(
5126 ::_pb::Arena* arena, bool is_message_owned) {
5127 (void)arena;
5128 (void)is_message_owned;
5129 new (&_impl_) Impl_{
5130 /*decltype(_impl_._cached_size_)*/{}
5131 };
5132 }
5133
~ReleaseCallableResponse()5134 ReleaseCallableResponse::~ReleaseCallableResponse() {
5135 // @@protoc_insertion_point(destructor:tensorflow.ReleaseCallableResponse)
5136 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
5137 (void)arena;
5138 return;
5139 }
5140 SharedDtor();
5141 }
5142
SharedDtor()5143 inline void ReleaseCallableResponse::SharedDtor() {
5144 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
5145 }
5146
SetCachedSize(int size) const5147 void ReleaseCallableResponse::SetCachedSize(int size) const {
5148 _impl_._cached_size_.Set(size);
5149 }
5150
Clear()5151 void ReleaseCallableResponse::Clear() {
5152 // @@protoc_insertion_point(message_clear_start:tensorflow.ReleaseCallableResponse)
5153 ::uint32_t cached_has_bits = 0;
5154 // Prevent compiler warnings about cached_has_bits being unused
5155 (void) cached_has_bits;
5156
5157 _internal_metadata_.Clear<std::string>();
5158 }
5159
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)5160 const char* ReleaseCallableResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
5161 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
5162 while (!ctx->Done(&ptr)) {
5163 ::uint32_t tag;
5164 ptr = ::_pbi::ReadTag(ptr, &tag);
5165 if ((tag == 0) || ((tag & 7) == 4)) {
5166 CHK_(ptr);
5167 ctx->SetLastTag(tag);
5168 goto message_done;
5169 }
5170 ptr = UnknownFieldParse(
5171 tag,
5172 _internal_metadata_.mutable_unknown_fields<std::string>(),
5173 ptr, ctx);
5174 CHK_(ptr != nullptr);
5175 } // while
5176 message_done:
5177 return ptr;
5178 failure:
5179 ptr = nullptr;
5180 goto message_done;
5181 #undef CHK_
5182 }
5183
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const5184 ::uint8_t* ReleaseCallableResponse::_InternalSerialize(
5185 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
5186 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.ReleaseCallableResponse)
5187 ::uint32_t cached_has_bits = 0;
5188 (void) cached_has_bits;
5189
5190 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5191 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
5192 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
5193 }
5194 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.ReleaseCallableResponse)
5195 return target;
5196 }
5197
ByteSizeLong() const5198 size_t ReleaseCallableResponse::ByteSizeLong() const {
5199 // @@protoc_insertion_point(message_byte_size_start:tensorflow.ReleaseCallableResponse)
5200 size_t total_size = 0;
5201
5202 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5203 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
5204 }
5205 int cached_size = ::_pbi::ToCachedSize(total_size);
5206 SetCachedSize(cached_size);
5207 return total_size;
5208 }
5209
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)5210 void ReleaseCallableResponse::CheckTypeAndMergeFrom(
5211 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
5212 MergeFrom(*::_pbi::DownCast<const ReleaseCallableResponse*>(
5213 &from));
5214 }
5215
MergeFrom(const ReleaseCallableResponse & from)5216 void ReleaseCallableResponse::MergeFrom(const ReleaseCallableResponse& from) {
5217 ReleaseCallableResponse* const _this = this;
5218 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.ReleaseCallableResponse)
5219 GOOGLE_DCHECK_NE(&from, _this);
5220 ::uint32_t cached_has_bits = 0;
5221 (void) cached_has_bits;
5222
5223 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5224 }
5225
CopyFrom(const ReleaseCallableResponse & from)5226 void ReleaseCallableResponse::CopyFrom(const ReleaseCallableResponse& from) {
5227 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.ReleaseCallableResponse)
5228 if (&from == this) return;
5229 Clear();
5230 MergeFrom(from);
5231 }
5232
IsInitialized() const5233 bool ReleaseCallableResponse::IsInitialized() const {
5234 return true;
5235 }
5236
InternalSwap(ReleaseCallableResponse * other)5237 void ReleaseCallableResponse::InternalSwap(ReleaseCallableResponse* other) {
5238 using std::swap;
5239 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
5240 }
5241
GetTypeName() const5242 std::string ReleaseCallableResponse::GetTypeName() const {
5243 return "tensorflow.ReleaseCallableResponse";
5244 }
5245
5246
5247 // @@protoc_insertion_point(namespace_scope)
5248 } // namespace tensorflow
5249 PROTOBUF_NAMESPACE_OPEN
5250 template<> PROTOBUF_NOINLINE ::tensorflow::CreateSessionRequest*
CreateMaybeMessage(Arena * arena)5251 Arena::CreateMaybeMessage< ::tensorflow::CreateSessionRequest >(Arena* arena) {
5252 return Arena::CreateMessageInternal< ::tensorflow::CreateSessionRequest >(arena);
5253 }
5254 template<> PROTOBUF_NOINLINE ::tensorflow::CreateSessionResponse*
CreateMaybeMessage(Arena * arena)5255 Arena::CreateMaybeMessage< ::tensorflow::CreateSessionResponse >(Arena* arena) {
5256 return Arena::CreateMessageInternal< ::tensorflow::CreateSessionResponse >(arena);
5257 }
5258 template<> PROTOBUF_NOINLINE ::tensorflow::ExtendSessionRequest*
CreateMaybeMessage(Arena * arena)5259 Arena::CreateMaybeMessage< ::tensorflow::ExtendSessionRequest >(Arena* arena) {
5260 return Arena::CreateMessageInternal< ::tensorflow::ExtendSessionRequest >(arena);
5261 }
5262 template<> PROTOBUF_NOINLINE ::tensorflow::ExtendSessionResponse*
CreateMaybeMessage(Arena * arena)5263 Arena::CreateMaybeMessage< ::tensorflow::ExtendSessionResponse >(Arena* arena) {
5264 return Arena::CreateMessageInternal< ::tensorflow::ExtendSessionResponse >(arena);
5265 }
5266 template<> PROTOBUF_NOINLINE ::tensorflow::RunStepRequest*
CreateMaybeMessage(Arena * arena)5267 Arena::CreateMaybeMessage< ::tensorflow::RunStepRequest >(Arena* arena) {
5268 return Arena::CreateMessageInternal< ::tensorflow::RunStepRequest >(arena);
5269 }
5270 template<> PROTOBUF_NOINLINE ::tensorflow::RunStepResponse*
CreateMaybeMessage(Arena * arena)5271 Arena::CreateMaybeMessage< ::tensorflow::RunStepResponse >(Arena* arena) {
5272 return Arena::CreateMessageInternal< ::tensorflow::RunStepResponse >(arena);
5273 }
5274 template<> PROTOBUF_NOINLINE ::tensorflow::PartialRunSetupRequest*
CreateMaybeMessage(Arena * arena)5275 Arena::CreateMaybeMessage< ::tensorflow::PartialRunSetupRequest >(Arena* arena) {
5276 return Arena::CreateMessageInternal< ::tensorflow::PartialRunSetupRequest >(arena);
5277 }
5278 template<> PROTOBUF_NOINLINE ::tensorflow::PartialRunSetupResponse*
CreateMaybeMessage(Arena * arena)5279 Arena::CreateMaybeMessage< ::tensorflow::PartialRunSetupResponse >(Arena* arena) {
5280 return Arena::CreateMessageInternal< ::tensorflow::PartialRunSetupResponse >(arena);
5281 }
5282 template<> PROTOBUF_NOINLINE ::tensorflow::CloseSessionRequest*
CreateMaybeMessage(Arena * arena)5283 Arena::CreateMaybeMessage< ::tensorflow::CloseSessionRequest >(Arena* arena) {
5284 return Arena::CreateMessageInternal< ::tensorflow::CloseSessionRequest >(arena);
5285 }
5286 template<> PROTOBUF_NOINLINE ::tensorflow::CloseSessionResponse*
CreateMaybeMessage(Arena * arena)5287 Arena::CreateMaybeMessage< ::tensorflow::CloseSessionResponse >(Arena* arena) {
5288 return Arena::CreateMessageInternal< ::tensorflow::CloseSessionResponse >(arena);
5289 }
5290 template<> PROTOBUF_NOINLINE ::tensorflow::ResetRequest*
CreateMaybeMessage(Arena * arena)5291 Arena::CreateMaybeMessage< ::tensorflow::ResetRequest >(Arena* arena) {
5292 return Arena::CreateMessageInternal< ::tensorflow::ResetRequest >(arena);
5293 }
5294 template<> PROTOBUF_NOINLINE ::tensorflow::ResetResponse*
CreateMaybeMessage(Arena * arena)5295 Arena::CreateMaybeMessage< ::tensorflow::ResetResponse >(Arena* arena) {
5296 return Arena::CreateMessageInternal< ::tensorflow::ResetResponse >(arena);
5297 }
5298 template<> PROTOBUF_NOINLINE ::tensorflow::ListDevicesRequest*
CreateMaybeMessage(Arena * arena)5299 Arena::CreateMaybeMessage< ::tensorflow::ListDevicesRequest >(Arena* arena) {
5300 return Arena::CreateMessageInternal< ::tensorflow::ListDevicesRequest >(arena);
5301 }
5302 template<> PROTOBUF_NOINLINE ::tensorflow::ListDevicesResponse*
CreateMaybeMessage(Arena * arena)5303 Arena::CreateMaybeMessage< ::tensorflow::ListDevicesResponse >(Arena* arena) {
5304 return Arena::CreateMessageInternal< ::tensorflow::ListDevicesResponse >(arena);
5305 }
5306 template<> PROTOBUF_NOINLINE ::tensorflow::MakeCallableRequest*
CreateMaybeMessage(Arena * arena)5307 Arena::CreateMaybeMessage< ::tensorflow::MakeCallableRequest >(Arena* arena) {
5308 return Arena::CreateMessageInternal< ::tensorflow::MakeCallableRequest >(arena);
5309 }
5310 template<> PROTOBUF_NOINLINE ::tensorflow::MakeCallableResponse*
CreateMaybeMessage(Arena * arena)5311 Arena::CreateMaybeMessage< ::tensorflow::MakeCallableResponse >(Arena* arena) {
5312 return Arena::CreateMessageInternal< ::tensorflow::MakeCallableResponse >(arena);
5313 }
5314 template<> PROTOBUF_NOINLINE ::tensorflow::RunCallableRequest*
CreateMaybeMessage(Arena * arena)5315 Arena::CreateMaybeMessage< ::tensorflow::RunCallableRequest >(Arena* arena) {
5316 return Arena::CreateMessageInternal< ::tensorflow::RunCallableRequest >(arena);
5317 }
5318 template<> PROTOBUF_NOINLINE ::tensorflow::RunCallableResponse*
CreateMaybeMessage(Arena * arena)5319 Arena::CreateMaybeMessage< ::tensorflow::RunCallableResponse >(Arena* arena) {
5320 return Arena::CreateMessageInternal< ::tensorflow::RunCallableResponse >(arena);
5321 }
5322 template<> PROTOBUF_NOINLINE ::tensorflow::ReleaseCallableRequest*
CreateMaybeMessage(Arena * arena)5323 Arena::CreateMaybeMessage< ::tensorflow::ReleaseCallableRequest >(Arena* arena) {
5324 return Arena::CreateMessageInternal< ::tensorflow::ReleaseCallableRequest >(arena);
5325 }
5326 template<> PROTOBUF_NOINLINE ::tensorflow::ReleaseCallableResponse*
CreateMaybeMessage(Arena * arena)5327 Arena::CreateMaybeMessage< ::tensorflow::ReleaseCallableResponse >(Arena* arena) {
5328 return Arena::CreateMessageInternal< ::tensorflow::ReleaseCallableResponse >(arena);
5329 }
5330 PROTOBUF_NAMESPACE_CLOSE
5331
5332 // @@protoc_insertion_point(global_scope)
5333 #include <google/protobuf/port_undef.inc>
5334