1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: tensorflow/core/protobuf/coordination_service.proto
3
4 #include "tensorflow/core/protobuf/coordination_service.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 {
CoordinatedTask(::_pbi::ConstantInitialized)22 PROTOBUF_CONSTEXPR CoordinatedTask::CoordinatedTask(
23 ::_pbi::ConstantInitialized): _impl_{
24 /*decltype(_impl_.job_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
25 , /*decltype(_impl_.task_id_)*/0
26 , /*decltype(_impl_._cached_size_)*/{}} {}
27 struct CoordinatedTaskDefaultTypeInternal {
CoordinatedTaskDefaultTypeInternaltensorflow::CoordinatedTaskDefaultTypeInternal28 PROTOBUF_CONSTEXPR CoordinatedTaskDefaultTypeInternal()
29 : _instance(::_pbi::ConstantInitialized{}) {}
~CoordinatedTaskDefaultTypeInternaltensorflow::CoordinatedTaskDefaultTypeInternal30 ~CoordinatedTaskDefaultTypeInternal() {}
31 union { // NOLINT(misc-non-private-member-variables-in-classes)
32 CoordinatedTask _instance;
33 };
34 };
35 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CoordinatedTaskDefaultTypeInternal _CoordinatedTask_default_instance_;
CoordinationServiceError(::_pbi::ConstantInitialized)36 PROTOBUF_CONSTEXPR CoordinationServiceError::CoordinationServiceError(
37 ::_pbi::ConstantInitialized): _impl_{
38 /*decltype(_impl_.source_task_)*/nullptr
39 , /*decltype(_impl_.is_reported_error_)*/false
40 , /*decltype(_impl_._cached_size_)*/{}} {}
41 struct CoordinationServiceErrorDefaultTypeInternal {
CoordinationServiceErrorDefaultTypeInternaltensorflow::CoordinationServiceErrorDefaultTypeInternal42 PROTOBUF_CONSTEXPR CoordinationServiceErrorDefaultTypeInternal()
43 : _instance(::_pbi::ConstantInitialized{}) {}
~CoordinationServiceErrorDefaultTypeInternaltensorflow::CoordinationServiceErrorDefaultTypeInternal44 ~CoordinationServiceErrorDefaultTypeInternal() {}
45 union { // NOLINT(misc-non-private-member-variables-in-classes)
46 CoordinationServiceError _instance;
47 };
48 };
49 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CoordinationServiceErrorDefaultTypeInternal _CoordinationServiceError_default_instance_;
TfDeviceList(::_pbi::ConstantInitialized)50 PROTOBUF_CONSTEXPR TfDeviceList::TfDeviceList(
51 ::_pbi::ConstantInitialized): _impl_{
52 /*decltype(_impl_.devices_)*/{}
53 , /*decltype(_impl_._cached_size_)*/{}} {}
54 struct TfDeviceListDefaultTypeInternal {
TfDeviceListDefaultTypeInternaltensorflow::TfDeviceListDefaultTypeInternal55 PROTOBUF_CONSTEXPR TfDeviceListDefaultTypeInternal()
56 : _instance(::_pbi::ConstantInitialized{}) {}
~TfDeviceListDefaultTypeInternaltensorflow::TfDeviceListDefaultTypeInternal57 ~TfDeviceListDefaultTypeInternal() {}
58 union { // NOLINT(misc-non-private-member-variables-in-classes)
59 TfDeviceList _instance;
60 };
61 };
62 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TfDeviceListDefaultTypeInternal _TfDeviceList_default_instance_;
XlaDeviceList(::_pbi::ConstantInitialized)63 PROTOBUF_CONSTEXPR XlaDeviceList::XlaDeviceList(
64 ::_pbi::ConstantInitialized): _impl_{
65 /*decltype(_impl_.devices_)*/nullptr
66 , /*decltype(_impl_._cached_size_)*/{}} {}
67 struct XlaDeviceListDefaultTypeInternal {
XlaDeviceListDefaultTypeInternaltensorflow::XlaDeviceListDefaultTypeInternal68 PROTOBUF_CONSTEXPR XlaDeviceListDefaultTypeInternal()
69 : _instance(::_pbi::ConstantInitialized{}) {}
~XlaDeviceListDefaultTypeInternaltensorflow::XlaDeviceListDefaultTypeInternal70 ~XlaDeviceListDefaultTypeInternal() {}
71 union { // NOLINT(misc-non-private-member-variables-in-classes)
72 XlaDeviceList _instance;
73 };
74 };
75 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 XlaDeviceListDefaultTypeInternal _XlaDeviceList_default_instance_;
CoordinationServiceDeviceInfo(::_pbi::ConstantInitialized)76 PROTOBUF_CONSTEXPR CoordinationServiceDeviceInfo::CoordinationServiceDeviceInfo(
77 ::_pbi::ConstantInitialized): _impl_{
78 /*decltype(_impl_.type_)*/{}
79 , /*decltype(_impl_._cached_size_)*/{}
80 , /*decltype(_impl_._oneof_case_)*/{}} {}
81 struct CoordinationServiceDeviceInfoDefaultTypeInternal {
CoordinationServiceDeviceInfoDefaultTypeInternaltensorflow::CoordinationServiceDeviceInfoDefaultTypeInternal82 PROTOBUF_CONSTEXPR CoordinationServiceDeviceInfoDefaultTypeInternal()
83 : _instance(::_pbi::ConstantInitialized{}) {}
~CoordinationServiceDeviceInfoDefaultTypeInternaltensorflow::CoordinationServiceDeviceInfoDefaultTypeInternal84 ~CoordinationServiceDeviceInfoDefaultTypeInternal() {}
85 union { // NOLINT(misc-non-private-member-variables-in-classes)
86 CoordinationServiceDeviceInfo _instance;
87 };
88 };
89 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CoordinationServiceDeviceInfoDefaultTypeInternal _CoordinationServiceDeviceInfo_default_instance_;
RegisterTaskRequest(::_pbi::ConstantInitialized)90 PROTOBUF_CONSTEXPR RegisterTaskRequest::RegisterTaskRequest(
91 ::_pbi::ConstantInitialized): _impl_{
92 /*decltype(_impl_.source_task_)*/nullptr
93 , /*decltype(_impl_.incarnation_)*/::uint64_t{0u}
94 , /*decltype(_impl_._cached_size_)*/{}} {}
95 struct RegisterTaskRequestDefaultTypeInternal {
RegisterTaskRequestDefaultTypeInternaltensorflow::RegisterTaskRequestDefaultTypeInternal96 PROTOBUF_CONSTEXPR RegisterTaskRequestDefaultTypeInternal()
97 : _instance(::_pbi::ConstantInitialized{}) {}
~RegisterTaskRequestDefaultTypeInternaltensorflow::RegisterTaskRequestDefaultTypeInternal98 ~RegisterTaskRequestDefaultTypeInternal() {}
99 union { // NOLINT(misc-non-private-member-variables-in-classes)
100 RegisterTaskRequest _instance;
101 };
102 };
103 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RegisterTaskRequestDefaultTypeInternal _RegisterTaskRequest_default_instance_;
RegisterTaskResponse(::_pbi::ConstantInitialized)104 PROTOBUF_CONSTEXPR RegisterTaskResponse::RegisterTaskResponse(
105 ::_pbi::ConstantInitialized): _impl_{
106 /*decltype(_impl_.leader_incarnation_)*/::uint64_t{0u}
107 , /*decltype(_impl_._cached_size_)*/{}} {}
108 struct RegisterTaskResponseDefaultTypeInternal {
RegisterTaskResponseDefaultTypeInternaltensorflow::RegisterTaskResponseDefaultTypeInternal109 PROTOBUF_CONSTEXPR RegisterTaskResponseDefaultTypeInternal()
110 : _instance(::_pbi::ConstantInitialized{}) {}
~RegisterTaskResponseDefaultTypeInternaltensorflow::RegisterTaskResponseDefaultTypeInternal111 ~RegisterTaskResponseDefaultTypeInternal() {}
112 union { // NOLINT(misc-non-private-member-variables-in-classes)
113 RegisterTaskResponse _instance;
114 };
115 };
116 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RegisterTaskResponseDefaultTypeInternal _RegisterTaskResponse_default_instance_;
HeartbeatRequest(::_pbi::ConstantInitialized)117 PROTOBUF_CONSTEXPR HeartbeatRequest::HeartbeatRequest(
118 ::_pbi::ConstantInitialized): _impl_{
119 /*decltype(_impl_.source_task_)*/nullptr
120 , /*decltype(_impl_.incarnation_)*/::uint64_t{0u}
121 , /*decltype(_impl_._cached_size_)*/{}} {}
122 struct HeartbeatRequestDefaultTypeInternal {
HeartbeatRequestDefaultTypeInternaltensorflow::HeartbeatRequestDefaultTypeInternal123 PROTOBUF_CONSTEXPR HeartbeatRequestDefaultTypeInternal()
124 : _instance(::_pbi::ConstantInitialized{}) {}
~HeartbeatRequestDefaultTypeInternaltensorflow::HeartbeatRequestDefaultTypeInternal125 ~HeartbeatRequestDefaultTypeInternal() {}
126 union { // NOLINT(misc-non-private-member-variables-in-classes)
127 HeartbeatRequest _instance;
128 };
129 };
130 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HeartbeatRequestDefaultTypeInternal _HeartbeatRequest_default_instance_;
HeartbeatResponse(::_pbi::ConstantInitialized)131 PROTOBUF_CONSTEXPR HeartbeatResponse::HeartbeatResponse(
132 ::_pbi::ConstantInitialized): _impl_{
133 /*decltype(_impl_.leader_incarnation_)*/::uint64_t{0u}
134 , /*decltype(_impl_._cached_size_)*/{}} {}
135 struct HeartbeatResponseDefaultTypeInternal {
HeartbeatResponseDefaultTypeInternaltensorflow::HeartbeatResponseDefaultTypeInternal136 PROTOBUF_CONSTEXPR HeartbeatResponseDefaultTypeInternal()
137 : _instance(::_pbi::ConstantInitialized{}) {}
~HeartbeatResponseDefaultTypeInternaltensorflow::HeartbeatResponseDefaultTypeInternal138 ~HeartbeatResponseDefaultTypeInternal() {}
139 union { // NOLINT(misc-non-private-member-variables-in-classes)
140 HeartbeatResponse _instance;
141 };
142 };
143 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HeartbeatResponseDefaultTypeInternal _HeartbeatResponse_default_instance_;
WaitForAllTasksRequest(::_pbi::ConstantInitialized)144 PROTOBUF_CONSTEXPR WaitForAllTasksRequest::WaitForAllTasksRequest(
145 ::_pbi::ConstantInitialized): _impl_{
146 /*decltype(_impl_.local_device_info_)*/nullptr
147 , /*decltype(_impl_.source_task_)*/nullptr
148 , /*decltype(_impl_._cached_size_)*/{}} {}
149 struct WaitForAllTasksRequestDefaultTypeInternal {
WaitForAllTasksRequestDefaultTypeInternaltensorflow::WaitForAllTasksRequestDefaultTypeInternal150 PROTOBUF_CONSTEXPR WaitForAllTasksRequestDefaultTypeInternal()
151 : _instance(::_pbi::ConstantInitialized{}) {}
~WaitForAllTasksRequestDefaultTypeInternaltensorflow::WaitForAllTasksRequestDefaultTypeInternal152 ~WaitForAllTasksRequestDefaultTypeInternal() {}
153 union { // NOLINT(misc-non-private-member-variables-in-classes)
154 WaitForAllTasksRequest _instance;
155 };
156 };
157 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WaitForAllTasksRequestDefaultTypeInternal _WaitForAllTasksRequest_default_instance_;
WaitForAllTasksResponse(::_pbi::ConstantInitialized)158 PROTOBUF_CONSTEXPR WaitForAllTasksResponse::WaitForAllTasksResponse(
159 ::_pbi::ConstantInitialized): _impl_{
160 /*decltype(_impl_.cluster_device_info_)*/nullptr
161 , /*decltype(_impl_.leader_incarnation_)*/::uint64_t{0u}
162 , /*decltype(_impl_._cached_size_)*/{}} {}
163 struct WaitForAllTasksResponseDefaultTypeInternal {
WaitForAllTasksResponseDefaultTypeInternaltensorflow::WaitForAllTasksResponseDefaultTypeInternal164 PROTOBUF_CONSTEXPR WaitForAllTasksResponseDefaultTypeInternal()
165 : _instance(::_pbi::ConstantInitialized{}) {}
~WaitForAllTasksResponseDefaultTypeInternaltensorflow::WaitForAllTasksResponseDefaultTypeInternal166 ~WaitForAllTasksResponseDefaultTypeInternal() {}
167 union { // NOLINT(misc-non-private-member-variables-in-classes)
168 WaitForAllTasksResponse _instance;
169 };
170 };
171 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WaitForAllTasksResponseDefaultTypeInternal _WaitForAllTasksResponse_default_instance_;
ShutdownTaskRequest(::_pbi::ConstantInitialized)172 PROTOBUF_CONSTEXPR ShutdownTaskRequest::ShutdownTaskRequest(
173 ::_pbi::ConstantInitialized): _impl_{
174 /*decltype(_impl_.source_task_)*/nullptr
175 , /*decltype(_impl_._cached_size_)*/{}} {}
176 struct ShutdownTaskRequestDefaultTypeInternal {
ShutdownTaskRequestDefaultTypeInternaltensorflow::ShutdownTaskRequestDefaultTypeInternal177 PROTOBUF_CONSTEXPR ShutdownTaskRequestDefaultTypeInternal()
178 : _instance(::_pbi::ConstantInitialized{}) {}
~ShutdownTaskRequestDefaultTypeInternaltensorflow::ShutdownTaskRequestDefaultTypeInternal179 ~ShutdownTaskRequestDefaultTypeInternal() {}
180 union { // NOLINT(misc-non-private-member-variables-in-classes)
181 ShutdownTaskRequest _instance;
182 };
183 };
184 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ShutdownTaskRequestDefaultTypeInternal _ShutdownTaskRequest_default_instance_;
ShutdownTaskResponse(::_pbi::ConstantInitialized)185 PROTOBUF_CONSTEXPR ShutdownTaskResponse::ShutdownTaskResponse(
186 ::_pbi::ConstantInitialized): _impl_{
187 /*decltype(_impl_._cached_size_)*/{}} {}
188 struct ShutdownTaskResponseDefaultTypeInternal {
ShutdownTaskResponseDefaultTypeInternaltensorflow::ShutdownTaskResponseDefaultTypeInternal189 PROTOBUF_CONSTEXPR ShutdownTaskResponseDefaultTypeInternal()
190 : _instance(::_pbi::ConstantInitialized{}) {}
~ShutdownTaskResponseDefaultTypeInternaltensorflow::ShutdownTaskResponseDefaultTypeInternal191 ~ShutdownTaskResponseDefaultTypeInternal() {}
192 union { // NOLINT(misc-non-private-member-variables-in-classes)
193 ShutdownTaskResponse _instance;
194 };
195 };
196 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ShutdownTaskResponseDefaultTypeInternal _ShutdownTaskResponse_default_instance_;
ResetTaskRequest(::_pbi::ConstantInitialized)197 PROTOBUF_CONSTEXPR ResetTaskRequest::ResetTaskRequest(
198 ::_pbi::ConstantInitialized): _impl_{
199 /*decltype(_impl_.source_task_)*/nullptr
200 , /*decltype(_impl_._cached_size_)*/{}} {}
201 struct ResetTaskRequestDefaultTypeInternal {
ResetTaskRequestDefaultTypeInternaltensorflow::ResetTaskRequestDefaultTypeInternal202 PROTOBUF_CONSTEXPR ResetTaskRequestDefaultTypeInternal()
203 : _instance(::_pbi::ConstantInitialized{}) {}
~ResetTaskRequestDefaultTypeInternaltensorflow::ResetTaskRequestDefaultTypeInternal204 ~ResetTaskRequestDefaultTypeInternal() {}
205 union { // NOLINT(misc-non-private-member-variables-in-classes)
206 ResetTaskRequest _instance;
207 };
208 };
209 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ResetTaskRequestDefaultTypeInternal _ResetTaskRequest_default_instance_;
ResetTaskResponse(::_pbi::ConstantInitialized)210 PROTOBUF_CONSTEXPR ResetTaskResponse::ResetTaskResponse(
211 ::_pbi::ConstantInitialized): _impl_{
212 /*decltype(_impl_._cached_size_)*/{}} {}
213 struct ResetTaskResponseDefaultTypeInternal {
ResetTaskResponseDefaultTypeInternaltensorflow::ResetTaskResponseDefaultTypeInternal214 PROTOBUF_CONSTEXPR ResetTaskResponseDefaultTypeInternal()
215 : _instance(::_pbi::ConstantInitialized{}) {}
~ResetTaskResponseDefaultTypeInternaltensorflow::ResetTaskResponseDefaultTypeInternal216 ~ResetTaskResponseDefaultTypeInternal() {}
217 union { // NOLINT(misc-non-private-member-variables-in-classes)
218 ResetTaskResponse _instance;
219 };
220 };
221 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ResetTaskResponseDefaultTypeInternal _ResetTaskResponse_default_instance_;
ReportErrorToTaskRequest(::_pbi::ConstantInitialized)222 PROTOBUF_CONSTEXPR ReportErrorToTaskRequest::ReportErrorToTaskRequest(
223 ::_pbi::ConstantInitialized): _impl_{
224 /*decltype(_impl_.error_message_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
225 , /*decltype(_impl_.error_payload_)*/nullptr
226 , /*decltype(_impl_.error_code_)*/0
227 , /*decltype(_impl_._cached_size_)*/{}} {}
228 struct ReportErrorToTaskRequestDefaultTypeInternal {
ReportErrorToTaskRequestDefaultTypeInternaltensorflow::ReportErrorToTaskRequestDefaultTypeInternal229 PROTOBUF_CONSTEXPR ReportErrorToTaskRequestDefaultTypeInternal()
230 : _instance(::_pbi::ConstantInitialized{}) {}
~ReportErrorToTaskRequestDefaultTypeInternaltensorflow::ReportErrorToTaskRequestDefaultTypeInternal231 ~ReportErrorToTaskRequestDefaultTypeInternal() {}
232 union { // NOLINT(misc-non-private-member-variables-in-classes)
233 ReportErrorToTaskRequest _instance;
234 };
235 };
236 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ReportErrorToTaskRequestDefaultTypeInternal _ReportErrorToTaskRequest_default_instance_;
ReportErrorToTaskResponse(::_pbi::ConstantInitialized)237 PROTOBUF_CONSTEXPR ReportErrorToTaskResponse::ReportErrorToTaskResponse(
238 ::_pbi::ConstantInitialized): _impl_{
239 /*decltype(_impl_._cached_size_)*/{}} {}
240 struct ReportErrorToTaskResponseDefaultTypeInternal {
ReportErrorToTaskResponseDefaultTypeInternaltensorflow::ReportErrorToTaskResponseDefaultTypeInternal241 PROTOBUF_CONSTEXPR ReportErrorToTaskResponseDefaultTypeInternal()
242 : _instance(::_pbi::ConstantInitialized{}) {}
~ReportErrorToTaskResponseDefaultTypeInternaltensorflow::ReportErrorToTaskResponseDefaultTypeInternal243 ~ReportErrorToTaskResponseDefaultTypeInternal() {}
244 union { // NOLINT(misc-non-private-member-variables-in-classes)
245 ReportErrorToTaskResponse _instance;
246 };
247 };
248 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ReportErrorToTaskResponseDefaultTypeInternal _ReportErrorToTaskResponse_default_instance_;
ReportErrorToServiceRequest(::_pbi::ConstantInitialized)249 PROTOBUF_CONSTEXPR ReportErrorToServiceRequest::ReportErrorToServiceRequest(
250 ::_pbi::ConstantInitialized): _impl_{
251 /*decltype(_impl_.error_message_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
252 , /*decltype(_impl_.error_origin_)*/nullptr
253 , /*decltype(_impl_.error_code_)*/0
254 , /*decltype(_impl_._cached_size_)*/{}} {}
255 struct ReportErrorToServiceRequestDefaultTypeInternal {
ReportErrorToServiceRequestDefaultTypeInternaltensorflow::ReportErrorToServiceRequestDefaultTypeInternal256 PROTOBUF_CONSTEXPR ReportErrorToServiceRequestDefaultTypeInternal()
257 : _instance(::_pbi::ConstantInitialized{}) {}
~ReportErrorToServiceRequestDefaultTypeInternaltensorflow::ReportErrorToServiceRequestDefaultTypeInternal258 ~ReportErrorToServiceRequestDefaultTypeInternal() {}
259 union { // NOLINT(misc-non-private-member-variables-in-classes)
260 ReportErrorToServiceRequest _instance;
261 };
262 };
263 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ReportErrorToServiceRequestDefaultTypeInternal _ReportErrorToServiceRequest_default_instance_;
ReportErrorToServiceResponse(::_pbi::ConstantInitialized)264 PROTOBUF_CONSTEXPR ReportErrorToServiceResponse::ReportErrorToServiceResponse(
265 ::_pbi::ConstantInitialized): _impl_{
266 /*decltype(_impl_._cached_size_)*/{}} {}
267 struct ReportErrorToServiceResponseDefaultTypeInternal {
ReportErrorToServiceResponseDefaultTypeInternaltensorflow::ReportErrorToServiceResponseDefaultTypeInternal268 PROTOBUF_CONSTEXPR ReportErrorToServiceResponseDefaultTypeInternal()
269 : _instance(::_pbi::ConstantInitialized{}) {}
~ReportErrorToServiceResponseDefaultTypeInternaltensorflow::ReportErrorToServiceResponseDefaultTypeInternal270 ~ReportErrorToServiceResponseDefaultTypeInternal() {}
271 union { // NOLINT(misc-non-private-member-variables-in-classes)
272 ReportErrorToServiceResponse _instance;
273 };
274 };
275 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ReportErrorToServiceResponseDefaultTypeInternal _ReportErrorToServiceResponse_default_instance_;
KeyValueEntry(::_pbi::ConstantInitialized)276 PROTOBUF_CONSTEXPR KeyValueEntry::KeyValueEntry(
277 ::_pbi::ConstantInitialized): _impl_{
278 /*decltype(_impl_.key_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
279 , /*decltype(_impl_.value_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
280 , /*decltype(_impl_._cached_size_)*/{}} {}
281 struct KeyValueEntryDefaultTypeInternal {
KeyValueEntryDefaultTypeInternaltensorflow::KeyValueEntryDefaultTypeInternal282 PROTOBUF_CONSTEXPR KeyValueEntryDefaultTypeInternal()
283 : _instance(::_pbi::ConstantInitialized{}) {}
~KeyValueEntryDefaultTypeInternaltensorflow::KeyValueEntryDefaultTypeInternal284 ~KeyValueEntryDefaultTypeInternal() {}
285 union { // NOLINT(misc-non-private-member-variables-in-classes)
286 KeyValueEntry _instance;
287 };
288 };
289 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 KeyValueEntryDefaultTypeInternal _KeyValueEntry_default_instance_;
InsertKeyValueRequest(::_pbi::ConstantInitialized)290 PROTOBUF_CONSTEXPR InsertKeyValueRequest::InsertKeyValueRequest(
291 ::_pbi::ConstantInitialized): _impl_{
292 /*decltype(_impl_.kv_)*/nullptr
293 , /*decltype(_impl_._cached_size_)*/{}} {}
294 struct InsertKeyValueRequestDefaultTypeInternal {
InsertKeyValueRequestDefaultTypeInternaltensorflow::InsertKeyValueRequestDefaultTypeInternal295 PROTOBUF_CONSTEXPR InsertKeyValueRequestDefaultTypeInternal()
296 : _instance(::_pbi::ConstantInitialized{}) {}
~InsertKeyValueRequestDefaultTypeInternaltensorflow::InsertKeyValueRequestDefaultTypeInternal297 ~InsertKeyValueRequestDefaultTypeInternal() {}
298 union { // NOLINT(misc-non-private-member-variables-in-classes)
299 InsertKeyValueRequest _instance;
300 };
301 };
302 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 InsertKeyValueRequestDefaultTypeInternal _InsertKeyValueRequest_default_instance_;
InsertKeyValueResponse(::_pbi::ConstantInitialized)303 PROTOBUF_CONSTEXPR InsertKeyValueResponse::InsertKeyValueResponse(
304 ::_pbi::ConstantInitialized): _impl_{
305 /*decltype(_impl_._cached_size_)*/{}} {}
306 struct InsertKeyValueResponseDefaultTypeInternal {
InsertKeyValueResponseDefaultTypeInternaltensorflow::InsertKeyValueResponseDefaultTypeInternal307 PROTOBUF_CONSTEXPR InsertKeyValueResponseDefaultTypeInternal()
308 : _instance(::_pbi::ConstantInitialized{}) {}
~InsertKeyValueResponseDefaultTypeInternaltensorflow::InsertKeyValueResponseDefaultTypeInternal309 ~InsertKeyValueResponseDefaultTypeInternal() {}
310 union { // NOLINT(misc-non-private-member-variables-in-classes)
311 InsertKeyValueResponse _instance;
312 };
313 };
314 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 InsertKeyValueResponseDefaultTypeInternal _InsertKeyValueResponse_default_instance_;
GetKeyValueRequest(::_pbi::ConstantInitialized)315 PROTOBUF_CONSTEXPR GetKeyValueRequest::GetKeyValueRequest(
316 ::_pbi::ConstantInitialized): _impl_{
317 /*decltype(_impl_.key_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
318 , /*decltype(_impl_._cached_size_)*/{}} {}
319 struct GetKeyValueRequestDefaultTypeInternal {
GetKeyValueRequestDefaultTypeInternaltensorflow::GetKeyValueRequestDefaultTypeInternal320 PROTOBUF_CONSTEXPR GetKeyValueRequestDefaultTypeInternal()
321 : _instance(::_pbi::ConstantInitialized{}) {}
~GetKeyValueRequestDefaultTypeInternaltensorflow::GetKeyValueRequestDefaultTypeInternal322 ~GetKeyValueRequestDefaultTypeInternal() {}
323 union { // NOLINT(misc-non-private-member-variables-in-classes)
324 GetKeyValueRequest _instance;
325 };
326 };
327 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetKeyValueRequestDefaultTypeInternal _GetKeyValueRequest_default_instance_;
GetKeyValueResponse(::_pbi::ConstantInitialized)328 PROTOBUF_CONSTEXPR GetKeyValueResponse::GetKeyValueResponse(
329 ::_pbi::ConstantInitialized): _impl_{
330 /*decltype(_impl_.kv_)*/nullptr
331 , /*decltype(_impl_._cached_size_)*/{}} {}
332 struct GetKeyValueResponseDefaultTypeInternal {
GetKeyValueResponseDefaultTypeInternaltensorflow::GetKeyValueResponseDefaultTypeInternal333 PROTOBUF_CONSTEXPR GetKeyValueResponseDefaultTypeInternal()
334 : _instance(::_pbi::ConstantInitialized{}) {}
~GetKeyValueResponseDefaultTypeInternaltensorflow::GetKeyValueResponseDefaultTypeInternal335 ~GetKeyValueResponseDefaultTypeInternal() {}
336 union { // NOLINT(misc-non-private-member-variables-in-classes)
337 GetKeyValueResponse _instance;
338 };
339 };
340 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetKeyValueResponseDefaultTypeInternal _GetKeyValueResponse_default_instance_;
TryGetKeyValueRequest(::_pbi::ConstantInitialized)341 PROTOBUF_CONSTEXPR TryGetKeyValueRequest::TryGetKeyValueRequest(
342 ::_pbi::ConstantInitialized): _impl_{
343 /*decltype(_impl_.key_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
344 , /*decltype(_impl_._cached_size_)*/{}} {}
345 struct TryGetKeyValueRequestDefaultTypeInternal {
TryGetKeyValueRequestDefaultTypeInternaltensorflow::TryGetKeyValueRequestDefaultTypeInternal346 PROTOBUF_CONSTEXPR TryGetKeyValueRequestDefaultTypeInternal()
347 : _instance(::_pbi::ConstantInitialized{}) {}
~TryGetKeyValueRequestDefaultTypeInternaltensorflow::TryGetKeyValueRequestDefaultTypeInternal348 ~TryGetKeyValueRequestDefaultTypeInternal() {}
349 union { // NOLINT(misc-non-private-member-variables-in-classes)
350 TryGetKeyValueRequest _instance;
351 };
352 };
353 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TryGetKeyValueRequestDefaultTypeInternal _TryGetKeyValueRequest_default_instance_;
TryGetKeyValueResponse(::_pbi::ConstantInitialized)354 PROTOBUF_CONSTEXPR TryGetKeyValueResponse::TryGetKeyValueResponse(
355 ::_pbi::ConstantInitialized): _impl_{
356 /*decltype(_impl_.kv_)*/nullptr
357 , /*decltype(_impl_._cached_size_)*/{}} {}
358 struct TryGetKeyValueResponseDefaultTypeInternal {
TryGetKeyValueResponseDefaultTypeInternaltensorflow::TryGetKeyValueResponseDefaultTypeInternal359 PROTOBUF_CONSTEXPR TryGetKeyValueResponseDefaultTypeInternal()
360 : _instance(::_pbi::ConstantInitialized{}) {}
~TryGetKeyValueResponseDefaultTypeInternaltensorflow::TryGetKeyValueResponseDefaultTypeInternal361 ~TryGetKeyValueResponseDefaultTypeInternal() {}
362 union { // NOLINT(misc-non-private-member-variables-in-classes)
363 TryGetKeyValueResponse _instance;
364 };
365 };
366 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TryGetKeyValueResponseDefaultTypeInternal _TryGetKeyValueResponse_default_instance_;
GetKeyValueDirRequest(::_pbi::ConstantInitialized)367 PROTOBUF_CONSTEXPR GetKeyValueDirRequest::GetKeyValueDirRequest(
368 ::_pbi::ConstantInitialized): _impl_{
369 /*decltype(_impl_.directory_key_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
370 , /*decltype(_impl_._cached_size_)*/{}} {}
371 struct GetKeyValueDirRequestDefaultTypeInternal {
GetKeyValueDirRequestDefaultTypeInternaltensorflow::GetKeyValueDirRequestDefaultTypeInternal372 PROTOBUF_CONSTEXPR GetKeyValueDirRequestDefaultTypeInternal()
373 : _instance(::_pbi::ConstantInitialized{}) {}
~GetKeyValueDirRequestDefaultTypeInternaltensorflow::GetKeyValueDirRequestDefaultTypeInternal374 ~GetKeyValueDirRequestDefaultTypeInternal() {}
375 union { // NOLINT(misc-non-private-member-variables-in-classes)
376 GetKeyValueDirRequest _instance;
377 };
378 };
379 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetKeyValueDirRequestDefaultTypeInternal _GetKeyValueDirRequest_default_instance_;
GetKeyValueDirResponse(::_pbi::ConstantInitialized)380 PROTOBUF_CONSTEXPR GetKeyValueDirResponse::GetKeyValueDirResponse(
381 ::_pbi::ConstantInitialized): _impl_{
382 /*decltype(_impl_.kv_)*/{}
383 , /*decltype(_impl_.directory_key_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
384 , /*decltype(_impl_._cached_size_)*/{}} {}
385 struct GetKeyValueDirResponseDefaultTypeInternal {
GetKeyValueDirResponseDefaultTypeInternaltensorflow::GetKeyValueDirResponseDefaultTypeInternal386 PROTOBUF_CONSTEXPR GetKeyValueDirResponseDefaultTypeInternal()
387 : _instance(::_pbi::ConstantInitialized{}) {}
~GetKeyValueDirResponseDefaultTypeInternaltensorflow::GetKeyValueDirResponseDefaultTypeInternal388 ~GetKeyValueDirResponseDefaultTypeInternal() {}
389 union { // NOLINT(misc-non-private-member-variables-in-classes)
390 GetKeyValueDirResponse _instance;
391 };
392 };
393 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetKeyValueDirResponseDefaultTypeInternal _GetKeyValueDirResponse_default_instance_;
DeleteKeyValueRequest(::_pbi::ConstantInitialized)394 PROTOBUF_CONSTEXPR DeleteKeyValueRequest::DeleteKeyValueRequest(
395 ::_pbi::ConstantInitialized): _impl_{
396 /*decltype(_impl_.key_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
397 , /*decltype(_impl_.is_directory_)*/false
398 , /*decltype(_impl_._cached_size_)*/{}} {}
399 struct DeleteKeyValueRequestDefaultTypeInternal {
DeleteKeyValueRequestDefaultTypeInternaltensorflow::DeleteKeyValueRequestDefaultTypeInternal400 PROTOBUF_CONSTEXPR DeleteKeyValueRequestDefaultTypeInternal()
401 : _instance(::_pbi::ConstantInitialized{}) {}
~DeleteKeyValueRequestDefaultTypeInternaltensorflow::DeleteKeyValueRequestDefaultTypeInternal402 ~DeleteKeyValueRequestDefaultTypeInternal() {}
403 union { // NOLINT(misc-non-private-member-variables-in-classes)
404 DeleteKeyValueRequest _instance;
405 };
406 };
407 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeleteKeyValueRequestDefaultTypeInternal _DeleteKeyValueRequest_default_instance_;
DeleteKeyValueResponse(::_pbi::ConstantInitialized)408 PROTOBUF_CONSTEXPR DeleteKeyValueResponse::DeleteKeyValueResponse(
409 ::_pbi::ConstantInitialized): _impl_{
410 /*decltype(_impl_._cached_size_)*/{}} {}
411 struct DeleteKeyValueResponseDefaultTypeInternal {
DeleteKeyValueResponseDefaultTypeInternaltensorflow::DeleteKeyValueResponseDefaultTypeInternal412 PROTOBUF_CONSTEXPR DeleteKeyValueResponseDefaultTypeInternal()
413 : _instance(::_pbi::ConstantInitialized{}) {}
~DeleteKeyValueResponseDefaultTypeInternaltensorflow::DeleteKeyValueResponseDefaultTypeInternal414 ~DeleteKeyValueResponseDefaultTypeInternal() {}
415 union { // NOLINT(misc-non-private-member-variables-in-classes)
416 DeleteKeyValueResponse _instance;
417 };
418 };
419 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeleteKeyValueResponseDefaultTypeInternal _DeleteKeyValueResponse_default_instance_;
BarrierRequest(::_pbi::ConstantInitialized)420 PROTOBUF_CONSTEXPR BarrierRequest::BarrierRequest(
421 ::_pbi::ConstantInitialized): _impl_{
422 /*decltype(_impl_.tasks_)*/{}
423 , /*decltype(_impl_.barrier_id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
424 , /*decltype(_impl_.source_task_)*/nullptr
425 , /*decltype(_impl_.barrier_timeout_in_ms_)*/::int64_t{0}
426 , /*decltype(_impl_._cached_size_)*/{}} {}
427 struct BarrierRequestDefaultTypeInternal {
BarrierRequestDefaultTypeInternaltensorflow::BarrierRequestDefaultTypeInternal428 PROTOBUF_CONSTEXPR BarrierRequestDefaultTypeInternal()
429 : _instance(::_pbi::ConstantInitialized{}) {}
~BarrierRequestDefaultTypeInternaltensorflow::BarrierRequestDefaultTypeInternal430 ~BarrierRequestDefaultTypeInternal() {}
431 union { // NOLINT(misc-non-private-member-variables-in-classes)
432 BarrierRequest _instance;
433 };
434 };
435 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BarrierRequestDefaultTypeInternal _BarrierRequest_default_instance_;
BarrierResponse(::_pbi::ConstantInitialized)436 PROTOBUF_CONSTEXPR BarrierResponse::BarrierResponse(
437 ::_pbi::ConstantInitialized): _impl_{
438 /*decltype(_impl_._cached_size_)*/{}} {}
439 struct BarrierResponseDefaultTypeInternal {
BarrierResponseDefaultTypeInternaltensorflow::BarrierResponseDefaultTypeInternal440 PROTOBUF_CONSTEXPR BarrierResponseDefaultTypeInternal()
441 : _instance(::_pbi::ConstantInitialized{}) {}
~BarrierResponseDefaultTypeInternaltensorflow::BarrierResponseDefaultTypeInternal442 ~BarrierResponseDefaultTypeInternal() {}
443 union { // NOLINT(misc-non-private-member-variables-in-classes)
444 BarrierResponse _instance;
445 };
446 };
447 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BarrierResponseDefaultTypeInternal _BarrierResponse_default_instance_;
CancelBarrierRequest(::_pbi::ConstantInitialized)448 PROTOBUF_CONSTEXPR CancelBarrierRequest::CancelBarrierRequest(
449 ::_pbi::ConstantInitialized): _impl_{
450 /*decltype(_impl_.barrier_id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
451 , /*decltype(_impl_.source_task_)*/nullptr
452 , /*decltype(_impl_._cached_size_)*/{}} {}
453 struct CancelBarrierRequestDefaultTypeInternal {
CancelBarrierRequestDefaultTypeInternaltensorflow::CancelBarrierRequestDefaultTypeInternal454 PROTOBUF_CONSTEXPR CancelBarrierRequestDefaultTypeInternal()
455 : _instance(::_pbi::ConstantInitialized{}) {}
~CancelBarrierRequestDefaultTypeInternaltensorflow::CancelBarrierRequestDefaultTypeInternal456 ~CancelBarrierRequestDefaultTypeInternal() {}
457 union { // NOLINT(misc-non-private-member-variables-in-classes)
458 CancelBarrierRequest _instance;
459 };
460 };
461 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CancelBarrierRequestDefaultTypeInternal _CancelBarrierRequest_default_instance_;
CancelBarrierResponse(::_pbi::ConstantInitialized)462 PROTOBUF_CONSTEXPR CancelBarrierResponse::CancelBarrierResponse(
463 ::_pbi::ConstantInitialized): _impl_{
464 /*decltype(_impl_._cached_size_)*/{}} {}
465 struct CancelBarrierResponseDefaultTypeInternal {
CancelBarrierResponseDefaultTypeInternaltensorflow::CancelBarrierResponseDefaultTypeInternal466 PROTOBUF_CONSTEXPR CancelBarrierResponseDefaultTypeInternal()
467 : _instance(::_pbi::ConstantInitialized{}) {}
~CancelBarrierResponseDefaultTypeInternaltensorflow::CancelBarrierResponseDefaultTypeInternal468 ~CancelBarrierResponseDefaultTypeInternal() {}
469 union { // NOLINT(misc-non-private-member-variables-in-classes)
470 CancelBarrierResponse _instance;
471 };
472 };
473 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CancelBarrierResponseDefaultTypeInternal _CancelBarrierResponse_default_instance_;
474 } // namespace tensorflow
475 namespace tensorflow {
CoordinatedTaskState_IsValid(int value)476 bool CoordinatedTaskState_IsValid(int value) {
477 switch (value) {
478 case 0:
479 case 1:
480 case 2:
481 case 3:
482 case 4:
483 return true;
484 default:
485 return false;
486 }
487 }
488
489 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> CoordinatedTaskState_strings[5] = {};
490
491 static const char CoordinatedTaskState_names[] =
492 "TASKSTATE_CONNECTED"
493 "TASKSTATE_DISCONNECTED"
494 "TASKSTATE_ERROR"
495 "TASKSTATE_UNINITIALIZED"
496 "TASKSTATE_UNSPECIFIED";
497
498 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry CoordinatedTaskState_entries[] = {
499 { {CoordinatedTaskState_names + 0, 19}, 3 },
500 { {CoordinatedTaskState_names + 19, 22}, 2 },
501 { {CoordinatedTaskState_names + 41, 15}, 4 },
502 { {CoordinatedTaskState_names + 56, 23}, 1 },
503 { {CoordinatedTaskState_names + 79, 21}, 0 },
504 };
505
506 static const int CoordinatedTaskState_entries_by_number[] = {
507 4, // 0 -> TASKSTATE_UNSPECIFIED
508 3, // 1 -> TASKSTATE_UNINITIALIZED
509 1, // 2 -> TASKSTATE_DISCONNECTED
510 0, // 3 -> TASKSTATE_CONNECTED
511 2, // 4 -> TASKSTATE_ERROR
512 };
513
CoordinatedTaskState_Name(CoordinatedTaskState value)514 const std::string& CoordinatedTaskState_Name(
515 CoordinatedTaskState value) {
516 static const bool dummy =
517 ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
518 CoordinatedTaskState_entries,
519 CoordinatedTaskState_entries_by_number,
520 5, CoordinatedTaskState_strings);
521 (void) dummy;
522 int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
523 CoordinatedTaskState_entries,
524 CoordinatedTaskState_entries_by_number,
525 5, value);
526 return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
527 CoordinatedTaskState_strings[idx].get();
528 }
CoordinatedTaskState_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,CoordinatedTaskState * value)529 bool CoordinatedTaskState_Parse(
530 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CoordinatedTaskState* value) {
531 int int_value;
532 bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
533 CoordinatedTaskState_entries, 5, name, &int_value);
534 if (success) {
535 *value = static_cast<CoordinatedTaskState>(int_value);
536 }
537 return success;
538 }
539
540 // ===================================================================
541
542 class CoordinatedTask::_Internal {
543 public:
544 };
545
CoordinatedTask(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)546 CoordinatedTask::CoordinatedTask(::PROTOBUF_NAMESPACE_ID::Arena* arena,
547 bool is_message_owned)
548 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
549 SharedCtor(arena, is_message_owned);
550 // @@protoc_insertion_point(arena_constructor:tensorflow.CoordinatedTask)
551 }
CoordinatedTask(const CoordinatedTask & from)552 CoordinatedTask::CoordinatedTask(const CoordinatedTask& from)
553 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
554 CoordinatedTask* const _this = this; (void)_this;
555 new (&_impl_) Impl_{
556 decltype(_impl_.job_name_){}
557 , decltype(_impl_.task_id_){}
558 , /*decltype(_impl_._cached_size_)*/{}};
559
560 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
561 _impl_.job_name_.InitDefault();
562 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
563 _impl_.job_name_.Set("", GetArenaForAllocation());
564 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
565 if (!from._internal_job_name().empty()) {
566 _this->_impl_.job_name_.Set(from._internal_job_name(),
567 _this->GetArenaForAllocation());
568 }
569 _this->_impl_.task_id_ = from._impl_.task_id_;
570 // @@protoc_insertion_point(copy_constructor:tensorflow.CoordinatedTask)
571 }
572
SharedCtor(::_pb::Arena * arena,bool is_message_owned)573 inline void CoordinatedTask::SharedCtor(
574 ::_pb::Arena* arena, bool is_message_owned) {
575 (void)arena;
576 (void)is_message_owned;
577 new (&_impl_) Impl_{
578 decltype(_impl_.job_name_){}
579 , decltype(_impl_.task_id_){0}
580 , /*decltype(_impl_._cached_size_)*/{}
581 };
582 _impl_.job_name_.InitDefault();
583 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
584 _impl_.job_name_.Set("", GetArenaForAllocation());
585 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
586 }
587
~CoordinatedTask()588 CoordinatedTask::~CoordinatedTask() {
589 // @@protoc_insertion_point(destructor:tensorflow.CoordinatedTask)
590 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
591 (void)arena;
592 return;
593 }
594 SharedDtor();
595 }
596
SharedDtor()597 inline void CoordinatedTask::SharedDtor() {
598 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
599 _impl_.job_name_.Destroy();
600 }
601
SetCachedSize(int size) const602 void CoordinatedTask::SetCachedSize(int size) const {
603 _impl_._cached_size_.Set(size);
604 }
605
Clear()606 void CoordinatedTask::Clear() {
607 // @@protoc_insertion_point(message_clear_start:tensorflow.CoordinatedTask)
608 ::uint32_t cached_has_bits = 0;
609 // Prevent compiler warnings about cached_has_bits being unused
610 (void) cached_has_bits;
611
612 _impl_.job_name_.ClearToEmpty();
613 _impl_.task_id_ = 0;
614 _internal_metadata_.Clear<std::string>();
615 }
616
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)617 const char* CoordinatedTask::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
618 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
619 while (!ctx->Done(&ptr)) {
620 ::uint32_t tag;
621 ptr = ::_pbi::ReadTag(ptr, &tag);
622 switch (tag >> 3) {
623 // string job_name = 1;
624 case 1:
625 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
626 auto str = _internal_mutable_job_name();
627 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
628 CHK_(ptr);
629 CHK_(::_pbi::VerifyUTF8(str, nullptr));
630 } else {
631 goto handle_unusual;
632 }
633 continue;
634 // int32 task_id = 2;
635 case 2:
636 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
637 _impl_.task_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
638 CHK_(ptr);
639 } else {
640 goto handle_unusual;
641 }
642 continue;
643 default:
644 goto handle_unusual;
645 } // switch
646 handle_unusual:
647 if ((tag == 0) || ((tag & 7) == 4)) {
648 CHK_(ptr);
649 ctx->SetLastTag(tag);
650 goto message_done;
651 }
652 ptr = UnknownFieldParse(
653 tag,
654 _internal_metadata_.mutable_unknown_fields<std::string>(),
655 ptr, ctx);
656 CHK_(ptr != nullptr);
657 } // while
658 message_done:
659 return ptr;
660 failure:
661 ptr = nullptr;
662 goto message_done;
663 #undef CHK_
664 }
665
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const666 ::uint8_t* CoordinatedTask::_InternalSerialize(
667 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
668 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.CoordinatedTask)
669 ::uint32_t cached_has_bits = 0;
670 (void) cached_has_bits;
671
672 // string job_name = 1;
673 if (!this->_internal_job_name().empty()) {
674 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
675 this->_internal_job_name().data(), static_cast<int>(this->_internal_job_name().length()),
676 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
677 "tensorflow.CoordinatedTask.job_name");
678 target = stream->WriteStringMaybeAliased(
679 1, this->_internal_job_name(), target);
680 }
681
682 // int32 task_id = 2;
683 if (this->_internal_task_id() != 0) {
684 target = stream->EnsureSpace(target);
685 target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_task_id(), target);
686 }
687
688 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
689 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
690 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
691 }
692 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.CoordinatedTask)
693 return target;
694 }
695
ByteSizeLong() const696 size_t CoordinatedTask::ByteSizeLong() const {
697 // @@protoc_insertion_point(message_byte_size_start:tensorflow.CoordinatedTask)
698 size_t total_size = 0;
699
700 ::uint32_t cached_has_bits = 0;
701 // Prevent compiler warnings about cached_has_bits being unused
702 (void) cached_has_bits;
703
704 // string job_name = 1;
705 if (!this->_internal_job_name().empty()) {
706 total_size += 1 +
707 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
708 this->_internal_job_name());
709 }
710
711 // int32 task_id = 2;
712 if (this->_internal_task_id() != 0) {
713 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_task_id());
714 }
715
716 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
717 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
718 }
719 int cached_size = ::_pbi::ToCachedSize(total_size);
720 SetCachedSize(cached_size);
721 return total_size;
722 }
723
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)724 void CoordinatedTask::CheckTypeAndMergeFrom(
725 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
726 MergeFrom(*::_pbi::DownCast<const CoordinatedTask*>(
727 &from));
728 }
729
MergeFrom(const CoordinatedTask & from)730 void CoordinatedTask::MergeFrom(const CoordinatedTask& from) {
731 CoordinatedTask* const _this = this;
732 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.CoordinatedTask)
733 GOOGLE_DCHECK_NE(&from, _this);
734 ::uint32_t cached_has_bits = 0;
735 (void) cached_has_bits;
736
737 if (!from._internal_job_name().empty()) {
738 _this->_internal_set_job_name(from._internal_job_name());
739 }
740 if (from._internal_task_id() != 0) {
741 _this->_internal_set_task_id(from._internal_task_id());
742 }
743 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
744 }
745
CopyFrom(const CoordinatedTask & from)746 void CoordinatedTask::CopyFrom(const CoordinatedTask& from) {
747 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.CoordinatedTask)
748 if (&from == this) return;
749 Clear();
750 MergeFrom(from);
751 }
752
IsInitialized() const753 bool CoordinatedTask::IsInitialized() const {
754 return true;
755 }
756
InternalSwap(CoordinatedTask * other)757 void CoordinatedTask::InternalSwap(CoordinatedTask* other) {
758 using std::swap;
759 auto* lhs_arena = GetArenaForAllocation();
760 auto* rhs_arena = other->GetArenaForAllocation();
761 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
762 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
763 &_impl_.job_name_, lhs_arena,
764 &other->_impl_.job_name_, rhs_arena
765 );
766 swap(_impl_.task_id_, other->_impl_.task_id_);
767 }
768
GetTypeName() const769 std::string CoordinatedTask::GetTypeName() const {
770 return "tensorflow.CoordinatedTask";
771 }
772
773
774 // ===================================================================
775
776 class CoordinationServiceError::_Internal {
777 public:
778 static const ::tensorflow::CoordinatedTask& source_task(const CoordinationServiceError* msg);
779 };
780
781 const ::tensorflow::CoordinatedTask&
source_task(const CoordinationServiceError * msg)782 CoordinationServiceError::_Internal::source_task(const CoordinationServiceError* msg) {
783 return *msg->_impl_.source_task_;
784 }
CoordinationServiceError(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)785 CoordinationServiceError::CoordinationServiceError(::PROTOBUF_NAMESPACE_ID::Arena* arena,
786 bool is_message_owned)
787 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
788 SharedCtor(arena, is_message_owned);
789 // @@protoc_insertion_point(arena_constructor:tensorflow.CoordinationServiceError)
790 }
CoordinationServiceError(const CoordinationServiceError & from)791 CoordinationServiceError::CoordinationServiceError(const CoordinationServiceError& from)
792 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
793 CoordinationServiceError* const _this = this; (void)_this;
794 new (&_impl_) Impl_{
795 decltype(_impl_.source_task_){nullptr}
796 , decltype(_impl_.is_reported_error_){}
797 , /*decltype(_impl_._cached_size_)*/{}};
798
799 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
800 if (from._internal_has_source_task()) {
801 _this->_impl_.source_task_ = new ::tensorflow::CoordinatedTask(*from._impl_.source_task_);
802 }
803 _this->_impl_.is_reported_error_ = from._impl_.is_reported_error_;
804 // @@protoc_insertion_point(copy_constructor:tensorflow.CoordinationServiceError)
805 }
806
SharedCtor(::_pb::Arena * arena,bool is_message_owned)807 inline void CoordinationServiceError::SharedCtor(
808 ::_pb::Arena* arena, bool is_message_owned) {
809 (void)arena;
810 (void)is_message_owned;
811 new (&_impl_) Impl_{
812 decltype(_impl_.source_task_){nullptr}
813 , decltype(_impl_.is_reported_error_){false}
814 , /*decltype(_impl_._cached_size_)*/{}
815 };
816 }
817
~CoordinationServiceError()818 CoordinationServiceError::~CoordinationServiceError() {
819 // @@protoc_insertion_point(destructor:tensorflow.CoordinationServiceError)
820 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
821 (void)arena;
822 return;
823 }
824 SharedDtor();
825 }
826
SharedDtor()827 inline void CoordinationServiceError::SharedDtor() {
828 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
829 if (this != internal_default_instance()) delete _impl_.source_task_;
830 }
831
SetCachedSize(int size) const832 void CoordinationServiceError::SetCachedSize(int size) const {
833 _impl_._cached_size_.Set(size);
834 }
835
Clear()836 void CoordinationServiceError::Clear() {
837 // @@protoc_insertion_point(message_clear_start:tensorflow.CoordinationServiceError)
838 ::uint32_t cached_has_bits = 0;
839 // Prevent compiler warnings about cached_has_bits being unused
840 (void) cached_has_bits;
841
842 if (GetArenaForAllocation() == nullptr && _impl_.source_task_ != nullptr) {
843 delete _impl_.source_task_;
844 }
845 _impl_.source_task_ = nullptr;
846 _impl_.is_reported_error_ = false;
847 _internal_metadata_.Clear<std::string>();
848 }
849
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)850 const char* CoordinationServiceError::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
851 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
852 while (!ctx->Done(&ptr)) {
853 ::uint32_t tag;
854 ptr = ::_pbi::ReadTag(ptr, &tag);
855 switch (tag >> 3) {
856 // bool is_reported_error = 3;
857 case 3:
858 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
859 _impl_.is_reported_error_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
860 CHK_(ptr);
861 } else {
862 goto handle_unusual;
863 }
864 continue;
865 // .tensorflow.CoordinatedTask source_task = 4;
866 case 4:
867 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
868 ptr = ctx->ParseMessage(_internal_mutable_source_task(), ptr);
869 CHK_(ptr);
870 } else {
871 goto handle_unusual;
872 }
873 continue;
874 default:
875 goto handle_unusual;
876 } // switch
877 handle_unusual:
878 if ((tag == 0) || ((tag & 7) == 4)) {
879 CHK_(ptr);
880 ctx->SetLastTag(tag);
881 goto message_done;
882 }
883 ptr = UnknownFieldParse(
884 tag,
885 _internal_metadata_.mutable_unknown_fields<std::string>(),
886 ptr, ctx);
887 CHK_(ptr != nullptr);
888 } // while
889 message_done:
890 return ptr;
891 failure:
892 ptr = nullptr;
893 goto message_done;
894 #undef CHK_
895 }
896
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const897 ::uint8_t* CoordinationServiceError::_InternalSerialize(
898 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
899 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.CoordinationServiceError)
900 ::uint32_t cached_has_bits = 0;
901 (void) cached_has_bits;
902
903 // bool is_reported_error = 3;
904 if (this->_internal_is_reported_error() != 0) {
905 target = stream->EnsureSpace(target);
906 target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_is_reported_error(), target);
907 }
908
909 // .tensorflow.CoordinatedTask source_task = 4;
910 if (this->_internal_has_source_task()) {
911 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
912 InternalWriteMessage(4, _Internal::source_task(this),
913 _Internal::source_task(this).GetCachedSize(), target, stream);
914 }
915
916 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
917 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
918 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
919 }
920 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.CoordinationServiceError)
921 return target;
922 }
923
ByteSizeLong() const924 size_t CoordinationServiceError::ByteSizeLong() const {
925 // @@protoc_insertion_point(message_byte_size_start:tensorflow.CoordinationServiceError)
926 size_t total_size = 0;
927
928 ::uint32_t cached_has_bits = 0;
929 // Prevent compiler warnings about cached_has_bits being unused
930 (void) cached_has_bits;
931
932 // .tensorflow.CoordinatedTask source_task = 4;
933 if (this->_internal_has_source_task()) {
934 total_size += 1 +
935 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
936 *_impl_.source_task_);
937 }
938
939 // bool is_reported_error = 3;
940 if (this->_internal_is_reported_error() != 0) {
941 total_size += 1 + 1;
942 }
943
944 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
945 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
946 }
947 int cached_size = ::_pbi::ToCachedSize(total_size);
948 SetCachedSize(cached_size);
949 return total_size;
950 }
951
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)952 void CoordinationServiceError::CheckTypeAndMergeFrom(
953 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
954 MergeFrom(*::_pbi::DownCast<const CoordinationServiceError*>(
955 &from));
956 }
957
MergeFrom(const CoordinationServiceError & from)958 void CoordinationServiceError::MergeFrom(const CoordinationServiceError& from) {
959 CoordinationServiceError* const _this = this;
960 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.CoordinationServiceError)
961 GOOGLE_DCHECK_NE(&from, _this);
962 ::uint32_t cached_has_bits = 0;
963 (void) cached_has_bits;
964
965 if (from._internal_has_source_task()) {
966 _this->_internal_mutable_source_task()->::tensorflow::CoordinatedTask::MergeFrom(
967 from._internal_source_task());
968 }
969 if (from._internal_is_reported_error() != 0) {
970 _this->_internal_set_is_reported_error(from._internal_is_reported_error());
971 }
972 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
973 }
974
CopyFrom(const CoordinationServiceError & from)975 void CoordinationServiceError::CopyFrom(const CoordinationServiceError& from) {
976 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.CoordinationServiceError)
977 if (&from == this) return;
978 Clear();
979 MergeFrom(from);
980 }
981
IsInitialized() const982 bool CoordinationServiceError::IsInitialized() const {
983 return true;
984 }
985
InternalSwap(CoordinationServiceError * other)986 void CoordinationServiceError::InternalSwap(CoordinationServiceError* other) {
987 using std::swap;
988 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
989 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
990 PROTOBUF_FIELD_OFFSET(CoordinationServiceError, _impl_.is_reported_error_)
991 + sizeof(CoordinationServiceError::_impl_.is_reported_error_) // NOLINT
992 - PROTOBUF_FIELD_OFFSET(CoordinationServiceError, _impl_.source_task_)>(
993 reinterpret_cast<char*>(&_impl_.source_task_),
994 reinterpret_cast<char*>(&other->_impl_.source_task_));
995 }
996
GetTypeName() const997 std::string CoordinationServiceError::GetTypeName() const {
998 return "tensorflow.CoordinationServiceError";
999 }
1000
1001
1002 // ===================================================================
1003
1004 class TfDeviceList::_Internal {
1005 public:
1006 };
1007
clear_devices()1008 void TfDeviceList::clear_devices() {
1009 _impl_.devices_.Clear();
1010 }
TfDeviceList(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1011 TfDeviceList::TfDeviceList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1012 bool is_message_owned)
1013 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1014 SharedCtor(arena, is_message_owned);
1015 // @@protoc_insertion_point(arena_constructor:tensorflow.TfDeviceList)
1016 }
TfDeviceList(const TfDeviceList & from)1017 TfDeviceList::TfDeviceList(const TfDeviceList& from)
1018 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1019 TfDeviceList* const _this = this; (void)_this;
1020 new (&_impl_) Impl_{
1021 decltype(_impl_.devices_){from._impl_.devices_}
1022 , /*decltype(_impl_._cached_size_)*/{}};
1023
1024 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1025 // @@protoc_insertion_point(copy_constructor:tensorflow.TfDeviceList)
1026 }
1027
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1028 inline void TfDeviceList::SharedCtor(
1029 ::_pb::Arena* arena, bool is_message_owned) {
1030 (void)arena;
1031 (void)is_message_owned;
1032 new (&_impl_) Impl_{
1033 decltype(_impl_.devices_){arena}
1034 , /*decltype(_impl_._cached_size_)*/{}
1035 };
1036 }
1037
~TfDeviceList()1038 TfDeviceList::~TfDeviceList() {
1039 // @@protoc_insertion_point(destructor:tensorflow.TfDeviceList)
1040 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1041 (void)arena;
1042 return;
1043 }
1044 SharedDtor();
1045 }
1046
SharedDtor()1047 inline void TfDeviceList::SharedDtor() {
1048 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1049 _impl_.devices_.~RepeatedPtrField();
1050 }
1051
SetCachedSize(int size) const1052 void TfDeviceList::SetCachedSize(int size) const {
1053 _impl_._cached_size_.Set(size);
1054 }
1055
Clear()1056 void TfDeviceList::Clear() {
1057 // @@protoc_insertion_point(message_clear_start:tensorflow.TfDeviceList)
1058 ::uint32_t cached_has_bits = 0;
1059 // Prevent compiler warnings about cached_has_bits being unused
1060 (void) cached_has_bits;
1061
1062 _impl_.devices_.Clear();
1063 _internal_metadata_.Clear<std::string>();
1064 }
1065
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1066 const char* TfDeviceList::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1067 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1068 while (!ctx->Done(&ptr)) {
1069 ::uint32_t tag;
1070 ptr = ::_pbi::ReadTag(ptr, &tag);
1071 switch (tag >> 3) {
1072 // repeated .tensorflow.DeviceAttributes devices = 1;
1073 case 1:
1074 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1075 ptr -= 1;
1076 do {
1077 ptr += 1;
1078 ptr = ctx->ParseMessage(_internal_add_devices(), ptr);
1079 CHK_(ptr);
1080 if (!ctx->DataAvailable(ptr)) break;
1081 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
1082 } else {
1083 goto handle_unusual;
1084 }
1085 continue;
1086 default:
1087 goto handle_unusual;
1088 } // switch
1089 handle_unusual:
1090 if ((tag == 0) || ((tag & 7) == 4)) {
1091 CHK_(ptr);
1092 ctx->SetLastTag(tag);
1093 goto message_done;
1094 }
1095 ptr = UnknownFieldParse(
1096 tag,
1097 _internal_metadata_.mutable_unknown_fields<std::string>(),
1098 ptr, ctx);
1099 CHK_(ptr != nullptr);
1100 } // while
1101 message_done:
1102 return ptr;
1103 failure:
1104 ptr = nullptr;
1105 goto message_done;
1106 #undef CHK_
1107 }
1108
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1109 ::uint8_t* TfDeviceList::_InternalSerialize(
1110 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1111 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.TfDeviceList)
1112 ::uint32_t cached_has_bits = 0;
1113 (void) cached_has_bits;
1114
1115 // repeated .tensorflow.DeviceAttributes devices = 1;
1116 for (unsigned i = 0,
1117 n = static_cast<unsigned>(this->_internal_devices_size()); i < n; i++) {
1118 const auto& repfield = this->_internal_devices(i);
1119 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1120 InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
1121 }
1122
1123 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1124 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1125 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1126 }
1127 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.TfDeviceList)
1128 return target;
1129 }
1130
ByteSizeLong() const1131 size_t TfDeviceList::ByteSizeLong() const {
1132 // @@protoc_insertion_point(message_byte_size_start:tensorflow.TfDeviceList)
1133 size_t total_size = 0;
1134
1135 ::uint32_t cached_has_bits = 0;
1136 // Prevent compiler warnings about cached_has_bits being unused
1137 (void) cached_has_bits;
1138
1139 // repeated .tensorflow.DeviceAttributes devices = 1;
1140 total_size += 1UL * this->_internal_devices_size();
1141 for (const auto& msg : this->_impl_.devices_) {
1142 total_size +=
1143 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
1144 }
1145
1146 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1147 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1148 }
1149 int cached_size = ::_pbi::ToCachedSize(total_size);
1150 SetCachedSize(cached_size);
1151 return total_size;
1152 }
1153
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1154 void TfDeviceList::CheckTypeAndMergeFrom(
1155 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1156 MergeFrom(*::_pbi::DownCast<const TfDeviceList*>(
1157 &from));
1158 }
1159
MergeFrom(const TfDeviceList & from)1160 void TfDeviceList::MergeFrom(const TfDeviceList& from) {
1161 TfDeviceList* const _this = this;
1162 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.TfDeviceList)
1163 GOOGLE_DCHECK_NE(&from, _this);
1164 ::uint32_t cached_has_bits = 0;
1165 (void) cached_has_bits;
1166
1167 _this->_impl_.devices_.MergeFrom(from._impl_.devices_);
1168 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1169 }
1170
CopyFrom(const TfDeviceList & from)1171 void TfDeviceList::CopyFrom(const TfDeviceList& from) {
1172 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.TfDeviceList)
1173 if (&from == this) return;
1174 Clear();
1175 MergeFrom(from);
1176 }
1177
IsInitialized() const1178 bool TfDeviceList::IsInitialized() const {
1179 return true;
1180 }
1181
InternalSwap(TfDeviceList * other)1182 void TfDeviceList::InternalSwap(TfDeviceList* other) {
1183 using std::swap;
1184 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1185 _impl_.devices_.InternalSwap(&other->_impl_.devices_);
1186 }
1187
GetTypeName() const1188 std::string TfDeviceList::GetTypeName() const {
1189 return "tensorflow.TfDeviceList";
1190 }
1191
1192
1193 // ===================================================================
1194
1195 class XlaDeviceList::_Internal {
1196 public:
1197 static const ::xla::GlobalTopologyProto& devices(const XlaDeviceList* msg);
1198 };
1199
1200 const ::xla::GlobalTopologyProto&
devices(const XlaDeviceList * msg)1201 XlaDeviceList::_Internal::devices(const XlaDeviceList* msg) {
1202 return *msg->_impl_.devices_;
1203 }
clear_devices()1204 void XlaDeviceList::clear_devices() {
1205 if (GetArenaForAllocation() == nullptr && _impl_.devices_ != nullptr) {
1206 delete _impl_.devices_;
1207 }
1208 _impl_.devices_ = nullptr;
1209 }
XlaDeviceList(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1210 XlaDeviceList::XlaDeviceList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1211 bool is_message_owned)
1212 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1213 SharedCtor(arena, is_message_owned);
1214 // @@protoc_insertion_point(arena_constructor:tensorflow.XlaDeviceList)
1215 }
XlaDeviceList(const XlaDeviceList & from)1216 XlaDeviceList::XlaDeviceList(const XlaDeviceList& from)
1217 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1218 XlaDeviceList* const _this = this; (void)_this;
1219 new (&_impl_) Impl_{
1220 decltype(_impl_.devices_){nullptr}
1221 , /*decltype(_impl_._cached_size_)*/{}};
1222
1223 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1224 if (from._internal_has_devices()) {
1225 _this->_impl_.devices_ = new ::xla::GlobalTopologyProto(*from._impl_.devices_);
1226 }
1227 // @@protoc_insertion_point(copy_constructor:tensorflow.XlaDeviceList)
1228 }
1229
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1230 inline void XlaDeviceList::SharedCtor(
1231 ::_pb::Arena* arena, bool is_message_owned) {
1232 (void)arena;
1233 (void)is_message_owned;
1234 new (&_impl_) Impl_{
1235 decltype(_impl_.devices_){nullptr}
1236 , /*decltype(_impl_._cached_size_)*/{}
1237 };
1238 }
1239
~XlaDeviceList()1240 XlaDeviceList::~XlaDeviceList() {
1241 // @@protoc_insertion_point(destructor:tensorflow.XlaDeviceList)
1242 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1243 (void)arena;
1244 return;
1245 }
1246 SharedDtor();
1247 }
1248
SharedDtor()1249 inline void XlaDeviceList::SharedDtor() {
1250 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1251 if (this != internal_default_instance()) delete _impl_.devices_;
1252 }
1253
SetCachedSize(int size) const1254 void XlaDeviceList::SetCachedSize(int size) const {
1255 _impl_._cached_size_.Set(size);
1256 }
1257
Clear()1258 void XlaDeviceList::Clear() {
1259 // @@protoc_insertion_point(message_clear_start:tensorflow.XlaDeviceList)
1260 ::uint32_t cached_has_bits = 0;
1261 // Prevent compiler warnings about cached_has_bits being unused
1262 (void) cached_has_bits;
1263
1264 if (GetArenaForAllocation() == nullptr && _impl_.devices_ != nullptr) {
1265 delete _impl_.devices_;
1266 }
1267 _impl_.devices_ = nullptr;
1268 _internal_metadata_.Clear<std::string>();
1269 }
1270
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1271 const char* XlaDeviceList::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1272 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1273 while (!ctx->Done(&ptr)) {
1274 ::uint32_t tag;
1275 ptr = ::_pbi::ReadTag(ptr, &tag);
1276 switch (tag >> 3) {
1277 // .xla.GlobalTopologyProto devices = 1;
1278 case 1:
1279 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1280 ptr = ctx->ParseMessage(_internal_mutable_devices(), ptr);
1281 CHK_(ptr);
1282 } else {
1283 goto handle_unusual;
1284 }
1285 continue;
1286 default:
1287 goto handle_unusual;
1288 } // switch
1289 handle_unusual:
1290 if ((tag == 0) || ((tag & 7) == 4)) {
1291 CHK_(ptr);
1292 ctx->SetLastTag(tag);
1293 goto message_done;
1294 }
1295 ptr = UnknownFieldParse(
1296 tag,
1297 _internal_metadata_.mutable_unknown_fields<std::string>(),
1298 ptr, ctx);
1299 CHK_(ptr != nullptr);
1300 } // while
1301 message_done:
1302 return ptr;
1303 failure:
1304 ptr = nullptr;
1305 goto message_done;
1306 #undef CHK_
1307 }
1308
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1309 ::uint8_t* XlaDeviceList::_InternalSerialize(
1310 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1311 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.XlaDeviceList)
1312 ::uint32_t cached_has_bits = 0;
1313 (void) cached_has_bits;
1314
1315 // .xla.GlobalTopologyProto devices = 1;
1316 if (this->_internal_has_devices()) {
1317 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1318 InternalWriteMessage(1, _Internal::devices(this),
1319 _Internal::devices(this).GetCachedSize(), target, stream);
1320 }
1321
1322 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1323 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1324 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1325 }
1326 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.XlaDeviceList)
1327 return target;
1328 }
1329
ByteSizeLong() const1330 size_t XlaDeviceList::ByteSizeLong() const {
1331 // @@protoc_insertion_point(message_byte_size_start:tensorflow.XlaDeviceList)
1332 size_t total_size = 0;
1333
1334 ::uint32_t cached_has_bits = 0;
1335 // Prevent compiler warnings about cached_has_bits being unused
1336 (void) cached_has_bits;
1337
1338 // .xla.GlobalTopologyProto devices = 1;
1339 if (this->_internal_has_devices()) {
1340 total_size += 1 +
1341 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1342 *_impl_.devices_);
1343 }
1344
1345 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1346 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1347 }
1348 int cached_size = ::_pbi::ToCachedSize(total_size);
1349 SetCachedSize(cached_size);
1350 return total_size;
1351 }
1352
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1353 void XlaDeviceList::CheckTypeAndMergeFrom(
1354 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1355 MergeFrom(*::_pbi::DownCast<const XlaDeviceList*>(
1356 &from));
1357 }
1358
MergeFrom(const XlaDeviceList & from)1359 void XlaDeviceList::MergeFrom(const XlaDeviceList& from) {
1360 XlaDeviceList* const _this = this;
1361 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.XlaDeviceList)
1362 GOOGLE_DCHECK_NE(&from, _this);
1363 ::uint32_t cached_has_bits = 0;
1364 (void) cached_has_bits;
1365
1366 if (from._internal_has_devices()) {
1367 _this->_internal_mutable_devices()->::xla::GlobalTopologyProto::MergeFrom(
1368 from._internal_devices());
1369 }
1370 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1371 }
1372
CopyFrom(const XlaDeviceList & from)1373 void XlaDeviceList::CopyFrom(const XlaDeviceList& from) {
1374 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.XlaDeviceList)
1375 if (&from == this) return;
1376 Clear();
1377 MergeFrom(from);
1378 }
1379
IsInitialized() const1380 bool XlaDeviceList::IsInitialized() const {
1381 return true;
1382 }
1383
InternalSwap(XlaDeviceList * other)1384 void XlaDeviceList::InternalSwap(XlaDeviceList* other) {
1385 using std::swap;
1386 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1387 swap(_impl_.devices_, other->_impl_.devices_);
1388 }
1389
GetTypeName() const1390 std::string XlaDeviceList::GetTypeName() const {
1391 return "tensorflow.XlaDeviceList";
1392 }
1393
1394
1395 // ===================================================================
1396
1397 class CoordinationServiceDeviceInfo::_Internal {
1398 public:
1399 static const ::tensorflow::TfDeviceList& tf(const CoordinationServiceDeviceInfo* msg);
1400 static const ::tensorflow::XlaDeviceList& xla(const CoordinationServiceDeviceInfo* msg);
1401 };
1402
1403 const ::tensorflow::TfDeviceList&
tf(const CoordinationServiceDeviceInfo * msg)1404 CoordinationServiceDeviceInfo::_Internal::tf(const CoordinationServiceDeviceInfo* msg) {
1405 return *msg->_impl_.type_.tf_;
1406 }
1407 const ::tensorflow::XlaDeviceList&
xla(const CoordinationServiceDeviceInfo * msg)1408 CoordinationServiceDeviceInfo::_Internal::xla(const CoordinationServiceDeviceInfo* msg) {
1409 return *msg->_impl_.type_.xla_;
1410 }
set_allocated_tf(::tensorflow::TfDeviceList * tf)1411 void CoordinationServiceDeviceInfo::set_allocated_tf(::tensorflow::TfDeviceList* tf) {
1412 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
1413 clear_type();
1414 if (tf) {
1415 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1416 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(tf);
1417 if (message_arena != submessage_arena) {
1418 tf = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1419 message_arena, tf, submessage_arena);
1420 }
1421 set_has_tf();
1422 _impl_.type_.tf_ = tf;
1423 }
1424 // @@protoc_insertion_point(field_set_allocated:tensorflow.CoordinationServiceDeviceInfo.tf)
1425 }
set_allocated_xla(::tensorflow::XlaDeviceList * xla)1426 void CoordinationServiceDeviceInfo::set_allocated_xla(::tensorflow::XlaDeviceList* xla) {
1427 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
1428 clear_type();
1429 if (xla) {
1430 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1431 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xla);
1432 if (message_arena != submessage_arena) {
1433 xla = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1434 message_arena, xla, submessage_arena);
1435 }
1436 set_has_xla();
1437 _impl_.type_.xla_ = xla;
1438 }
1439 // @@protoc_insertion_point(field_set_allocated:tensorflow.CoordinationServiceDeviceInfo.xla)
1440 }
CoordinationServiceDeviceInfo(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1441 CoordinationServiceDeviceInfo::CoordinationServiceDeviceInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1442 bool is_message_owned)
1443 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1444 SharedCtor(arena, is_message_owned);
1445 // @@protoc_insertion_point(arena_constructor:tensorflow.CoordinationServiceDeviceInfo)
1446 }
CoordinationServiceDeviceInfo(const CoordinationServiceDeviceInfo & from)1447 CoordinationServiceDeviceInfo::CoordinationServiceDeviceInfo(const CoordinationServiceDeviceInfo& from)
1448 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1449 CoordinationServiceDeviceInfo* const _this = this; (void)_this;
1450 new (&_impl_) Impl_{
1451 decltype(_impl_.type_){}
1452 , /*decltype(_impl_._cached_size_)*/{}
1453 , /*decltype(_impl_._oneof_case_)*/{}};
1454
1455 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1456 clear_has_type();
1457 switch (from.type_case()) {
1458 case kTf: {
1459 _this->_internal_mutable_tf()->::tensorflow::TfDeviceList::MergeFrom(
1460 from._internal_tf());
1461 break;
1462 }
1463 case kXla: {
1464 _this->_internal_mutable_xla()->::tensorflow::XlaDeviceList::MergeFrom(
1465 from._internal_xla());
1466 break;
1467 }
1468 case TYPE_NOT_SET: {
1469 break;
1470 }
1471 }
1472 // @@protoc_insertion_point(copy_constructor:tensorflow.CoordinationServiceDeviceInfo)
1473 }
1474
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1475 inline void CoordinationServiceDeviceInfo::SharedCtor(
1476 ::_pb::Arena* arena, bool is_message_owned) {
1477 (void)arena;
1478 (void)is_message_owned;
1479 new (&_impl_) Impl_{
1480 decltype(_impl_.type_){}
1481 , /*decltype(_impl_._cached_size_)*/{}
1482 , /*decltype(_impl_._oneof_case_)*/{}
1483 };
1484 clear_has_type();
1485 }
1486
~CoordinationServiceDeviceInfo()1487 CoordinationServiceDeviceInfo::~CoordinationServiceDeviceInfo() {
1488 // @@protoc_insertion_point(destructor:tensorflow.CoordinationServiceDeviceInfo)
1489 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1490 (void)arena;
1491 return;
1492 }
1493 SharedDtor();
1494 }
1495
SharedDtor()1496 inline void CoordinationServiceDeviceInfo::SharedDtor() {
1497 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1498 if (has_type()) {
1499 clear_type();
1500 }
1501 }
1502
SetCachedSize(int size) const1503 void CoordinationServiceDeviceInfo::SetCachedSize(int size) const {
1504 _impl_._cached_size_.Set(size);
1505 }
1506
clear_type()1507 void CoordinationServiceDeviceInfo::clear_type() {
1508 // @@protoc_insertion_point(one_of_clear_start:tensorflow.CoordinationServiceDeviceInfo)
1509 switch (type_case()) {
1510 case kTf: {
1511 if (GetArenaForAllocation() == nullptr) {
1512 delete _impl_.type_.tf_;
1513 }
1514 break;
1515 }
1516 case kXla: {
1517 if (GetArenaForAllocation() == nullptr) {
1518 delete _impl_.type_.xla_;
1519 }
1520 break;
1521 }
1522 case TYPE_NOT_SET: {
1523 break;
1524 }
1525 }
1526 _impl_._oneof_case_[0] = TYPE_NOT_SET;
1527 }
1528
1529
Clear()1530 void CoordinationServiceDeviceInfo::Clear() {
1531 // @@protoc_insertion_point(message_clear_start:tensorflow.CoordinationServiceDeviceInfo)
1532 ::uint32_t cached_has_bits = 0;
1533 // Prevent compiler warnings about cached_has_bits being unused
1534 (void) cached_has_bits;
1535
1536 clear_type();
1537 _internal_metadata_.Clear<std::string>();
1538 }
1539
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1540 const char* CoordinationServiceDeviceInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1541 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1542 while (!ctx->Done(&ptr)) {
1543 ::uint32_t tag;
1544 ptr = ::_pbi::ReadTag(ptr, &tag);
1545 switch (tag >> 3) {
1546 // .tensorflow.TfDeviceList tf = 1;
1547 case 1:
1548 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1549 ptr = ctx->ParseMessage(_internal_mutable_tf(), ptr);
1550 CHK_(ptr);
1551 } else {
1552 goto handle_unusual;
1553 }
1554 continue;
1555 // .tensorflow.XlaDeviceList xla = 2;
1556 case 2:
1557 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1558 ptr = ctx->ParseMessage(_internal_mutable_xla(), ptr);
1559 CHK_(ptr);
1560 } else {
1561 goto handle_unusual;
1562 }
1563 continue;
1564 default:
1565 goto handle_unusual;
1566 } // switch
1567 handle_unusual:
1568 if ((tag == 0) || ((tag & 7) == 4)) {
1569 CHK_(ptr);
1570 ctx->SetLastTag(tag);
1571 goto message_done;
1572 }
1573 ptr = UnknownFieldParse(
1574 tag,
1575 _internal_metadata_.mutable_unknown_fields<std::string>(),
1576 ptr, ctx);
1577 CHK_(ptr != nullptr);
1578 } // while
1579 message_done:
1580 return ptr;
1581 failure:
1582 ptr = nullptr;
1583 goto message_done;
1584 #undef CHK_
1585 }
1586
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1587 ::uint8_t* CoordinationServiceDeviceInfo::_InternalSerialize(
1588 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1589 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.CoordinationServiceDeviceInfo)
1590 ::uint32_t cached_has_bits = 0;
1591 (void) cached_has_bits;
1592
1593 // .tensorflow.TfDeviceList tf = 1;
1594 if (_internal_has_tf()) {
1595 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1596 InternalWriteMessage(1, _Internal::tf(this),
1597 _Internal::tf(this).GetCachedSize(), target, stream);
1598 }
1599
1600 // .tensorflow.XlaDeviceList xla = 2;
1601 if (_internal_has_xla()) {
1602 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1603 InternalWriteMessage(2, _Internal::xla(this),
1604 _Internal::xla(this).GetCachedSize(), target, stream);
1605 }
1606
1607 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1608 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1609 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1610 }
1611 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.CoordinationServiceDeviceInfo)
1612 return target;
1613 }
1614
ByteSizeLong() const1615 size_t CoordinationServiceDeviceInfo::ByteSizeLong() const {
1616 // @@protoc_insertion_point(message_byte_size_start:tensorflow.CoordinationServiceDeviceInfo)
1617 size_t total_size = 0;
1618
1619 switch (type_case()) {
1620 // .tensorflow.TfDeviceList tf = 1;
1621 case kTf: {
1622 total_size += 1 +
1623 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1624 *_impl_.type_.tf_);
1625 break;
1626 }
1627 // .tensorflow.XlaDeviceList xla = 2;
1628 case kXla: {
1629 total_size += 1 +
1630 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1631 *_impl_.type_.xla_);
1632 break;
1633 }
1634 case TYPE_NOT_SET: {
1635 break;
1636 }
1637 }
1638 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1639 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1640 }
1641 int cached_size = ::_pbi::ToCachedSize(total_size);
1642 SetCachedSize(cached_size);
1643 return total_size;
1644 }
1645
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1646 void CoordinationServiceDeviceInfo::CheckTypeAndMergeFrom(
1647 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1648 MergeFrom(*::_pbi::DownCast<const CoordinationServiceDeviceInfo*>(
1649 &from));
1650 }
1651
MergeFrom(const CoordinationServiceDeviceInfo & from)1652 void CoordinationServiceDeviceInfo::MergeFrom(const CoordinationServiceDeviceInfo& from) {
1653 CoordinationServiceDeviceInfo* const _this = this;
1654 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.CoordinationServiceDeviceInfo)
1655 GOOGLE_DCHECK_NE(&from, _this);
1656 ::uint32_t cached_has_bits = 0;
1657 (void) cached_has_bits;
1658
1659 switch (from.type_case()) {
1660 case kTf: {
1661 _this->_internal_mutable_tf()->::tensorflow::TfDeviceList::MergeFrom(
1662 from._internal_tf());
1663 break;
1664 }
1665 case kXla: {
1666 _this->_internal_mutable_xla()->::tensorflow::XlaDeviceList::MergeFrom(
1667 from._internal_xla());
1668 break;
1669 }
1670 case TYPE_NOT_SET: {
1671 break;
1672 }
1673 }
1674 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1675 }
1676
CopyFrom(const CoordinationServiceDeviceInfo & from)1677 void CoordinationServiceDeviceInfo::CopyFrom(const CoordinationServiceDeviceInfo& from) {
1678 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.CoordinationServiceDeviceInfo)
1679 if (&from == this) return;
1680 Clear();
1681 MergeFrom(from);
1682 }
1683
IsInitialized() const1684 bool CoordinationServiceDeviceInfo::IsInitialized() const {
1685 return true;
1686 }
1687
InternalSwap(CoordinationServiceDeviceInfo * other)1688 void CoordinationServiceDeviceInfo::InternalSwap(CoordinationServiceDeviceInfo* other) {
1689 using std::swap;
1690 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1691 swap(_impl_.type_, other->_impl_.type_);
1692 swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
1693 }
1694
GetTypeName() const1695 std::string CoordinationServiceDeviceInfo::GetTypeName() const {
1696 return "tensorflow.CoordinationServiceDeviceInfo";
1697 }
1698
1699
1700 // ===================================================================
1701
1702 class RegisterTaskRequest::_Internal {
1703 public:
1704 static const ::tensorflow::CoordinatedTask& source_task(const RegisterTaskRequest* msg);
1705 };
1706
1707 const ::tensorflow::CoordinatedTask&
source_task(const RegisterTaskRequest * msg)1708 RegisterTaskRequest::_Internal::source_task(const RegisterTaskRequest* msg) {
1709 return *msg->_impl_.source_task_;
1710 }
RegisterTaskRequest(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1711 RegisterTaskRequest::RegisterTaskRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1712 bool is_message_owned)
1713 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1714 SharedCtor(arena, is_message_owned);
1715 // @@protoc_insertion_point(arena_constructor:tensorflow.RegisterTaskRequest)
1716 }
RegisterTaskRequest(const RegisterTaskRequest & from)1717 RegisterTaskRequest::RegisterTaskRequest(const RegisterTaskRequest& from)
1718 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1719 RegisterTaskRequest* const _this = this; (void)_this;
1720 new (&_impl_) Impl_{
1721 decltype(_impl_.source_task_){nullptr}
1722 , decltype(_impl_.incarnation_){}
1723 , /*decltype(_impl_._cached_size_)*/{}};
1724
1725 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1726 if (from._internal_has_source_task()) {
1727 _this->_impl_.source_task_ = new ::tensorflow::CoordinatedTask(*from._impl_.source_task_);
1728 }
1729 _this->_impl_.incarnation_ = from._impl_.incarnation_;
1730 // @@protoc_insertion_point(copy_constructor:tensorflow.RegisterTaskRequest)
1731 }
1732
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1733 inline void RegisterTaskRequest::SharedCtor(
1734 ::_pb::Arena* arena, bool is_message_owned) {
1735 (void)arena;
1736 (void)is_message_owned;
1737 new (&_impl_) Impl_{
1738 decltype(_impl_.source_task_){nullptr}
1739 , decltype(_impl_.incarnation_){::uint64_t{0u}}
1740 , /*decltype(_impl_._cached_size_)*/{}
1741 };
1742 }
1743
~RegisterTaskRequest()1744 RegisterTaskRequest::~RegisterTaskRequest() {
1745 // @@protoc_insertion_point(destructor:tensorflow.RegisterTaskRequest)
1746 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1747 (void)arena;
1748 return;
1749 }
1750 SharedDtor();
1751 }
1752
SharedDtor()1753 inline void RegisterTaskRequest::SharedDtor() {
1754 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1755 if (this != internal_default_instance()) delete _impl_.source_task_;
1756 }
1757
SetCachedSize(int size) const1758 void RegisterTaskRequest::SetCachedSize(int size) const {
1759 _impl_._cached_size_.Set(size);
1760 }
1761
Clear()1762 void RegisterTaskRequest::Clear() {
1763 // @@protoc_insertion_point(message_clear_start:tensorflow.RegisterTaskRequest)
1764 ::uint32_t cached_has_bits = 0;
1765 // Prevent compiler warnings about cached_has_bits being unused
1766 (void) cached_has_bits;
1767
1768 if (GetArenaForAllocation() == nullptr && _impl_.source_task_ != nullptr) {
1769 delete _impl_.source_task_;
1770 }
1771 _impl_.source_task_ = nullptr;
1772 _impl_.incarnation_ = ::uint64_t{0u};
1773 _internal_metadata_.Clear<std::string>();
1774 }
1775
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1776 const char* RegisterTaskRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1777 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1778 while (!ctx->Done(&ptr)) {
1779 ::uint32_t tag;
1780 ptr = ::_pbi::ReadTag(ptr, &tag);
1781 switch (tag >> 3) {
1782 // fixed64 incarnation = 3;
1783 case 3:
1784 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 25)) {
1785 _impl_.incarnation_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::uint64_t>(ptr);
1786 ptr += sizeof(::uint64_t);
1787 } else {
1788 goto handle_unusual;
1789 }
1790 continue;
1791 // .tensorflow.CoordinatedTask source_task = 5;
1792 case 5:
1793 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
1794 ptr = ctx->ParseMessage(_internal_mutable_source_task(), ptr);
1795 CHK_(ptr);
1796 } else {
1797 goto handle_unusual;
1798 }
1799 continue;
1800 default:
1801 goto handle_unusual;
1802 } // switch
1803 handle_unusual:
1804 if ((tag == 0) || ((tag & 7) == 4)) {
1805 CHK_(ptr);
1806 ctx->SetLastTag(tag);
1807 goto message_done;
1808 }
1809 ptr = UnknownFieldParse(
1810 tag,
1811 _internal_metadata_.mutable_unknown_fields<std::string>(),
1812 ptr, ctx);
1813 CHK_(ptr != nullptr);
1814 } // while
1815 message_done:
1816 return ptr;
1817 failure:
1818 ptr = nullptr;
1819 goto message_done;
1820 #undef CHK_
1821 }
1822
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1823 ::uint8_t* RegisterTaskRequest::_InternalSerialize(
1824 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1825 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.RegisterTaskRequest)
1826 ::uint32_t cached_has_bits = 0;
1827 (void) cached_has_bits;
1828
1829 // fixed64 incarnation = 3;
1830 if (this->_internal_incarnation() != 0) {
1831 target = stream->EnsureSpace(target);
1832 target = ::_pbi::WireFormatLite::WriteFixed64ToArray(3, this->_internal_incarnation(), target);
1833 }
1834
1835 // .tensorflow.CoordinatedTask source_task = 5;
1836 if (this->_internal_has_source_task()) {
1837 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1838 InternalWriteMessage(5, _Internal::source_task(this),
1839 _Internal::source_task(this).GetCachedSize(), target, stream);
1840 }
1841
1842 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1843 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1844 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1845 }
1846 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.RegisterTaskRequest)
1847 return target;
1848 }
1849
ByteSizeLong() const1850 size_t RegisterTaskRequest::ByteSizeLong() const {
1851 // @@protoc_insertion_point(message_byte_size_start:tensorflow.RegisterTaskRequest)
1852 size_t total_size = 0;
1853
1854 ::uint32_t cached_has_bits = 0;
1855 // Prevent compiler warnings about cached_has_bits being unused
1856 (void) cached_has_bits;
1857
1858 // .tensorflow.CoordinatedTask source_task = 5;
1859 if (this->_internal_has_source_task()) {
1860 total_size += 1 +
1861 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1862 *_impl_.source_task_);
1863 }
1864
1865 // fixed64 incarnation = 3;
1866 if (this->_internal_incarnation() != 0) {
1867 total_size += 1 + 8;
1868 }
1869
1870 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1871 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1872 }
1873 int cached_size = ::_pbi::ToCachedSize(total_size);
1874 SetCachedSize(cached_size);
1875 return total_size;
1876 }
1877
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1878 void RegisterTaskRequest::CheckTypeAndMergeFrom(
1879 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1880 MergeFrom(*::_pbi::DownCast<const RegisterTaskRequest*>(
1881 &from));
1882 }
1883
MergeFrom(const RegisterTaskRequest & from)1884 void RegisterTaskRequest::MergeFrom(const RegisterTaskRequest& from) {
1885 RegisterTaskRequest* const _this = this;
1886 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.RegisterTaskRequest)
1887 GOOGLE_DCHECK_NE(&from, _this);
1888 ::uint32_t cached_has_bits = 0;
1889 (void) cached_has_bits;
1890
1891 if (from._internal_has_source_task()) {
1892 _this->_internal_mutable_source_task()->::tensorflow::CoordinatedTask::MergeFrom(
1893 from._internal_source_task());
1894 }
1895 if (from._internal_incarnation() != 0) {
1896 _this->_internal_set_incarnation(from._internal_incarnation());
1897 }
1898 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1899 }
1900
CopyFrom(const RegisterTaskRequest & from)1901 void RegisterTaskRequest::CopyFrom(const RegisterTaskRequest& from) {
1902 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.RegisterTaskRequest)
1903 if (&from == this) return;
1904 Clear();
1905 MergeFrom(from);
1906 }
1907
IsInitialized() const1908 bool RegisterTaskRequest::IsInitialized() const {
1909 return true;
1910 }
1911
InternalSwap(RegisterTaskRequest * other)1912 void RegisterTaskRequest::InternalSwap(RegisterTaskRequest* other) {
1913 using std::swap;
1914 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1915 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1916 PROTOBUF_FIELD_OFFSET(RegisterTaskRequest, _impl_.incarnation_)
1917 + sizeof(RegisterTaskRequest::_impl_.incarnation_) // NOLINT
1918 - PROTOBUF_FIELD_OFFSET(RegisterTaskRequest, _impl_.source_task_)>(
1919 reinterpret_cast<char*>(&_impl_.source_task_),
1920 reinterpret_cast<char*>(&other->_impl_.source_task_));
1921 }
1922
GetTypeName() const1923 std::string RegisterTaskRequest::GetTypeName() const {
1924 return "tensorflow.RegisterTaskRequest";
1925 }
1926
1927
1928 // ===================================================================
1929
1930 class RegisterTaskResponse::_Internal {
1931 public:
1932 };
1933
RegisterTaskResponse(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1934 RegisterTaskResponse::RegisterTaskResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1935 bool is_message_owned)
1936 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1937 SharedCtor(arena, is_message_owned);
1938 // @@protoc_insertion_point(arena_constructor:tensorflow.RegisterTaskResponse)
1939 }
RegisterTaskResponse(const RegisterTaskResponse & from)1940 RegisterTaskResponse::RegisterTaskResponse(const RegisterTaskResponse& from)
1941 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1942 RegisterTaskResponse* const _this = this; (void)_this;
1943 new (&_impl_) Impl_{
1944 decltype(_impl_.leader_incarnation_){}
1945 , /*decltype(_impl_._cached_size_)*/{}};
1946
1947 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1948 _this->_impl_.leader_incarnation_ = from._impl_.leader_incarnation_;
1949 // @@protoc_insertion_point(copy_constructor:tensorflow.RegisterTaskResponse)
1950 }
1951
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1952 inline void RegisterTaskResponse::SharedCtor(
1953 ::_pb::Arena* arena, bool is_message_owned) {
1954 (void)arena;
1955 (void)is_message_owned;
1956 new (&_impl_) Impl_{
1957 decltype(_impl_.leader_incarnation_){::uint64_t{0u}}
1958 , /*decltype(_impl_._cached_size_)*/{}
1959 };
1960 }
1961
~RegisterTaskResponse()1962 RegisterTaskResponse::~RegisterTaskResponse() {
1963 // @@protoc_insertion_point(destructor:tensorflow.RegisterTaskResponse)
1964 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1965 (void)arena;
1966 return;
1967 }
1968 SharedDtor();
1969 }
1970
SharedDtor()1971 inline void RegisterTaskResponse::SharedDtor() {
1972 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1973 }
1974
SetCachedSize(int size) const1975 void RegisterTaskResponse::SetCachedSize(int size) const {
1976 _impl_._cached_size_.Set(size);
1977 }
1978
Clear()1979 void RegisterTaskResponse::Clear() {
1980 // @@protoc_insertion_point(message_clear_start:tensorflow.RegisterTaskResponse)
1981 ::uint32_t cached_has_bits = 0;
1982 // Prevent compiler warnings about cached_has_bits being unused
1983 (void) cached_has_bits;
1984
1985 _impl_.leader_incarnation_ = ::uint64_t{0u};
1986 _internal_metadata_.Clear<std::string>();
1987 }
1988
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1989 const char* RegisterTaskResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1990 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1991 while (!ctx->Done(&ptr)) {
1992 ::uint32_t tag;
1993 ptr = ::_pbi::ReadTag(ptr, &tag);
1994 switch (tag >> 3) {
1995 // fixed64 leader_incarnation = 1;
1996 case 1:
1997 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 9)) {
1998 _impl_.leader_incarnation_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::uint64_t>(ptr);
1999 ptr += sizeof(::uint64_t);
2000 } else {
2001 goto handle_unusual;
2002 }
2003 continue;
2004 default:
2005 goto handle_unusual;
2006 } // switch
2007 handle_unusual:
2008 if ((tag == 0) || ((tag & 7) == 4)) {
2009 CHK_(ptr);
2010 ctx->SetLastTag(tag);
2011 goto message_done;
2012 }
2013 ptr = UnknownFieldParse(
2014 tag,
2015 _internal_metadata_.mutable_unknown_fields<std::string>(),
2016 ptr, ctx);
2017 CHK_(ptr != nullptr);
2018 } // while
2019 message_done:
2020 return ptr;
2021 failure:
2022 ptr = nullptr;
2023 goto message_done;
2024 #undef CHK_
2025 }
2026
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2027 ::uint8_t* RegisterTaskResponse::_InternalSerialize(
2028 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2029 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.RegisterTaskResponse)
2030 ::uint32_t cached_has_bits = 0;
2031 (void) cached_has_bits;
2032
2033 // fixed64 leader_incarnation = 1;
2034 if (this->_internal_leader_incarnation() != 0) {
2035 target = stream->EnsureSpace(target);
2036 target = ::_pbi::WireFormatLite::WriteFixed64ToArray(1, this->_internal_leader_incarnation(), target);
2037 }
2038
2039 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2040 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2041 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2042 }
2043 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.RegisterTaskResponse)
2044 return target;
2045 }
2046
ByteSizeLong() const2047 size_t RegisterTaskResponse::ByteSizeLong() const {
2048 // @@protoc_insertion_point(message_byte_size_start:tensorflow.RegisterTaskResponse)
2049 size_t total_size = 0;
2050
2051 ::uint32_t cached_has_bits = 0;
2052 // Prevent compiler warnings about cached_has_bits being unused
2053 (void) cached_has_bits;
2054
2055 // fixed64 leader_incarnation = 1;
2056 if (this->_internal_leader_incarnation() != 0) {
2057 total_size += 1 + 8;
2058 }
2059
2060 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2061 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2062 }
2063 int cached_size = ::_pbi::ToCachedSize(total_size);
2064 SetCachedSize(cached_size);
2065 return total_size;
2066 }
2067
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2068 void RegisterTaskResponse::CheckTypeAndMergeFrom(
2069 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2070 MergeFrom(*::_pbi::DownCast<const RegisterTaskResponse*>(
2071 &from));
2072 }
2073
MergeFrom(const RegisterTaskResponse & from)2074 void RegisterTaskResponse::MergeFrom(const RegisterTaskResponse& from) {
2075 RegisterTaskResponse* const _this = this;
2076 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.RegisterTaskResponse)
2077 GOOGLE_DCHECK_NE(&from, _this);
2078 ::uint32_t cached_has_bits = 0;
2079 (void) cached_has_bits;
2080
2081 if (from._internal_leader_incarnation() != 0) {
2082 _this->_internal_set_leader_incarnation(from._internal_leader_incarnation());
2083 }
2084 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2085 }
2086
CopyFrom(const RegisterTaskResponse & from)2087 void RegisterTaskResponse::CopyFrom(const RegisterTaskResponse& from) {
2088 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.RegisterTaskResponse)
2089 if (&from == this) return;
2090 Clear();
2091 MergeFrom(from);
2092 }
2093
IsInitialized() const2094 bool RegisterTaskResponse::IsInitialized() const {
2095 return true;
2096 }
2097
InternalSwap(RegisterTaskResponse * other)2098 void RegisterTaskResponse::InternalSwap(RegisterTaskResponse* other) {
2099 using std::swap;
2100 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2101 swap(_impl_.leader_incarnation_, other->_impl_.leader_incarnation_);
2102 }
2103
GetTypeName() const2104 std::string RegisterTaskResponse::GetTypeName() const {
2105 return "tensorflow.RegisterTaskResponse";
2106 }
2107
2108
2109 // ===================================================================
2110
2111 class HeartbeatRequest::_Internal {
2112 public:
2113 static const ::tensorflow::CoordinatedTask& source_task(const HeartbeatRequest* msg);
2114 };
2115
2116 const ::tensorflow::CoordinatedTask&
source_task(const HeartbeatRequest * msg)2117 HeartbeatRequest::_Internal::source_task(const HeartbeatRequest* msg) {
2118 return *msg->_impl_.source_task_;
2119 }
HeartbeatRequest(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2120 HeartbeatRequest::HeartbeatRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2121 bool is_message_owned)
2122 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2123 SharedCtor(arena, is_message_owned);
2124 // @@protoc_insertion_point(arena_constructor:tensorflow.HeartbeatRequest)
2125 }
HeartbeatRequest(const HeartbeatRequest & from)2126 HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& from)
2127 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2128 HeartbeatRequest* const _this = this; (void)_this;
2129 new (&_impl_) Impl_{
2130 decltype(_impl_.source_task_){nullptr}
2131 , decltype(_impl_.incarnation_){}
2132 , /*decltype(_impl_._cached_size_)*/{}};
2133
2134 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2135 if (from._internal_has_source_task()) {
2136 _this->_impl_.source_task_ = new ::tensorflow::CoordinatedTask(*from._impl_.source_task_);
2137 }
2138 _this->_impl_.incarnation_ = from._impl_.incarnation_;
2139 // @@protoc_insertion_point(copy_constructor:tensorflow.HeartbeatRequest)
2140 }
2141
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2142 inline void HeartbeatRequest::SharedCtor(
2143 ::_pb::Arena* arena, bool is_message_owned) {
2144 (void)arena;
2145 (void)is_message_owned;
2146 new (&_impl_) Impl_{
2147 decltype(_impl_.source_task_){nullptr}
2148 , decltype(_impl_.incarnation_){::uint64_t{0u}}
2149 , /*decltype(_impl_._cached_size_)*/{}
2150 };
2151 }
2152
~HeartbeatRequest()2153 HeartbeatRequest::~HeartbeatRequest() {
2154 // @@protoc_insertion_point(destructor:tensorflow.HeartbeatRequest)
2155 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2156 (void)arena;
2157 return;
2158 }
2159 SharedDtor();
2160 }
2161
SharedDtor()2162 inline void HeartbeatRequest::SharedDtor() {
2163 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2164 if (this != internal_default_instance()) delete _impl_.source_task_;
2165 }
2166
SetCachedSize(int size) const2167 void HeartbeatRequest::SetCachedSize(int size) const {
2168 _impl_._cached_size_.Set(size);
2169 }
2170
Clear()2171 void HeartbeatRequest::Clear() {
2172 // @@protoc_insertion_point(message_clear_start:tensorflow.HeartbeatRequest)
2173 ::uint32_t cached_has_bits = 0;
2174 // Prevent compiler warnings about cached_has_bits being unused
2175 (void) cached_has_bits;
2176
2177 if (GetArenaForAllocation() == nullptr && _impl_.source_task_ != nullptr) {
2178 delete _impl_.source_task_;
2179 }
2180 _impl_.source_task_ = nullptr;
2181 _impl_.incarnation_ = ::uint64_t{0u};
2182 _internal_metadata_.Clear<std::string>();
2183 }
2184
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2185 const char* HeartbeatRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2186 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2187 while (!ctx->Done(&ptr)) {
2188 ::uint32_t tag;
2189 ptr = ::_pbi::ReadTag(ptr, &tag);
2190 switch (tag >> 3) {
2191 // fixed64 incarnation = 3;
2192 case 3:
2193 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 25)) {
2194 _impl_.incarnation_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::uint64_t>(ptr);
2195 ptr += sizeof(::uint64_t);
2196 } else {
2197 goto handle_unusual;
2198 }
2199 continue;
2200 // .tensorflow.CoordinatedTask source_task = 4;
2201 case 4:
2202 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
2203 ptr = ctx->ParseMessage(_internal_mutable_source_task(), ptr);
2204 CHK_(ptr);
2205 } else {
2206 goto handle_unusual;
2207 }
2208 continue;
2209 default:
2210 goto handle_unusual;
2211 } // switch
2212 handle_unusual:
2213 if ((tag == 0) || ((tag & 7) == 4)) {
2214 CHK_(ptr);
2215 ctx->SetLastTag(tag);
2216 goto message_done;
2217 }
2218 ptr = UnknownFieldParse(
2219 tag,
2220 _internal_metadata_.mutable_unknown_fields<std::string>(),
2221 ptr, ctx);
2222 CHK_(ptr != nullptr);
2223 } // while
2224 message_done:
2225 return ptr;
2226 failure:
2227 ptr = nullptr;
2228 goto message_done;
2229 #undef CHK_
2230 }
2231
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2232 ::uint8_t* HeartbeatRequest::_InternalSerialize(
2233 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2234 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.HeartbeatRequest)
2235 ::uint32_t cached_has_bits = 0;
2236 (void) cached_has_bits;
2237
2238 // fixed64 incarnation = 3;
2239 if (this->_internal_incarnation() != 0) {
2240 target = stream->EnsureSpace(target);
2241 target = ::_pbi::WireFormatLite::WriteFixed64ToArray(3, this->_internal_incarnation(), target);
2242 }
2243
2244 // .tensorflow.CoordinatedTask source_task = 4;
2245 if (this->_internal_has_source_task()) {
2246 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
2247 InternalWriteMessage(4, _Internal::source_task(this),
2248 _Internal::source_task(this).GetCachedSize(), target, stream);
2249 }
2250
2251 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2252 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2253 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2254 }
2255 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.HeartbeatRequest)
2256 return target;
2257 }
2258
ByteSizeLong() const2259 size_t HeartbeatRequest::ByteSizeLong() const {
2260 // @@protoc_insertion_point(message_byte_size_start:tensorflow.HeartbeatRequest)
2261 size_t total_size = 0;
2262
2263 ::uint32_t cached_has_bits = 0;
2264 // Prevent compiler warnings about cached_has_bits being unused
2265 (void) cached_has_bits;
2266
2267 // .tensorflow.CoordinatedTask source_task = 4;
2268 if (this->_internal_has_source_task()) {
2269 total_size += 1 +
2270 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
2271 *_impl_.source_task_);
2272 }
2273
2274 // fixed64 incarnation = 3;
2275 if (this->_internal_incarnation() != 0) {
2276 total_size += 1 + 8;
2277 }
2278
2279 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2280 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2281 }
2282 int cached_size = ::_pbi::ToCachedSize(total_size);
2283 SetCachedSize(cached_size);
2284 return total_size;
2285 }
2286
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2287 void HeartbeatRequest::CheckTypeAndMergeFrom(
2288 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2289 MergeFrom(*::_pbi::DownCast<const HeartbeatRequest*>(
2290 &from));
2291 }
2292
MergeFrom(const HeartbeatRequest & from)2293 void HeartbeatRequest::MergeFrom(const HeartbeatRequest& from) {
2294 HeartbeatRequest* const _this = this;
2295 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.HeartbeatRequest)
2296 GOOGLE_DCHECK_NE(&from, _this);
2297 ::uint32_t cached_has_bits = 0;
2298 (void) cached_has_bits;
2299
2300 if (from._internal_has_source_task()) {
2301 _this->_internal_mutable_source_task()->::tensorflow::CoordinatedTask::MergeFrom(
2302 from._internal_source_task());
2303 }
2304 if (from._internal_incarnation() != 0) {
2305 _this->_internal_set_incarnation(from._internal_incarnation());
2306 }
2307 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2308 }
2309
CopyFrom(const HeartbeatRequest & from)2310 void HeartbeatRequest::CopyFrom(const HeartbeatRequest& from) {
2311 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.HeartbeatRequest)
2312 if (&from == this) return;
2313 Clear();
2314 MergeFrom(from);
2315 }
2316
IsInitialized() const2317 bool HeartbeatRequest::IsInitialized() const {
2318 return true;
2319 }
2320
InternalSwap(HeartbeatRequest * other)2321 void HeartbeatRequest::InternalSwap(HeartbeatRequest* other) {
2322 using std::swap;
2323 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2324 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2325 PROTOBUF_FIELD_OFFSET(HeartbeatRequest, _impl_.incarnation_)
2326 + sizeof(HeartbeatRequest::_impl_.incarnation_) // NOLINT
2327 - PROTOBUF_FIELD_OFFSET(HeartbeatRequest, _impl_.source_task_)>(
2328 reinterpret_cast<char*>(&_impl_.source_task_),
2329 reinterpret_cast<char*>(&other->_impl_.source_task_));
2330 }
2331
GetTypeName() const2332 std::string HeartbeatRequest::GetTypeName() const {
2333 return "tensorflow.HeartbeatRequest";
2334 }
2335
2336
2337 // ===================================================================
2338
2339 class HeartbeatResponse::_Internal {
2340 public:
2341 };
2342
HeartbeatResponse(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2343 HeartbeatResponse::HeartbeatResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2344 bool is_message_owned)
2345 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2346 SharedCtor(arena, is_message_owned);
2347 // @@protoc_insertion_point(arena_constructor:tensorflow.HeartbeatResponse)
2348 }
HeartbeatResponse(const HeartbeatResponse & from)2349 HeartbeatResponse::HeartbeatResponse(const HeartbeatResponse& from)
2350 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2351 HeartbeatResponse* const _this = this; (void)_this;
2352 new (&_impl_) Impl_{
2353 decltype(_impl_.leader_incarnation_){}
2354 , /*decltype(_impl_._cached_size_)*/{}};
2355
2356 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2357 _this->_impl_.leader_incarnation_ = from._impl_.leader_incarnation_;
2358 // @@protoc_insertion_point(copy_constructor:tensorflow.HeartbeatResponse)
2359 }
2360
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2361 inline void HeartbeatResponse::SharedCtor(
2362 ::_pb::Arena* arena, bool is_message_owned) {
2363 (void)arena;
2364 (void)is_message_owned;
2365 new (&_impl_) Impl_{
2366 decltype(_impl_.leader_incarnation_){::uint64_t{0u}}
2367 , /*decltype(_impl_._cached_size_)*/{}
2368 };
2369 }
2370
~HeartbeatResponse()2371 HeartbeatResponse::~HeartbeatResponse() {
2372 // @@protoc_insertion_point(destructor:tensorflow.HeartbeatResponse)
2373 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2374 (void)arena;
2375 return;
2376 }
2377 SharedDtor();
2378 }
2379
SharedDtor()2380 inline void HeartbeatResponse::SharedDtor() {
2381 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2382 }
2383
SetCachedSize(int size) const2384 void HeartbeatResponse::SetCachedSize(int size) const {
2385 _impl_._cached_size_.Set(size);
2386 }
2387
Clear()2388 void HeartbeatResponse::Clear() {
2389 // @@protoc_insertion_point(message_clear_start:tensorflow.HeartbeatResponse)
2390 ::uint32_t cached_has_bits = 0;
2391 // Prevent compiler warnings about cached_has_bits being unused
2392 (void) cached_has_bits;
2393
2394 _impl_.leader_incarnation_ = ::uint64_t{0u};
2395 _internal_metadata_.Clear<std::string>();
2396 }
2397
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2398 const char* HeartbeatResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2399 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2400 while (!ctx->Done(&ptr)) {
2401 ::uint32_t tag;
2402 ptr = ::_pbi::ReadTag(ptr, &tag);
2403 switch (tag >> 3) {
2404 // fixed64 leader_incarnation = 1;
2405 case 1:
2406 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 9)) {
2407 _impl_.leader_incarnation_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::uint64_t>(ptr);
2408 ptr += sizeof(::uint64_t);
2409 } else {
2410 goto handle_unusual;
2411 }
2412 continue;
2413 default:
2414 goto handle_unusual;
2415 } // switch
2416 handle_unusual:
2417 if ((tag == 0) || ((tag & 7) == 4)) {
2418 CHK_(ptr);
2419 ctx->SetLastTag(tag);
2420 goto message_done;
2421 }
2422 ptr = UnknownFieldParse(
2423 tag,
2424 _internal_metadata_.mutable_unknown_fields<std::string>(),
2425 ptr, ctx);
2426 CHK_(ptr != nullptr);
2427 } // while
2428 message_done:
2429 return ptr;
2430 failure:
2431 ptr = nullptr;
2432 goto message_done;
2433 #undef CHK_
2434 }
2435
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2436 ::uint8_t* HeartbeatResponse::_InternalSerialize(
2437 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2438 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.HeartbeatResponse)
2439 ::uint32_t cached_has_bits = 0;
2440 (void) cached_has_bits;
2441
2442 // fixed64 leader_incarnation = 1;
2443 if (this->_internal_leader_incarnation() != 0) {
2444 target = stream->EnsureSpace(target);
2445 target = ::_pbi::WireFormatLite::WriteFixed64ToArray(1, this->_internal_leader_incarnation(), target);
2446 }
2447
2448 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2449 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2450 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2451 }
2452 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.HeartbeatResponse)
2453 return target;
2454 }
2455
ByteSizeLong() const2456 size_t HeartbeatResponse::ByteSizeLong() const {
2457 // @@protoc_insertion_point(message_byte_size_start:tensorflow.HeartbeatResponse)
2458 size_t total_size = 0;
2459
2460 ::uint32_t cached_has_bits = 0;
2461 // Prevent compiler warnings about cached_has_bits being unused
2462 (void) cached_has_bits;
2463
2464 // fixed64 leader_incarnation = 1;
2465 if (this->_internal_leader_incarnation() != 0) {
2466 total_size += 1 + 8;
2467 }
2468
2469 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2470 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2471 }
2472 int cached_size = ::_pbi::ToCachedSize(total_size);
2473 SetCachedSize(cached_size);
2474 return total_size;
2475 }
2476
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2477 void HeartbeatResponse::CheckTypeAndMergeFrom(
2478 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2479 MergeFrom(*::_pbi::DownCast<const HeartbeatResponse*>(
2480 &from));
2481 }
2482
MergeFrom(const HeartbeatResponse & from)2483 void HeartbeatResponse::MergeFrom(const HeartbeatResponse& from) {
2484 HeartbeatResponse* const _this = this;
2485 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.HeartbeatResponse)
2486 GOOGLE_DCHECK_NE(&from, _this);
2487 ::uint32_t cached_has_bits = 0;
2488 (void) cached_has_bits;
2489
2490 if (from._internal_leader_incarnation() != 0) {
2491 _this->_internal_set_leader_incarnation(from._internal_leader_incarnation());
2492 }
2493 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2494 }
2495
CopyFrom(const HeartbeatResponse & from)2496 void HeartbeatResponse::CopyFrom(const HeartbeatResponse& from) {
2497 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.HeartbeatResponse)
2498 if (&from == this) return;
2499 Clear();
2500 MergeFrom(from);
2501 }
2502
IsInitialized() const2503 bool HeartbeatResponse::IsInitialized() const {
2504 return true;
2505 }
2506
InternalSwap(HeartbeatResponse * other)2507 void HeartbeatResponse::InternalSwap(HeartbeatResponse* other) {
2508 using std::swap;
2509 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2510 swap(_impl_.leader_incarnation_, other->_impl_.leader_incarnation_);
2511 }
2512
GetTypeName() const2513 std::string HeartbeatResponse::GetTypeName() const {
2514 return "tensorflow.HeartbeatResponse";
2515 }
2516
2517
2518 // ===================================================================
2519
2520 class WaitForAllTasksRequest::_Internal {
2521 public:
2522 static const ::tensorflow::CoordinationServiceDeviceInfo& local_device_info(const WaitForAllTasksRequest* msg);
2523 static const ::tensorflow::CoordinatedTask& source_task(const WaitForAllTasksRequest* msg);
2524 };
2525
2526 const ::tensorflow::CoordinationServiceDeviceInfo&
local_device_info(const WaitForAllTasksRequest * msg)2527 WaitForAllTasksRequest::_Internal::local_device_info(const WaitForAllTasksRequest* msg) {
2528 return *msg->_impl_.local_device_info_;
2529 }
2530 const ::tensorflow::CoordinatedTask&
source_task(const WaitForAllTasksRequest * msg)2531 WaitForAllTasksRequest::_Internal::source_task(const WaitForAllTasksRequest* msg) {
2532 return *msg->_impl_.source_task_;
2533 }
WaitForAllTasksRequest(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2534 WaitForAllTasksRequest::WaitForAllTasksRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2535 bool is_message_owned)
2536 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2537 SharedCtor(arena, is_message_owned);
2538 // @@protoc_insertion_point(arena_constructor:tensorflow.WaitForAllTasksRequest)
2539 }
WaitForAllTasksRequest(const WaitForAllTasksRequest & from)2540 WaitForAllTasksRequest::WaitForAllTasksRequest(const WaitForAllTasksRequest& from)
2541 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2542 WaitForAllTasksRequest* const _this = this; (void)_this;
2543 new (&_impl_) Impl_{
2544 decltype(_impl_.local_device_info_){nullptr}
2545 , decltype(_impl_.source_task_){nullptr}
2546 , /*decltype(_impl_._cached_size_)*/{}};
2547
2548 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2549 if (from._internal_has_local_device_info()) {
2550 _this->_impl_.local_device_info_ = new ::tensorflow::CoordinationServiceDeviceInfo(*from._impl_.local_device_info_);
2551 }
2552 if (from._internal_has_source_task()) {
2553 _this->_impl_.source_task_ = new ::tensorflow::CoordinatedTask(*from._impl_.source_task_);
2554 }
2555 // @@protoc_insertion_point(copy_constructor:tensorflow.WaitForAllTasksRequest)
2556 }
2557
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2558 inline void WaitForAllTasksRequest::SharedCtor(
2559 ::_pb::Arena* arena, bool is_message_owned) {
2560 (void)arena;
2561 (void)is_message_owned;
2562 new (&_impl_) Impl_{
2563 decltype(_impl_.local_device_info_){nullptr}
2564 , decltype(_impl_.source_task_){nullptr}
2565 , /*decltype(_impl_._cached_size_)*/{}
2566 };
2567 }
2568
~WaitForAllTasksRequest()2569 WaitForAllTasksRequest::~WaitForAllTasksRequest() {
2570 // @@protoc_insertion_point(destructor:tensorflow.WaitForAllTasksRequest)
2571 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2572 (void)arena;
2573 return;
2574 }
2575 SharedDtor();
2576 }
2577
SharedDtor()2578 inline void WaitForAllTasksRequest::SharedDtor() {
2579 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2580 if (this != internal_default_instance()) delete _impl_.local_device_info_;
2581 if (this != internal_default_instance()) delete _impl_.source_task_;
2582 }
2583
SetCachedSize(int size) const2584 void WaitForAllTasksRequest::SetCachedSize(int size) const {
2585 _impl_._cached_size_.Set(size);
2586 }
2587
Clear()2588 void WaitForAllTasksRequest::Clear() {
2589 // @@protoc_insertion_point(message_clear_start:tensorflow.WaitForAllTasksRequest)
2590 ::uint32_t cached_has_bits = 0;
2591 // Prevent compiler warnings about cached_has_bits being unused
2592 (void) cached_has_bits;
2593
2594 if (GetArenaForAllocation() == nullptr && _impl_.local_device_info_ != nullptr) {
2595 delete _impl_.local_device_info_;
2596 }
2597 _impl_.local_device_info_ = nullptr;
2598 if (GetArenaForAllocation() == nullptr && _impl_.source_task_ != nullptr) {
2599 delete _impl_.source_task_;
2600 }
2601 _impl_.source_task_ = nullptr;
2602 _internal_metadata_.Clear<std::string>();
2603 }
2604
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2605 const char* WaitForAllTasksRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2606 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2607 while (!ctx->Done(&ptr)) {
2608 ::uint32_t tag;
2609 ptr = ::_pbi::ReadTag(ptr, &tag);
2610 switch (tag >> 3) {
2611 // .tensorflow.CoordinationServiceDeviceInfo local_device_info = 4;
2612 case 4:
2613 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
2614 ptr = ctx->ParseMessage(_internal_mutable_local_device_info(), ptr);
2615 CHK_(ptr);
2616 } else {
2617 goto handle_unusual;
2618 }
2619 continue;
2620 // .tensorflow.CoordinatedTask source_task = 5;
2621 case 5:
2622 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
2623 ptr = ctx->ParseMessage(_internal_mutable_source_task(), ptr);
2624 CHK_(ptr);
2625 } else {
2626 goto handle_unusual;
2627 }
2628 continue;
2629 default:
2630 goto handle_unusual;
2631 } // switch
2632 handle_unusual:
2633 if ((tag == 0) || ((tag & 7) == 4)) {
2634 CHK_(ptr);
2635 ctx->SetLastTag(tag);
2636 goto message_done;
2637 }
2638 ptr = UnknownFieldParse(
2639 tag,
2640 _internal_metadata_.mutable_unknown_fields<std::string>(),
2641 ptr, ctx);
2642 CHK_(ptr != nullptr);
2643 } // while
2644 message_done:
2645 return ptr;
2646 failure:
2647 ptr = nullptr;
2648 goto message_done;
2649 #undef CHK_
2650 }
2651
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2652 ::uint8_t* WaitForAllTasksRequest::_InternalSerialize(
2653 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2654 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.WaitForAllTasksRequest)
2655 ::uint32_t cached_has_bits = 0;
2656 (void) cached_has_bits;
2657
2658 // .tensorflow.CoordinationServiceDeviceInfo local_device_info = 4;
2659 if (this->_internal_has_local_device_info()) {
2660 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
2661 InternalWriteMessage(4, _Internal::local_device_info(this),
2662 _Internal::local_device_info(this).GetCachedSize(), target, stream);
2663 }
2664
2665 // .tensorflow.CoordinatedTask source_task = 5;
2666 if (this->_internal_has_source_task()) {
2667 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
2668 InternalWriteMessage(5, _Internal::source_task(this),
2669 _Internal::source_task(this).GetCachedSize(), target, stream);
2670 }
2671
2672 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2673 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2674 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2675 }
2676 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.WaitForAllTasksRequest)
2677 return target;
2678 }
2679
ByteSizeLong() const2680 size_t WaitForAllTasksRequest::ByteSizeLong() const {
2681 // @@protoc_insertion_point(message_byte_size_start:tensorflow.WaitForAllTasksRequest)
2682 size_t total_size = 0;
2683
2684 ::uint32_t cached_has_bits = 0;
2685 // Prevent compiler warnings about cached_has_bits being unused
2686 (void) cached_has_bits;
2687
2688 // .tensorflow.CoordinationServiceDeviceInfo local_device_info = 4;
2689 if (this->_internal_has_local_device_info()) {
2690 total_size += 1 +
2691 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
2692 *_impl_.local_device_info_);
2693 }
2694
2695 // .tensorflow.CoordinatedTask source_task = 5;
2696 if (this->_internal_has_source_task()) {
2697 total_size += 1 +
2698 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
2699 *_impl_.source_task_);
2700 }
2701
2702 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2703 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2704 }
2705 int cached_size = ::_pbi::ToCachedSize(total_size);
2706 SetCachedSize(cached_size);
2707 return total_size;
2708 }
2709
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2710 void WaitForAllTasksRequest::CheckTypeAndMergeFrom(
2711 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2712 MergeFrom(*::_pbi::DownCast<const WaitForAllTasksRequest*>(
2713 &from));
2714 }
2715
MergeFrom(const WaitForAllTasksRequest & from)2716 void WaitForAllTasksRequest::MergeFrom(const WaitForAllTasksRequest& from) {
2717 WaitForAllTasksRequest* const _this = this;
2718 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.WaitForAllTasksRequest)
2719 GOOGLE_DCHECK_NE(&from, _this);
2720 ::uint32_t cached_has_bits = 0;
2721 (void) cached_has_bits;
2722
2723 if (from._internal_has_local_device_info()) {
2724 _this->_internal_mutable_local_device_info()->::tensorflow::CoordinationServiceDeviceInfo::MergeFrom(
2725 from._internal_local_device_info());
2726 }
2727 if (from._internal_has_source_task()) {
2728 _this->_internal_mutable_source_task()->::tensorflow::CoordinatedTask::MergeFrom(
2729 from._internal_source_task());
2730 }
2731 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2732 }
2733
CopyFrom(const WaitForAllTasksRequest & from)2734 void WaitForAllTasksRequest::CopyFrom(const WaitForAllTasksRequest& from) {
2735 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.WaitForAllTasksRequest)
2736 if (&from == this) return;
2737 Clear();
2738 MergeFrom(from);
2739 }
2740
IsInitialized() const2741 bool WaitForAllTasksRequest::IsInitialized() const {
2742 return true;
2743 }
2744
InternalSwap(WaitForAllTasksRequest * other)2745 void WaitForAllTasksRequest::InternalSwap(WaitForAllTasksRequest* other) {
2746 using std::swap;
2747 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2748 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2749 PROTOBUF_FIELD_OFFSET(WaitForAllTasksRequest, _impl_.source_task_)
2750 + sizeof(WaitForAllTasksRequest::_impl_.source_task_) // NOLINT
2751 - PROTOBUF_FIELD_OFFSET(WaitForAllTasksRequest, _impl_.local_device_info_)>(
2752 reinterpret_cast<char*>(&_impl_.local_device_info_),
2753 reinterpret_cast<char*>(&other->_impl_.local_device_info_));
2754 }
2755
GetTypeName() const2756 std::string WaitForAllTasksRequest::GetTypeName() const {
2757 return "tensorflow.WaitForAllTasksRequest";
2758 }
2759
2760
2761 // ===================================================================
2762
2763 class WaitForAllTasksResponse::_Internal {
2764 public:
2765 static const ::tensorflow::CoordinationServiceDeviceInfo& cluster_device_info(const WaitForAllTasksResponse* msg);
2766 };
2767
2768 const ::tensorflow::CoordinationServiceDeviceInfo&
cluster_device_info(const WaitForAllTasksResponse * msg)2769 WaitForAllTasksResponse::_Internal::cluster_device_info(const WaitForAllTasksResponse* msg) {
2770 return *msg->_impl_.cluster_device_info_;
2771 }
WaitForAllTasksResponse(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2772 WaitForAllTasksResponse::WaitForAllTasksResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2773 bool is_message_owned)
2774 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2775 SharedCtor(arena, is_message_owned);
2776 // @@protoc_insertion_point(arena_constructor:tensorflow.WaitForAllTasksResponse)
2777 }
WaitForAllTasksResponse(const WaitForAllTasksResponse & from)2778 WaitForAllTasksResponse::WaitForAllTasksResponse(const WaitForAllTasksResponse& from)
2779 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2780 WaitForAllTasksResponse* const _this = this; (void)_this;
2781 new (&_impl_) Impl_{
2782 decltype(_impl_.cluster_device_info_){nullptr}
2783 , decltype(_impl_.leader_incarnation_){}
2784 , /*decltype(_impl_._cached_size_)*/{}};
2785
2786 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2787 if (from._internal_has_cluster_device_info()) {
2788 _this->_impl_.cluster_device_info_ = new ::tensorflow::CoordinationServiceDeviceInfo(*from._impl_.cluster_device_info_);
2789 }
2790 _this->_impl_.leader_incarnation_ = from._impl_.leader_incarnation_;
2791 // @@protoc_insertion_point(copy_constructor:tensorflow.WaitForAllTasksResponse)
2792 }
2793
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2794 inline void WaitForAllTasksResponse::SharedCtor(
2795 ::_pb::Arena* arena, bool is_message_owned) {
2796 (void)arena;
2797 (void)is_message_owned;
2798 new (&_impl_) Impl_{
2799 decltype(_impl_.cluster_device_info_){nullptr}
2800 , decltype(_impl_.leader_incarnation_){::uint64_t{0u}}
2801 , /*decltype(_impl_._cached_size_)*/{}
2802 };
2803 }
2804
~WaitForAllTasksResponse()2805 WaitForAllTasksResponse::~WaitForAllTasksResponse() {
2806 // @@protoc_insertion_point(destructor:tensorflow.WaitForAllTasksResponse)
2807 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2808 (void)arena;
2809 return;
2810 }
2811 SharedDtor();
2812 }
2813
SharedDtor()2814 inline void WaitForAllTasksResponse::SharedDtor() {
2815 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2816 if (this != internal_default_instance()) delete _impl_.cluster_device_info_;
2817 }
2818
SetCachedSize(int size) const2819 void WaitForAllTasksResponse::SetCachedSize(int size) const {
2820 _impl_._cached_size_.Set(size);
2821 }
2822
Clear()2823 void WaitForAllTasksResponse::Clear() {
2824 // @@protoc_insertion_point(message_clear_start:tensorflow.WaitForAllTasksResponse)
2825 ::uint32_t cached_has_bits = 0;
2826 // Prevent compiler warnings about cached_has_bits being unused
2827 (void) cached_has_bits;
2828
2829 if (GetArenaForAllocation() == nullptr && _impl_.cluster_device_info_ != nullptr) {
2830 delete _impl_.cluster_device_info_;
2831 }
2832 _impl_.cluster_device_info_ = nullptr;
2833 _impl_.leader_incarnation_ = ::uint64_t{0u};
2834 _internal_metadata_.Clear<std::string>();
2835 }
2836
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2837 const char* WaitForAllTasksResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2838 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2839 while (!ctx->Done(&ptr)) {
2840 ::uint32_t tag;
2841 ptr = ::_pbi::ReadTag(ptr, &tag);
2842 switch (tag >> 3) {
2843 // fixed64 leader_incarnation = 1;
2844 case 1:
2845 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 9)) {
2846 _impl_.leader_incarnation_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::uint64_t>(ptr);
2847 ptr += sizeof(::uint64_t);
2848 } else {
2849 goto handle_unusual;
2850 }
2851 continue;
2852 // .tensorflow.CoordinationServiceDeviceInfo cluster_device_info = 3;
2853 case 3:
2854 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
2855 ptr = ctx->ParseMessage(_internal_mutable_cluster_device_info(), ptr);
2856 CHK_(ptr);
2857 } else {
2858 goto handle_unusual;
2859 }
2860 continue;
2861 default:
2862 goto handle_unusual;
2863 } // switch
2864 handle_unusual:
2865 if ((tag == 0) || ((tag & 7) == 4)) {
2866 CHK_(ptr);
2867 ctx->SetLastTag(tag);
2868 goto message_done;
2869 }
2870 ptr = UnknownFieldParse(
2871 tag,
2872 _internal_metadata_.mutable_unknown_fields<std::string>(),
2873 ptr, ctx);
2874 CHK_(ptr != nullptr);
2875 } // while
2876 message_done:
2877 return ptr;
2878 failure:
2879 ptr = nullptr;
2880 goto message_done;
2881 #undef CHK_
2882 }
2883
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2884 ::uint8_t* WaitForAllTasksResponse::_InternalSerialize(
2885 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2886 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.WaitForAllTasksResponse)
2887 ::uint32_t cached_has_bits = 0;
2888 (void) cached_has_bits;
2889
2890 // fixed64 leader_incarnation = 1;
2891 if (this->_internal_leader_incarnation() != 0) {
2892 target = stream->EnsureSpace(target);
2893 target = ::_pbi::WireFormatLite::WriteFixed64ToArray(1, this->_internal_leader_incarnation(), target);
2894 }
2895
2896 // .tensorflow.CoordinationServiceDeviceInfo cluster_device_info = 3;
2897 if (this->_internal_has_cluster_device_info()) {
2898 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
2899 InternalWriteMessage(3, _Internal::cluster_device_info(this),
2900 _Internal::cluster_device_info(this).GetCachedSize(), target, stream);
2901 }
2902
2903 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2904 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2905 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2906 }
2907 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.WaitForAllTasksResponse)
2908 return target;
2909 }
2910
ByteSizeLong() const2911 size_t WaitForAllTasksResponse::ByteSizeLong() const {
2912 // @@protoc_insertion_point(message_byte_size_start:tensorflow.WaitForAllTasksResponse)
2913 size_t total_size = 0;
2914
2915 ::uint32_t cached_has_bits = 0;
2916 // Prevent compiler warnings about cached_has_bits being unused
2917 (void) cached_has_bits;
2918
2919 // .tensorflow.CoordinationServiceDeviceInfo cluster_device_info = 3;
2920 if (this->_internal_has_cluster_device_info()) {
2921 total_size += 1 +
2922 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
2923 *_impl_.cluster_device_info_);
2924 }
2925
2926 // fixed64 leader_incarnation = 1;
2927 if (this->_internal_leader_incarnation() != 0) {
2928 total_size += 1 + 8;
2929 }
2930
2931 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2932 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2933 }
2934 int cached_size = ::_pbi::ToCachedSize(total_size);
2935 SetCachedSize(cached_size);
2936 return total_size;
2937 }
2938
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2939 void WaitForAllTasksResponse::CheckTypeAndMergeFrom(
2940 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2941 MergeFrom(*::_pbi::DownCast<const WaitForAllTasksResponse*>(
2942 &from));
2943 }
2944
MergeFrom(const WaitForAllTasksResponse & from)2945 void WaitForAllTasksResponse::MergeFrom(const WaitForAllTasksResponse& from) {
2946 WaitForAllTasksResponse* const _this = this;
2947 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.WaitForAllTasksResponse)
2948 GOOGLE_DCHECK_NE(&from, _this);
2949 ::uint32_t cached_has_bits = 0;
2950 (void) cached_has_bits;
2951
2952 if (from._internal_has_cluster_device_info()) {
2953 _this->_internal_mutable_cluster_device_info()->::tensorflow::CoordinationServiceDeviceInfo::MergeFrom(
2954 from._internal_cluster_device_info());
2955 }
2956 if (from._internal_leader_incarnation() != 0) {
2957 _this->_internal_set_leader_incarnation(from._internal_leader_incarnation());
2958 }
2959 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2960 }
2961
CopyFrom(const WaitForAllTasksResponse & from)2962 void WaitForAllTasksResponse::CopyFrom(const WaitForAllTasksResponse& from) {
2963 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.WaitForAllTasksResponse)
2964 if (&from == this) return;
2965 Clear();
2966 MergeFrom(from);
2967 }
2968
IsInitialized() const2969 bool WaitForAllTasksResponse::IsInitialized() const {
2970 return true;
2971 }
2972
InternalSwap(WaitForAllTasksResponse * other)2973 void WaitForAllTasksResponse::InternalSwap(WaitForAllTasksResponse* other) {
2974 using std::swap;
2975 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2976 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2977 PROTOBUF_FIELD_OFFSET(WaitForAllTasksResponse, _impl_.leader_incarnation_)
2978 + sizeof(WaitForAllTasksResponse::_impl_.leader_incarnation_) // NOLINT
2979 - PROTOBUF_FIELD_OFFSET(WaitForAllTasksResponse, _impl_.cluster_device_info_)>(
2980 reinterpret_cast<char*>(&_impl_.cluster_device_info_),
2981 reinterpret_cast<char*>(&other->_impl_.cluster_device_info_));
2982 }
2983
GetTypeName() const2984 std::string WaitForAllTasksResponse::GetTypeName() const {
2985 return "tensorflow.WaitForAllTasksResponse";
2986 }
2987
2988
2989 // ===================================================================
2990
2991 class ShutdownTaskRequest::_Internal {
2992 public:
2993 static const ::tensorflow::CoordinatedTask& source_task(const ShutdownTaskRequest* msg);
2994 };
2995
2996 const ::tensorflow::CoordinatedTask&
source_task(const ShutdownTaskRequest * msg)2997 ShutdownTaskRequest::_Internal::source_task(const ShutdownTaskRequest* msg) {
2998 return *msg->_impl_.source_task_;
2999 }
ShutdownTaskRequest(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3000 ShutdownTaskRequest::ShutdownTaskRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3001 bool is_message_owned)
3002 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3003 SharedCtor(arena, is_message_owned);
3004 // @@protoc_insertion_point(arena_constructor:tensorflow.ShutdownTaskRequest)
3005 }
ShutdownTaskRequest(const ShutdownTaskRequest & from)3006 ShutdownTaskRequest::ShutdownTaskRequest(const ShutdownTaskRequest& from)
3007 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3008 ShutdownTaskRequest* const _this = this; (void)_this;
3009 new (&_impl_) Impl_{
3010 decltype(_impl_.source_task_){nullptr}
3011 , /*decltype(_impl_._cached_size_)*/{}};
3012
3013 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3014 if (from._internal_has_source_task()) {
3015 _this->_impl_.source_task_ = new ::tensorflow::CoordinatedTask(*from._impl_.source_task_);
3016 }
3017 // @@protoc_insertion_point(copy_constructor:tensorflow.ShutdownTaskRequest)
3018 }
3019
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3020 inline void ShutdownTaskRequest::SharedCtor(
3021 ::_pb::Arena* arena, bool is_message_owned) {
3022 (void)arena;
3023 (void)is_message_owned;
3024 new (&_impl_) Impl_{
3025 decltype(_impl_.source_task_){nullptr}
3026 , /*decltype(_impl_._cached_size_)*/{}
3027 };
3028 }
3029
~ShutdownTaskRequest()3030 ShutdownTaskRequest::~ShutdownTaskRequest() {
3031 // @@protoc_insertion_point(destructor:tensorflow.ShutdownTaskRequest)
3032 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3033 (void)arena;
3034 return;
3035 }
3036 SharedDtor();
3037 }
3038
SharedDtor()3039 inline void ShutdownTaskRequest::SharedDtor() {
3040 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3041 if (this != internal_default_instance()) delete _impl_.source_task_;
3042 }
3043
SetCachedSize(int size) const3044 void ShutdownTaskRequest::SetCachedSize(int size) const {
3045 _impl_._cached_size_.Set(size);
3046 }
3047
Clear()3048 void ShutdownTaskRequest::Clear() {
3049 // @@protoc_insertion_point(message_clear_start:tensorflow.ShutdownTaskRequest)
3050 ::uint32_t cached_has_bits = 0;
3051 // Prevent compiler warnings about cached_has_bits being unused
3052 (void) cached_has_bits;
3053
3054 if (GetArenaForAllocation() == nullptr && _impl_.source_task_ != nullptr) {
3055 delete _impl_.source_task_;
3056 }
3057 _impl_.source_task_ = nullptr;
3058 _internal_metadata_.Clear<std::string>();
3059 }
3060
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3061 const char* ShutdownTaskRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3062 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3063 while (!ctx->Done(&ptr)) {
3064 ::uint32_t tag;
3065 ptr = ::_pbi::ReadTag(ptr, &tag);
3066 switch (tag >> 3) {
3067 // .tensorflow.CoordinatedTask source_task = 1;
3068 case 1:
3069 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
3070 ptr = ctx->ParseMessage(_internal_mutable_source_task(), ptr);
3071 CHK_(ptr);
3072 } else {
3073 goto handle_unusual;
3074 }
3075 continue;
3076 default:
3077 goto handle_unusual;
3078 } // switch
3079 handle_unusual:
3080 if ((tag == 0) || ((tag & 7) == 4)) {
3081 CHK_(ptr);
3082 ctx->SetLastTag(tag);
3083 goto message_done;
3084 }
3085 ptr = UnknownFieldParse(
3086 tag,
3087 _internal_metadata_.mutable_unknown_fields<std::string>(),
3088 ptr, ctx);
3089 CHK_(ptr != nullptr);
3090 } // while
3091 message_done:
3092 return ptr;
3093 failure:
3094 ptr = nullptr;
3095 goto message_done;
3096 #undef CHK_
3097 }
3098
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3099 ::uint8_t* ShutdownTaskRequest::_InternalSerialize(
3100 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3101 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.ShutdownTaskRequest)
3102 ::uint32_t cached_has_bits = 0;
3103 (void) cached_has_bits;
3104
3105 // .tensorflow.CoordinatedTask source_task = 1;
3106 if (this->_internal_has_source_task()) {
3107 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
3108 InternalWriteMessage(1, _Internal::source_task(this),
3109 _Internal::source_task(this).GetCachedSize(), target, stream);
3110 }
3111
3112 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3113 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3114 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3115 }
3116 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.ShutdownTaskRequest)
3117 return target;
3118 }
3119
ByteSizeLong() const3120 size_t ShutdownTaskRequest::ByteSizeLong() const {
3121 // @@protoc_insertion_point(message_byte_size_start:tensorflow.ShutdownTaskRequest)
3122 size_t total_size = 0;
3123
3124 ::uint32_t cached_has_bits = 0;
3125 // Prevent compiler warnings about cached_has_bits being unused
3126 (void) cached_has_bits;
3127
3128 // .tensorflow.CoordinatedTask source_task = 1;
3129 if (this->_internal_has_source_task()) {
3130 total_size += 1 +
3131 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
3132 *_impl_.source_task_);
3133 }
3134
3135 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3136 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3137 }
3138 int cached_size = ::_pbi::ToCachedSize(total_size);
3139 SetCachedSize(cached_size);
3140 return total_size;
3141 }
3142
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3143 void ShutdownTaskRequest::CheckTypeAndMergeFrom(
3144 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3145 MergeFrom(*::_pbi::DownCast<const ShutdownTaskRequest*>(
3146 &from));
3147 }
3148
MergeFrom(const ShutdownTaskRequest & from)3149 void ShutdownTaskRequest::MergeFrom(const ShutdownTaskRequest& from) {
3150 ShutdownTaskRequest* const _this = this;
3151 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.ShutdownTaskRequest)
3152 GOOGLE_DCHECK_NE(&from, _this);
3153 ::uint32_t cached_has_bits = 0;
3154 (void) cached_has_bits;
3155
3156 if (from._internal_has_source_task()) {
3157 _this->_internal_mutable_source_task()->::tensorflow::CoordinatedTask::MergeFrom(
3158 from._internal_source_task());
3159 }
3160 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3161 }
3162
CopyFrom(const ShutdownTaskRequest & from)3163 void ShutdownTaskRequest::CopyFrom(const ShutdownTaskRequest& from) {
3164 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.ShutdownTaskRequest)
3165 if (&from == this) return;
3166 Clear();
3167 MergeFrom(from);
3168 }
3169
IsInitialized() const3170 bool ShutdownTaskRequest::IsInitialized() const {
3171 return true;
3172 }
3173
InternalSwap(ShutdownTaskRequest * other)3174 void ShutdownTaskRequest::InternalSwap(ShutdownTaskRequest* other) {
3175 using std::swap;
3176 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3177 swap(_impl_.source_task_, other->_impl_.source_task_);
3178 }
3179
GetTypeName() const3180 std::string ShutdownTaskRequest::GetTypeName() const {
3181 return "tensorflow.ShutdownTaskRequest";
3182 }
3183
3184
3185 // ===================================================================
3186
3187 class ShutdownTaskResponse::_Internal {
3188 public:
3189 };
3190
ShutdownTaskResponse(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3191 ShutdownTaskResponse::ShutdownTaskResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3192 bool is_message_owned)
3193 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3194 SharedCtor(arena, is_message_owned);
3195 // @@protoc_insertion_point(arena_constructor:tensorflow.ShutdownTaskResponse)
3196 }
ShutdownTaskResponse(const ShutdownTaskResponse & from)3197 ShutdownTaskResponse::ShutdownTaskResponse(const ShutdownTaskResponse& from)
3198 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3199 ShutdownTaskResponse* const _this = this; (void)_this;
3200 new (&_impl_) Impl_{
3201 /*decltype(_impl_._cached_size_)*/{}};
3202
3203 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3204 // @@protoc_insertion_point(copy_constructor:tensorflow.ShutdownTaskResponse)
3205 }
3206
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3207 inline void ShutdownTaskResponse::SharedCtor(
3208 ::_pb::Arena* arena, bool is_message_owned) {
3209 (void)arena;
3210 (void)is_message_owned;
3211 new (&_impl_) Impl_{
3212 /*decltype(_impl_._cached_size_)*/{}
3213 };
3214 }
3215
~ShutdownTaskResponse()3216 ShutdownTaskResponse::~ShutdownTaskResponse() {
3217 // @@protoc_insertion_point(destructor:tensorflow.ShutdownTaskResponse)
3218 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3219 (void)arena;
3220 return;
3221 }
3222 SharedDtor();
3223 }
3224
SharedDtor()3225 inline void ShutdownTaskResponse::SharedDtor() {
3226 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3227 }
3228
SetCachedSize(int size) const3229 void ShutdownTaskResponse::SetCachedSize(int size) const {
3230 _impl_._cached_size_.Set(size);
3231 }
3232
Clear()3233 void ShutdownTaskResponse::Clear() {
3234 // @@protoc_insertion_point(message_clear_start:tensorflow.ShutdownTaskResponse)
3235 ::uint32_t cached_has_bits = 0;
3236 // Prevent compiler warnings about cached_has_bits being unused
3237 (void) cached_has_bits;
3238
3239 _internal_metadata_.Clear<std::string>();
3240 }
3241
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3242 const char* ShutdownTaskResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3243 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3244 while (!ctx->Done(&ptr)) {
3245 ::uint32_t tag;
3246 ptr = ::_pbi::ReadTag(ptr, &tag);
3247 if ((tag == 0) || ((tag & 7) == 4)) {
3248 CHK_(ptr);
3249 ctx->SetLastTag(tag);
3250 goto message_done;
3251 }
3252 ptr = UnknownFieldParse(
3253 tag,
3254 _internal_metadata_.mutable_unknown_fields<std::string>(),
3255 ptr, ctx);
3256 CHK_(ptr != nullptr);
3257 } // while
3258 message_done:
3259 return ptr;
3260 failure:
3261 ptr = nullptr;
3262 goto message_done;
3263 #undef CHK_
3264 }
3265
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3266 ::uint8_t* ShutdownTaskResponse::_InternalSerialize(
3267 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3268 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.ShutdownTaskResponse)
3269 ::uint32_t cached_has_bits = 0;
3270 (void) cached_has_bits;
3271
3272 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3273 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3274 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3275 }
3276 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.ShutdownTaskResponse)
3277 return target;
3278 }
3279
ByteSizeLong() const3280 size_t ShutdownTaskResponse::ByteSizeLong() const {
3281 // @@protoc_insertion_point(message_byte_size_start:tensorflow.ShutdownTaskResponse)
3282 size_t total_size = 0;
3283
3284 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3285 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3286 }
3287 int cached_size = ::_pbi::ToCachedSize(total_size);
3288 SetCachedSize(cached_size);
3289 return total_size;
3290 }
3291
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3292 void ShutdownTaskResponse::CheckTypeAndMergeFrom(
3293 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3294 MergeFrom(*::_pbi::DownCast<const ShutdownTaskResponse*>(
3295 &from));
3296 }
3297
MergeFrom(const ShutdownTaskResponse & from)3298 void ShutdownTaskResponse::MergeFrom(const ShutdownTaskResponse& from) {
3299 ShutdownTaskResponse* const _this = this;
3300 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.ShutdownTaskResponse)
3301 GOOGLE_DCHECK_NE(&from, _this);
3302 ::uint32_t cached_has_bits = 0;
3303 (void) cached_has_bits;
3304
3305 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3306 }
3307
CopyFrom(const ShutdownTaskResponse & from)3308 void ShutdownTaskResponse::CopyFrom(const ShutdownTaskResponse& from) {
3309 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.ShutdownTaskResponse)
3310 if (&from == this) return;
3311 Clear();
3312 MergeFrom(from);
3313 }
3314
IsInitialized() const3315 bool ShutdownTaskResponse::IsInitialized() const {
3316 return true;
3317 }
3318
InternalSwap(ShutdownTaskResponse * other)3319 void ShutdownTaskResponse::InternalSwap(ShutdownTaskResponse* other) {
3320 using std::swap;
3321 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3322 }
3323
GetTypeName() const3324 std::string ShutdownTaskResponse::GetTypeName() const {
3325 return "tensorflow.ShutdownTaskResponse";
3326 }
3327
3328
3329 // ===================================================================
3330
3331 class ResetTaskRequest::_Internal {
3332 public:
3333 static const ::tensorflow::CoordinatedTask& source_task(const ResetTaskRequest* msg);
3334 };
3335
3336 const ::tensorflow::CoordinatedTask&
source_task(const ResetTaskRequest * msg)3337 ResetTaskRequest::_Internal::source_task(const ResetTaskRequest* msg) {
3338 return *msg->_impl_.source_task_;
3339 }
ResetTaskRequest(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3340 ResetTaskRequest::ResetTaskRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3341 bool is_message_owned)
3342 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3343 SharedCtor(arena, is_message_owned);
3344 // @@protoc_insertion_point(arena_constructor:tensorflow.ResetTaskRequest)
3345 }
ResetTaskRequest(const ResetTaskRequest & from)3346 ResetTaskRequest::ResetTaskRequest(const ResetTaskRequest& from)
3347 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3348 ResetTaskRequest* const _this = this; (void)_this;
3349 new (&_impl_) Impl_{
3350 decltype(_impl_.source_task_){nullptr}
3351 , /*decltype(_impl_._cached_size_)*/{}};
3352
3353 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3354 if (from._internal_has_source_task()) {
3355 _this->_impl_.source_task_ = new ::tensorflow::CoordinatedTask(*from._impl_.source_task_);
3356 }
3357 // @@protoc_insertion_point(copy_constructor:tensorflow.ResetTaskRequest)
3358 }
3359
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3360 inline void ResetTaskRequest::SharedCtor(
3361 ::_pb::Arena* arena, bool is_message_owned) {
3362 (void)arena;
3363 (void)is_message_owned;
3364 new (&_impl_) Impl_{
3365 decltype(_impl_.source_task_){nullptr}
3366 , /*decltype(_impl_._cached_size_)*/{}
3367 };
3368 }
3369
~ResetTaskRequest()3370 ResetTaskRequest::~ResetTaskRequest() {
3371 // @@protoc_insertion_point(destructor:tensorflow.ResetTaskRequest)
3372 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3373 (void)arena;
3374 return;
3375 }
3376 SharedDtor();
3377 }
3378
SharedDtor()3379 inline void ResetTaskRequest::SharedDtor() {
3380 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3381 if (this != internal_default_instance()) delete _impl_.source_task_;
3382 }
3383
SetCachedSize(int size) const3384 void ResetTaskRequest::SetCachedSize(int size) const {
3385 _impl_._cached_size_.Set(size);
3386 }
3387
Clear()3388 void ResetTaskRequest::Clear() {
3389 // @@protoc_insertion_point(message_clear_start:tensorflow.ResetTaskRequest)
3390 ::uint32_t cached_has_bits = 0;
3391 // Prevent compiler warnings about cached_has_bits being unused
3392 (void) cached_has_bits;
3393
3394 if (GetArenaForAllocation() == nullptr && _impl_.source_task_ != nullptr) {
3395 delete _impl_.source_task_;
3396 }
3397 _impl_.source_task_ = nullptr;
3398 _internal_metadata_.Clear<std::string>();
3399 }
3400
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3401 const char* ResetTaskRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3402 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3403 while (!ctx->Done(&ptr)) {
3404 ::uint32_t tag;
3405 ptr = ::_pbi::ReadTag(ptr, &tag);
3406 switch (tag >> 3) {
3407 // .tensorflow.CoordinatedTask source_task = 1;
3408 case 1:
3409 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
3410 ptr = ctx->ParseMessage(_internal_mutable_source_task(), ptr);
3411 CHK_(ptr);
3412 } else {
3413 goto handle_unusual;
3414 }
3415 continue;
3416 default:
3417 goto handle_unusual;
3418 } // switch
3419 handle_unusual:
3420 if ((tag == 0) || ((tag & 7) == 4)) {
3421 CHK_(ptr);
3422 ctx->SetLastTag(tag);
3423 goto message_done;
3424 }
3425 ptr = UnknownFieldParse(
3426 tag,
3427 _internal_metadata_.mutable_unknown_fields<std::string>(),
3428 ptr, ctx);
3429 CHK_(ptr != nullptr);
3430 } // while
3431 message_done:
3432 return ptr;
3433 failure:
3434 ptr = nullptr;
3435 goto message_done;
3436 #undef CHK_
3437 }
3438
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3439 ::uint8_t* ResetTaskRequest::_InternalSerialize(
3440 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3441 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.ResetTaskRequest)
3442 ::uint32_t cached_has_bits = 0;
3443 (void) cached_has_bits;
3444
3445 // .tensorflow.CoordinatedTask source_task = 1;
3446 if (this->_internal_has_source_task()) {
3447 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
3448 InternalWriteMessage(1, _Internal::source_task(this),
3449 _Internal::source_task(this).GetCachedSize(), target, stream);
3450 }
3451
3452 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3453 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3454 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3455 }
3456 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.ResetTaskRequest)
3457 return target;
3458 }
3459
ByteSizeLong() const3460 size_t ResetTaskRequest::ByteSizeLong() const {
3461 // @@protoc_insertion_point(message_byte_size_start:tensorflow.ResetTaskRequest)
3462 size_t total_size = 0;
3463
3464 ::uint32_t cached_has_bits = 0;
3465 // Prevent compiler warnings about cached_has_bits being unused
3466 (void) cached_has_bits;
3467
3468 // .tensorflow.CoordinatedTask source_task = 1;
3469 if (this->_internal_has_source_task()) {
3470 total_size += 1 +
3471 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
3472 *_impl_.source_task_);
3473 }
3474
3475 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3476 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3477 }
3478 int cached_size = ::_pbi::ToCachedSize(total_size);
3479 SetCachedSize(cached_size);
3480 return total_size;
3481 }
3482
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3483 void ResetTaskRequest::CheckTypeAndMergeFrom(
3484 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3485 MergeFrom(*::_pbi::DownCast<const ResetTaskRequest*>(
3486 &from));
3487 }
3488
MergeFrom(const ResetTaskRequest & from)3489 void ResetTaskRequest::MergeFrom(const ResetTaskRequest& from) {
3490 ResetTaskRequest* const _this = this;
3491 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.ResetTaskRequest)
3492 GOOGLE_DCHECK_NE(&from, _this);
3493 ::uint32_t cached_has_bits = 0;
3494 (void) cached_has_bits;
3495
3496 if (from._internal_has_source_task()) {
3497 _this->_internal_mutable_source_task()->::tensorflow::CoordinatedTask::MergeFrom(
3498 from._internal_source_task());
3499 }
3500 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3501 }
3502
CopyFrom(const ResetTaskRequest & from)3503 void ResetTaskRequest::CopyFrom(const ResetTaskRequest& from) {
3504 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.ResetTaskRequest)
3505 if (&from == this) return;
3506 Clear();
3507 MergeFrom(from);
3508 }
3509
IsInitialized() const3510 bool ResetTaskRequest::IsInitialized() const {
3511 return true;
3512 }
3513
InternalSwap(ResetTaskRequest * other)3514 void ResetTaskRequest::InternalSwap(ResetTaskRequest* other) {
3515 using std::swap;
3516 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3517 swap(_impl_.source_task_, other->_impl_.source_task_);
3518 }
3519
GetTypeName() const3520 std::string ResetTaskRequest::GetTypeName() const {
3521 return "tensorflow.ResetTaskRequest";
3522 }
3523
3524
3525 // ===================================================================
3526
3527 class ResetTaskResponse::_Internal {
3528 public:
3529 };
3530
ResetTaskResponse(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3531 ResetTaskResponse::ResetTaskResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3532 bool is_message_owned)
3533 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3534 SharedCtor(arena, is_message_owned);
3535 // @@protoc_insertion_point(arena_constructor:tensorflow.ResetTaskResponse)
3536 }
ResetTaskResponse(const ResetTaskResponse & from)3537 ResetTaskResponse::ResetTaskResponse(const ResetTaskResponse& from)
3538 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3539 ResetTaskResponse* const _this = this; (void)_this;
3540 new (&_impl_) Impl_{
3541 /*decltype(_impl_._cached_size_)*/{}};
3542
3543 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3544 // @@protoc_insertion_point(copy_constructor:tensorflow.ResetTaskResponse)
3545 }
3546
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3547 inline void ResetTaskResponse::SharedCtor(
3548 ::_pb::Arena* arena, bool is_message_owned) {
3549 (void)arena;
3550 (void)is_message_owned;
3551 new (&_impl_) Impl_{
3552 /*decltype(_impl_._cached_size_)*/{}
3553 };
3554 }
3555
~ResetTaskResponse()3556 ResetTaskResponse::~ResetTaskResponse() {
3557 // @@protoc_insertion_point(destructor:tensorflow.ResetTaskResponse)
3558 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3559 (void)arena;
3560 return;
3561 }
3562 SharedDtor();
3563 }
3564
SharedDtor()3565 inline void ResetTaskResponse::SharedDtor() {
3566 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3567 }
3568
SetCachedSize(int size) const3569 void ResetTaskResponse::SetCachedSize(int size) const {
3570 _impl_._cached_size_.Set(size);
3571 }
3572
Clear()3573 void ResetTaskResponse::Clear() {
3574 // @@protoc_insertion_point(message_clear_start:tensorflow.ResetTaskResponse)
3575 ::uint32_t cached_has_bits = 0;
3576 // Prevent compiler warnings about cached_has_bits being unused
3577 (void) cached_has_bits;
3578
3579 _internal_metadata_.Clear<std::string>();
3580 }
3581
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3582 const char* ResetTaskResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3583 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3584 while (!ctx->Done(&ptr)) {
3585 ::uint32_t tag;
3586 ptr = ::_pbi::ReadTag(ptr, &tag);
3587 if ((tag == 0) || ((tag & 7) == 4)) {
3588 CHK_(ptr);
3589 ctx->SetLastTag(tag);
3590 goto message_done;
3591 }
3592 ptr = UnknownFieldParse(
3593 tag,
3594 _internal_metadata_.mutable_unknown_fields<std::string>(),
3595 ptr, ctx);
3596 CHK_(ptr != nullptr);
3597 } // while
3598 message_done:
3599 return ptr;
3600 failure:
3601 ptr = nullptr;
3602 goto message_done;
3603 #undef CHK_
3604 }
3605
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3606 ::uint8_t* ResetTaskResponse::_InternalSerialize(
3607 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3608 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.ResetTaskResponse)
3609 ::uint32_t cached_has_bits = 0;
3610 (void) cached_has_bits;
3611
3612 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3613 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3614 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3615 }
3616 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.ResetTaskResponse)
3617 return target;
3618 }
3619
ByteSizeLong() const3620 size_t ResetTaskResponse::ByteSizeLong() const {
3621 // @@protoc_insertion_point(message_byte_size_start:tensorflow.ResetTaskResponse)
3622 size_t total_size = 0;
3623
3624 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3625 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3626 }
3627 int cached_size = ::_pbi::ToCachedSize(total_size);
3628 SetCachedSize(cached_size);
3629 return total_size;
3630 }
3631
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3632 void ResetTaskResponse::CheckTypeAndMergeFrom(
3633 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3634 MergeFrom(*::_pbi::DownCast<const ResetTaskResponse*>(
3635 &from));
3636 }
3637
MergeFrom(const ResetTaskResponse & from)3638 void ResetTaskResponse::MergeFrom(const ResetTaskResponse& from) {
3639 ResetTaskResponse* const _this = this;
3640 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.ResetTaskResponse)
3641 GOOGLE_DCHECK_NE(&from, _this);
3642 ::uint32_t cached_has_bits = 0;
3643 (void) cached_has_bits;
3644
3645 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3646 }
3647
CopyFrom(const ResetTaskResponse & from)3648 void ResetTaskResponse::CopyFrom(const ResetTaskResponse& from) {
3649 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.ResetTaskResponse)
3650 if (&from == this) return;
3651 Clear();
3652 MergeFrom(from);
3653 }
3654
IsInitialized() const3655 bool ResetTaskResponse::IsInitialized() const {
3656 return true;
3657 }
3658
InternalSwap(ResetTaskResponse * other)3659 void ResetTaskResponse::InternalSwap(ResetTaskResponse* other) {
3660 using std::swap;
3661 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3662 }
3663
GetTypeName() const3664 std::string ResetTaskResponse::GetTypeName() const {
3665 return "tensorflow.ResetTaskResponse";
3666 }
3667
3668
3669 // ===================================================================
3670
3671 class ReportErrorToTaskRequest::_Internal {
3672 public:
3673 static const ::tensorflow::CoordinationServiceError& error_payload(const ReportErrorToTaskRequest* msg);
3674 };
3675
3676 const ::tensorflow::CoordinationServiceError&
error_payload(const ReportErrorToTaskRequest * msg)3677 ReportErrorToTaskRequest::_Internal::error_payload(const ReportErrorToTaskRequest* msg) {
3678 return *msg->_impl_.error_payload_;
3679 }
ReportErrorToTaskRequest(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3680 ReportErrorToTaskRequest::ReportErrorToTaskRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3681 bool is_message_owned)
3682 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3683 SharedCtor(arena, is_message_owned);
3684 // @@protoc_insertion_point(arena_constructor:tensorflow.ReportErrorToTaskRequest)
3685 }
ReportErrorToTaskRequest(const ReportErrorToTaskRequest & from)3686 ReportErrorToTaskRequest::ReportErrorToTaskRequest(const ReportErrorToTaskRequest& from)
3687 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3688 ReportErrorToTaskRequest* const _this = this; (void)_this;
3689 new (&_impl_) Impl_{
3690 decltype(_impl_.error_message_){}
3691 , decltype(_impl_.error_payload_){nullptr}
3692 , decltype(_impl_.error_code_){}
3693 , /*decltype(_impl_._cached_size_)*/{}};
3694
3695 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3696 _impl_.error_message_.InitDefault();
3697 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3698 _impl_.error_message_.Set("", GetArenaForAllocation());
3699 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3700 if (!from._internal_error_message().empty()) {
3701 _this->_impl_.error_message_.Set(from._internal_error_message(),
3702 _this->GetArenaForAllocation());
3703 }
3704 if (from._internal_has_error_payload()) {
3705 _this->_impl_.error_payload_ = new ::tensorflow::CoordinationServiceError(*from._impl_.error_payload_);
3706 }
3707 _this->_impl_.error_code_ = from._impl_.error_code_;
3708 // @@protoc_insertion_point(copy_constructor:tensorflow.ReportErrorToTaskRequest)
3709 }
3710
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3711 inline void ReportErrorToTaskRequest::SharedCtor(
3712 ::_pb::Arena* arena, bool is_message_owned) {
3713 (void)arena;
3714 (void)is_message_owned;
3715 new (&_impl_) Impl_{
3716 decltype(_impl_.error_message_){}
3717 , decltype(_impl_.error_payload_){nullptr}
3718 , decltype(_impl_.error_code_){0}
3719 , /*decltype(_impl_._cached_size_)*/{}
3720 };
3721 _impl_.error_message_.InitDefault();
3722 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3723 _impl_.error_message_.Set("", GetArenaForAllocation());
3724 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3725 }
3726
~ReportErrorToTaskRequest()3727 ReportErrorToTaskRequest::~ReportErrorToTaskRequest() {
3728 // @@protoc_insertion_point(destructor:tensorflow.ReportErrorToTaskRequest)
3729 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3730 (void)arena;
3731 return;
3732 }
3733 SharedDtor();
3734 }
3735
SharedDtor()3736 inline void ReportErrorToTaskRequest::SharedDtor() {
3737 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3738 _impl_.error_message_.Destroy();
3739 if (this != internal_default_instance()) delete _impl_.error_payload_;
3740 }
3741
SetCachedSize(int size) const3742 void ReportErrorToTaskRequest::SetCachedSize(int size) const {
3743 _impl_._cached_size_.Set(size);
3744 }
3745
Clear()3746 void ReportErrorToTaskRequest::Clear() {
3747 // @@protoc_insertion_point(message_clear_start:tensorflow.ReportErrorToTaskRequest)
3748 ::uint32_t cached_has_bits = 0;
3749 // Prevent compiler warnings about cached_has_bits being unused
3750 (void) cached_has_bits;
3751
3752 _impl_.error_message_.ClearToEmpty();
3753 if (GetArenaForAllocation() == nullptr && _impl_.error_payload_ != nullptr) {
3754 delete _impl_.error_payload_;
3755 }
3756 _impl_.error_payload_ = nullptr;
3757 _impl_.error_code_ = 0;
3758 _internal_metadata_.Clear<std::string>();
3759 }
3760
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3761 const char* ReportErrorToTaskRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3762 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3763 while (!ctx->Done(&ptr)) {
3764 ::uint32_t tag;
3765 ptr = ::_pbi::ReadTag(ptr, &tag);
3766 switch (tag >> 3) {
3767 // int32 error_code = 1;
3768 case 1:
3769 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
3770 _impl_.error_code_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3771 CHK_(ptr);
3772 } else {
3773 goto handle_unusual;
3774 }
3775 continue;
3776 // string error_message = 2;
3777 case 2:
3778 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
3779 auto str = _internal_mutable_error_message();
3780 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
3781 CHK_(ptr);
3782 CHK_(::_pbi::VerifyUTF8(str, nullptr));
3783 } else {
3784 goto handle_unusual;
3785 }
3786 continue;
3787 // .tensorflow.CoordinationServiceError error_payload = 5;
3788 case 5:
3789 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
3790 ptr = ctx->ParseMessage(_internal_mutable_error_payload(), ptr);
3791 CHK_(ptr);
3792 } else {
3793 goto handle_unusual;
3794 }
3795 continue;
3796 default:
3797 goto handle_unusual;
3798 } // switch
3799 handle_unusual:
3800 if ((tag == 0) || ((tag & 7) == 4)) {
3801 CHK_(ptr);
3802 ctx->SetLastTag(tag);
3803 goto message_done;
3804 }
3805 ptr = UnknownFieldParse(
3806 tag,
3807 _internal_metadata_.mutable_unknown_fields<std::string>(),
3808 ptr, ctx);
3809 CHK_(ptr != nullptr);
3810 } // while
3811 message_done:
3812 return ptr;
3813 failure:
3814 ptr = nullptr;
3815 goto message_done;
3816 #undef CHK_
3817 }
3818
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3819 ::uint8_t* ReportErrorToTaskRequest::_InternalSerialize(
3820 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3821 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.ReportErrorToTaskRequest)
3822 ::uint32_t cached_has_bits = 0;
3823 (void) cached_has_bits;
3824
3825 // int32 error_code = 1;
3826 if (this->_internal_error_code() != 0) {
3827 target = stream->EnsureSpace(target);
3828 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_error_code(), target);
3829 }
3830
3831 // string error_message = 2;
3832 if (!this->_internal_error_message().empty()) {
3833 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
3834 this->_internal_error_message().data(), static_cast<int>(this->_internal_error_message().length()),
3835 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
3836 "tensorflow.ReportErrorToTaskRequest.error_message");
3837 target = stream->WriteStringMaybeAliased(
3838 2, this->_internal_error_message(), target);
3839 }
3840
3841 // .tensorflow.CoordinationServiceError error_payload = 5;
3842 if (this->_internal_has_error_payload()) {
3843 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
3844 InternalWriteMessage(5, _Internal::error_payload(this),
3845 _Internal::error_payload(this).GetCachedSize(), target, stream);
3846 }
3847
3848 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3849 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3850 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3851 }
3852 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.ReportErrorToTaskRequest)
3853 return target;
3854 }
3855
ByteSizeLong() const3856 size_t ReportErrorToTaskRequest::ByteSizeLong() const {
3857 // @@protoc_insertion_point(message_byte_size_start:tensorflow.ReportErrorToTaskRequest)
3858 size_t total_size = 0;
3859
3860 ::uint32_t cached_has_bits = 0;
3861 // Prevent compiler warnings about cached_has_bits being unused
3862 (void) cached_has_bits;
3863
3864 // string error_message = 2;
3865 if (!this->_internal_error_message().empty()) {
3866 total_size += 1 +
3867 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
3868 this->_internal_error_message());
3869 }
3870
3871 // .tensorflow.CoordinationServiceError error_payload = 5;
3872 if (this->_internal_has_error_payload()) {
3873 total_size += 1 +
3874 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
3875 *_impl_.error_payload_);
3876 }
3877
3878 // int32 error_code = 1;
3879 if (this->_internal_error_code() != 0) {
3880 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_error_code());
3881 }
3882
3883 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3884 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3885 }
3886 int cached_size = ::_pbi::ToCachedSize(total_size);
3887 SetCachedSize(cached_size);
3888 return total_size;
3889 }
3890
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3891 void ReportErrorToTaskRequest::CheckTypeAndMergeFrom(
3892 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3893 MergeFrom(*::_pbi::DownCast<const ReportErrorToTaskRequest*>(
3894 &from));
3895 }
3896
MergeFrom(const ReportErrorToTaskRequest & from)3897 void ReportErrorToTaskRequest::MergeFrom(const ReportErrorToTaskRequest& from) {
3898 ReportErrorToTaskRequest* const _this = this;
3899 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.ReportErrorToTaskRequest)
3900 GOOGLE_DCHECK_NE(&from, _this);
3901 ::uint32_t cached_has_bits = 0;
3902 (void) cached_has_bits;
3903
3904 if (!from._internal_error_message().empty()) {
3905 _this->_internal_set_error_message(from._internal_error_message());
3906 }
3907 if (from._internal_has_error_payload()) {
3908 _this->_internal_mutable_error_payload()->::tensorflow::CoordinationServiceError::MergeFrom(
3909 from._internal_error_payload());
3910 }
3911 if (from._internal_error_code() != 0) {
3912 _this->_internal_set_error_code(from._internal_error_code());
3913 }
3914 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3915 }
3916
CopyFrom(const ReportErrorToTaskRequest & from)3917 void ReportErrorToTaskRequest::CopyFrom(const ReportErrorToTaskRequest& from) {
3918 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.ReportErrorToTaskRequest)
3919 if (&from == this) return;
3920 Clear();
3921 MergeFrom(from);
3922 }
3923
IsInitialized() const3924 bool ReportErrorToTaskRequest::IsInitialized() const {
3925 return true;
3926 }
3927
InternalSwap(ReportErrorToTaskRequest * other)3928 void ReportErrorToTaskRequest::InternalSwap(ReportErrorToTaskRequest* other) {
3929 using std::swap;
3930 auto* lhs_arena = GetArenaForAllocation();
3931 auto* rhs_arena = other->GetArenaForAllocation();
3932 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3933 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
3934 &_impl_.error_message_, lhs_arena,
3935 &other->_impl_.error_message_, rhs_arena
3936 );
3937 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
3938 PROTOBUF_FIELD_OFFSET(ReportErrorToTaskRequest, _impl_.error_code_)
3939 + sizeof(ReportErrorToTaskRequest::_impl_.error_code_) // NOLINT
3940 - PROTOBUF_FIELD_OFFSET(ReportErrorToTaskRequest, _impl_.error_payload_)>(
3941 reinterpret_cast<char*>(&_impl_.error_payload_),
3942 reinterpret_cast<char*>(&other->_impl_.error_payload_));
3943 }
3944
GetTypeName() const3945 std::string ReportErrorToTaskRequest::GetTypeName() const {
3946 return "tensorflow.ReportErrorToTaskRequest";
3947 }
3948
3949
3950 // ===================================================================
3951
3952 class ReportErrorToTaskResponse::_Internal {
3953 public:
3954 };
3955
ReportErrorToTaskResponse(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3956 ReportErrorToTaskResponse::ReportErrorToTaskResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3957 bool is_message_owned)
3958 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3959 SharedCtor(arena, is_message_owned);
3960 // @@protoc_insertion_point(arena_constructor:tensorflow.ReportErrorToTaskResponse)
3961 }
ReportErrorToTaskResponse(const ReportErrorToTaskResponse & from)3962 ReportErrorToTaskResponse::ReportErrorToTaskResponse(const ReportErrorToTaskResponse& from)
3963 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3964 ReportErrorToTaskResponse* const _this = this; (void)_this;
3965 new (&_impl_) Impl_{
3966 /*decltype(_impl_._cached_size_)*/{}};
3967
3968 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3969 // @@protoc_insertion_point(copy_constructor:tensorflow.ReportErrorToTaskResponse)
3970 }
3971
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3972 inline void ReportErrorToTaskResponse::SharedCtor(
3973 ::_pb::Arena* arena, bool is_message_owned) {
3974 (void)arena;
3975 (void)is_message_owned;
3976 new (&_impl_) Impl_{
3977 /*decltype(_impl_._cached_size_)*/{}
3978 };
3979 }
3980
~ReportErrorToTaskResponse()3981 ReportErrorToTaskResponse::~ReportErrorToTaskResponse() {
3982 // @@protoc_insertion_point(destructor:tensorflow.ReportErrorToTaskResponse)
3983 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3984 (void)arena;
3985 return;
3986 }
3987 SharedDtor();
3988 }
3989
SharedDtor()3990 inline void ReportErrorToTaskResponse::SharedDtor() {
3991 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3992 }
3993
SetCachedSize(int size) const3994 void ReportErrorToTaskResponse::SetCachedSize(int size) const {
3995 _impl_._cached_size_.Set(size);
3996 }
3997
Clear()3998 void ReportErrorToTaskResponse::Clear() {
3999 // @@protoc_insertion_point(message_clear_start:tensorflow.ReportErrorToTaskResponse)
4000 ::uint32_t cached_has_bits = 0;
4001 // Prevent compiler warnings about cached_has_bits being unused
4002 (void) cached_has_bits;
4003
4004 _internal_metadata_.Clear<std::string>();
4005 }
4006
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)4007 const char* ReportErrorToTaskResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
4008 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
4009 while (!ctx->Done(&ptr)) {
4010 ::uint32_t tag;
4011 ptr = ::_pbi::ReadTag(ptr, &tag);
4012 if ((tag == 0) || ((tag & 7) == 4)) {
4013 CHK_(ptr);
4014 ctx->SetLastTag(tag);
4015 goto message_done;
4016 }
4017 ptr = UnknownFieldParse(
4018 tag,
4019 _internal_metadata_.mutable_unknown_fields<std::string>(),
4020 ptr, ctx);
4021 CHK_(ptr != nullptr);
4022 } // while
4023 message_done:
4024 return ptr;
4025 failure:
4026 ptr = nullptr;
4027 goto message_done;
4028 #undef CHK_
4029 }
4030
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const4031 ::uint8_t* ReportErrorToTaskResponse::_InternalSerialize(
4032 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
4033 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.ReportErrorToTaskResponse)
4034 ::uint32_t cached_has_bits = 0;
4035 (void) cached_has_bits;
4036
4037 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4038 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
4039 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
4040 }
4041 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.ReportErrorToTaskResponse)
4042 return target;
4043 }
4044
ByteSizeLong() const4045 size_t ReportErrorToTaskResponse::ByteSizeLong() const {
4046 // @@protoc_insertion_point(message_byte_size_start:tensorflow.ReportErrorToTaskResponse)
4047 size_t total_size = 0;
4048
4049 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4050 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
4051 }
4052 int cached_size = ::_pbi::ToCachedSize(total_size);
4053 SetCachedSize(cached_size);
4054 return total_size;
4055 }
4056
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)4057 void ReportErrorToTaskResponse::CheckTypeAndMergeFrom(
4058 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
4059 MergeFrom(*::_pbi::DownCast<const ReportErrorToTaskResponse*>(
4060 &from));
4061 }
4062
MergeFrom(const ReportErrorToTaskResponse & from)4063 void ReportErrorToTaskResponse::MergeFrom(const ReportErrorToTaskResponse& from) {
4064 ReportErrorToTaskResponse* const _this = this;
4065 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.ReportErrorToTaskResponse)
4066 GOOGLE_DCHECK_NE(&from, _this);
4067 ::uint32_t cached_has_bits = 0;
4068 (void) cached_has_bits;
4069
4070 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4071 }
4072
CopyFrom(const ReportErrorToTaskResponse & from)4073 void ReportErrorToTaskResponse::CopyFrom(const ReportErrorToTaskResponse& from) {
4074 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.ReportErrorToTaskResponse)
4075 if (&from == this) return;
4076 Clear();
4077 MergeFrom(from);
4078 }
4079
IsInitialized() const4080 bool ReportErrorToTaskResponse::IsInitialized() const {
4081 return true;
4082 }
4083
InternalSwap(ReportErrorToTaskResponse * other)4084 void ReportErrorToTaskResponse::InternalSwap(ReportErrorToTaskResponse* other) {
4085 using std::swap;
4086 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
4087 }
4088
GetTypeName() const4089 std::string ReportErrorToTaskResponse::GetTypeName() const {
4090 return "tensorflow.ReportErrorToTaskResponse";
4091 }
4092
4093
4094 // ===================================================================
4095
4096 class ReportErrorToServiceRequest::_Internal {
4097 public:
4098 static const ::tensorflow::CoordinatedTask& error_origin(const ReportErrorToServiceRequest* msg);
4099 };
4100
4101 const ::tensorflow::CoordinatedTask&
error_origin(const ReportErrorToServiceRequest * msg)4102 ReportErrorToServiceRequest::_Internal::error_origin(const ReportErrorToServiceRequest* msg) {
4103 return *msg->_impl_.error_origin_;
4104 }
ReportErrorToServiceRequest(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)4105 ReportErrorToServiceRequest::ReportErrorToServiceRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4106 bool is_message_owned)
4107 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
4108 SharedCtor(arena, is_message_owned);
4109 // @@protoc_insertion_point(arena_constructor:tensorflow.ReportErrorToServiceRequest)
4110 }
ReportErrorToServiceRequest(const ReportErrorToServiceRequest & from)4111 ReportErrorToServiceRequest::ReportErrorToServiceRequest(const ReportErrorToServiceRequest& from)
4112 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
4113 ReportErrorToServiceRequest* const _this = this; (void)_this;
4114 new (&_impl_) Impl_{
4115 decltype(_impl_.error_message_){}
4116 , decltype(_impl_.error_origin_){nullptr}
4117 , decltype(_impl_.error_code_){}
4118 , /*decltype(_impl_._cached_size_)*/{}};
4119
4120 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4121 _impl_.error_message_.InitDefault();
4122 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4123 _impl_.error_message_.Set("", GetArenaForAllocation());
4124 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4125 if (!from._internal_error_message().empty()) {
4126 _this->_impl_.error_message_.Set(from._internal_error_message(),
4127 _this->GetArenaForAllocation());
4128 }
4129 if (from._internal_has_error_origin()) {
4130 _this->_impl_.error_origin_ = new ::tensorflow::CoordinatedTask(*from._impl_.error_origin_);
4131 }
4132 _this->_impl_.error_code_ = from._impl_.error_code_;
4133 // @@protoc_insertion_point(copy_constructor:tensorflow.ReportErrorToServiceRequest)
4134 }
4135
SharedCtor(::_pb::Arena * arena,bool is_message_owned)4136 inline void ReportErrorToServiceRequest::SharedCtor(
4137 ::_pb::Arena* arena, bool is_message_owned) {
4138 (void)arena;
4139 (void)is_message_owned;
4140 new (&_impl_) Impl_{
4141 decltype(_impl_.error_message_){}
4142 , decltype(_impl_.error_origin_){nullptr}
4143 , decltype(_impl_.error_code_){0}
4144 , /*decltype(_impl_._cached_size_)*/{}
4145 };
4146 _impl_.error_message_.InitDefault();
4147 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4148 _impl_.error_message_.Set("", GetArenaForAllocation());
4149 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4150 }
4151
~ReportErrorToServiceRequest()4152 ReportErrorToServiceRequest::~ReportErrorToServiceRequest() {
4153 // @@protoc_insertion_point(destructor:tensorflow.ReportErrorToServiceRequest)
4154 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
4155 (void)arena;
4156 return;
4157 }
4158 SharedDtor();
4159 }
4160
SharedDtor()4161 inline void ReportErrorToServiceRequest::SharedDtor() {
4162 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
4163 _impl_.error_message_.Destroy();
4164 if (this != internal_default_instance()) delete _impl_.error_origin_;
4165 }
4166
SetCachedSize(int size) const4167 void ReportErrorToServiceRequest::SetCachedSize(int size) const {
4168 _impl_._cached_size_.Set(size);
4169 }
4170
Clear()4171 void ReportErrorToServiceRequest::Clear() {
4172 // @@protoc_insertion_point(message_clear_start:tensorflow.ReportErrorToServiceRequest)
4173 ::uint32_t cached_has_bits = 0;
4174 // Prevent compiler warnings about cached_has_bits being unused
4175 (void) cached_has_bits;
4176
4177 _impl_.error_message_.ClearToEmpty();
4178 if (GetArenaForAllocation() == nullptr && _impl_.error_origin_ != nullptr) {
4179 delete _impl_.error_origin_;
4180 }
4181 _impl_.error_origin_ = nullptr;
4182 _impl_.error_code_ = 0;
4183 _internal_metadata_.Clear<std::string>();
4184 }
4185
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)4186 const char* ReportErrorToServiceRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
4187 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
4188 while (!ctx->Done(&ptr)) {
4189 ::uint32_t tag;
4190 ptr = ::_pbi::ReadTag(ptr, &tag);
4191 switch (tag >> 3) {
4192 // int32 error_code = 1;
4193 case 1:
4194 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
4195 _impl_.error_code_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4196 CHK_(ptr);
4197 } else {
4198 goto handle_unusual;
4199 }
4200 continue;
4201 // string error_message = 2;
4202 case 2:
4203 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
4204 auto str = _internal_mutable_error_message();
4205 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
4206 CHK_(ptr);
4207 CHK_(::_pbi::VerifyUTF8(str, nullptr));
4208 } else {
4209 goto handle_unusual;
4210 }
4211 continue;
4212 // .tensorflow.CoordinatedTask error_origin = 5;
4213 case 5:
4214 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
4215 ptr = ctx->ParseMessage(_internal_mutable_error_origin(), ptr);
4216 CHK_(ptr);
4217 } else {
4218 goto handle_unusual;
4219 }
4220 continue;
4221 default:
4222 goto handle_unusual;
4223 } // switch
4224 handle_unusual:
4225 if ((tag == 0) || ((tag & 7) == 4)) {
4226 CHK_(ptr);
4227 ctx->SetLastTag(tag);
4228 goto message_done;
4229 }
4230 ptr = UnknownFieldParse(
4231 tag,
4232 _internal_metadata_.mutable_unknown_fields<std::string>(),
4233 ptr, ctx);
4234 CHK_(ptr != nullptr);
4235 } // while
4236 message_done:
4237 return ptr;
4238 failure:
4239 ptr = nullptr;
4240 goto message_done;
4241 #undef CHK_
4242 }
4243
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const4244 ::uint8_t* ReportErrorToServiceRequest::_InternalSerialize(
4245 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
4246 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.ReportErrorToServiceRequest)
4247 ::uint32_t cached_has_bits = 0;
4248 (void) cached_has_bits;
4249
4250 // int32 error_code = 1;
4251 if (this->_internal_error_code() != 0) {
4252 target = stream->EnsureSpace(target);
4253 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_error_code(), target);
4254 }
4255
4256 // string error_message = 2;
4257 if (!this->_internal_error_message().empty()) {
4258 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
4259 this->_internal_error_message().data(), static_cast<int>(this->_internal_error_message().length()),
4260 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
4261 "tensorflow.ReportErrorToServiceRequest.error_message");
4262 target = stream->WriteStringMaybeAliased(
4263 2, this->_internal_error_message(), target);
4264 }
4265
4266 // .tensorflow.CoordinatedTask error_origin = 5;
4267 if (this->_internal_has_error_origin()) {
4268 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
4269 InternalWriteMessage(5, _Internal::error_origin(this),
4270 _Internal::error_origin(this).GetCachedSize(), target, stream);
4271 }
4272
4273 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4274 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
4275 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
4276 }
4277 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.ReportErrorToServiceRequest)
4278 return target;
4279 }
4280
ByteSizeLong() const4281 size_t ReportErrorToServiceRequest::ByteSizeLong() const {
4282 // @@protoc_insertion_point(message_byte_size_start:tensorflow.ReportErrorToServiceRequest)
4283 size_t total_size = 0;
4284
4285 ::uint32_t cached_has_bits = 0;
4286 // Prevent compiler warnings about cached_has_bits being unused
4287 (void) cached_has_bits;
4288
4289 // string error_message = 2;
4290 if (!this->_internal_error_message().empty()) {
4291 total_size += 1 +
4292 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
4293 this->_internal_error_message());
4294 }
4295
4296 // .tensorflow.CoordinatedTask error_origin = 5;
4297 if (this->_internal_has_error_origin()) {
4298 total_size += 1 +
4299 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
4300 *_impl_.error_origin_);
4301 }
4302
4303 // int32 error_code = 1;
4304 if (this->_internal_error_code() != 0) {
4305 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_error_code());
4306 }
4307
4308 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4309 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
4310 }
4311 int cached_size = ::_pbi::ToCachedSize(total_size);
4312 SetCachedSize(cached_size);
4313 return total_size;
4314 }
4315
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)4316 void ReportErrorToServiceRequest::CheckTypeAndMergeFrom(
4317 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
4318 MergeFrom(*::_pbi::DownCast<const ReportErrorToServiceRequest*>(
4319 &from));
4320 }
4321
MergeFrom(const ReportErrorToServiceRequest & from)4322 void ReportErrorToServiceRequest::MergeFrom(const ReportErrorToServiceRequest& from) {
4323 ReportErrorToServiceRequest* const _this = this;
4324 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.ReportErrorToServiceRequest)
4325 GOOGLE_DCHECK_NE(&from, _this);
4326 ::uint32_t cached_has_bits = 0;
4327 (void) cached_has_bits;
4328
4329 if (!from._internal_error_message().empty()) {
4330 _this->_internal_set_error_message(from._internal_error_message());
4331 }
4332 if (from._internal_has_error_origin()) {
4333 _this->_internal_mutable_error_origin()->::tensorflow::CoordinatedTask::MergeFrom(
4334 from._internal_error_origin());
4335 }
4336 if (from._internal_error_code() != 0) {
4337 _this->_internal_set_error_code(from._internal_error_code());
4338 }
4339 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4340 }
4341
CopyFrom(const ReportErrorToServiceRequest & from)4342 void ReportErrorToServiceRequest::CopyFrom(const ReportErrorToServiceRequest& from) {
4343 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.ReportErrorToServiceRequest)
4344 if (&from == this) return;
4345 Clear();
4346 MergeFrom(from);
4347 }
4348
IsInitialized() const4349 bool ReportErrorToServiceRequest::IsInitialized() const {
4350 return true;
4351 }
4352
InternalSwap(ReportErrorToServiceRequest * other)4353 void ReportErrorToServiceRequest::InternalSwap(ReportErrorToServiceRequest* other) {
4354 using std::swap;
4355 auto* lhs_arena = GetArenaForAllocation();
4356 auto* rhs_arena = other->GetArenaForAllocation();
4357 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
4358 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
4359 &_impl_.error_message_, lhs_arena,
4360 &other->_impl_.error_message_, rhs_arena
4361 );
4362 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
4363 PROTOBUF_FIELD_OFFSET(ReportErrorToServiceRequest, _impl_.error_code_)
4364 + sizeof(ReportErrorToServiceRequest::_impl_.error_code_) // NOLINT
4365 - PROTOBUF_FIELD_OFFSET(ReportErrorToServiceRequest, _impl_.error_origin_)>(
4366 reinterpret_cast<char*>(&_impl_.error_origin_),
4367 reinterpret_cast<char*>(&other->_impl_.error_origin_));
4368 }
4369
GetTypeName() const4370 std::string ReportErrorToServiceRequest::GetTypeName() const {
4371 return "tensorflow.ReportErrorToServiceRequest";
4372 }
4373
4374
4375 // ===================================================================
4376
4377 class ReportErrorToServiceResponse::_Internal {
4378 public:
4379 };
4380
ReportErrorToServiceResponse(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)4381 ReportErrorToServiceResponse::ReportErrorToServiceResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4382 bool is_message_owned)
4383 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
4384 SharedCtor(arena, is_message_owned);
4385 // @@protoc_insertion_point(arena_constructor:tensorflow.ReportErrorToServiceResponse)
4386 }
ReportErrorToServiceResponse(const ReportErrorToServiceResponse & from)4387 ReportErrorToServiceResponse::ReportErrorToServiceResponse(const ReportErrorToServiceResponse& from)
4388 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
4389 ReportErrorToServiceResponse* const _this = this; (void)_this;
4390 new (&_impl_) Impl_{
4391 /*decltype(_impl_._cached_size_)*/{}};
4392
4393 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4394 // @@protoc_insertion_point(copy_constructor:tensorflow.ReportErrorToServiceResponse)
4395 }
4396
SharedCtor(::_pb::Arena * arena,bool is_message_owned)4397 inline void ReportErrorToServiceResponse::SharedCtor(
4398 ::_pb::Arena* arena, bool is_message_owned) {
4399 (void)arena;
4400 (void)is_message_owned;
4401 new (&_impl_) Impl_{
4402 /*decltype(_impl_._cached_size_)*/{}
4403 };
4404 }
4405
~ReportErrorToServiceResponse()4406 ReportErrorToServiceResponse::~ReportErrorToServiceResponse() {
4407 // @@protoc_insertion_point(destructor:tensorflow.ReportErrorToServiceResponse)
4408 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
4409 (void)arena;
4410 return;
4411 }
4412 SharedDtor();
4413 }
4414
SharedDtor()4415 inline void ReportErrorToServiceResponse::SharedDtor() {
4416 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
4417 }
4418
SetCachedSize(int size) const4419 void ReportErrorToServiceResponse::SetCachedSize(int size) const {
4420 _impl_._cached_size_.Set(size);
4421 }
4422
Clear()4423 void ReportErrorToServiceResponse::Clear() {
4424 // @@protoc_insertion_point(message_clear_start:tensorflow.ReportErrorToServiceResponse)
4425 ::uint32_t cached_has_bits = 0;
4426 // Prevent compiler warnings about cached_has_bits being unused
4427 (void) cached_has_bits;
4428
4429 _internal_metadata_.Clear<std::string>();
4430 }
4431
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)4432 const char* ReportErrorToServiceResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
4433 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
4434 while (!ctx->Done(&ptr)) {
4435 ::uint32_t tag;
4436 ptr = ::_pbi::ReadTag(ptr, &tag);
4437 if ((tag == 0) || ((tag & 7) == 4)) {
4438 CHK_(ptr);
4439 ctx->SetLastTag(tag);
4440 goto message_done;
4441 }
4442 ptr = UnknownFieldParse(
4443 tag,
4444 _internal_metadata_.mutable_unknown_fields<std::string>(),
4445 ptr, ctx);
4446 CHK_(ptr != nullptr);
4447 } // while
4448 message_done:
4449 return ptr;
4450 failure:
4451 ptr = nullptr;
4452 goto message_done;
4453 #undef CHK_
4454 }
4455
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const4456 ::uint8_t* ReportErrorToServiceResponse::_InternalSerialize(
4457 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
4458 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.ReportErrorToServiceResponse)
4459 ::uint32_t cached_has_bits = 0;
4460 (void) cached_has_bits;
4461
4462 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4463 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
4464 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
4465 }
4466 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.ReportErrorToServiceResponse)
4467 return target;
4468 }
4469
ByteSizeLong() const4470 size_t ReportErrorToServiceResponse::ByteSizeLong() const {
4471 // @@protoc_insertion_point(message_byte_size_start:tensorflow.ReportErrorToServiceResponse)
4472 size_t total_size = 0;
4473
4474 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4475 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
4476 }
4477 int cached_size = ::_pbi::ToCachedSize(total_size);
4478 SetCachedSize(cached_size);
4479 return total_size;
4480 }
4481
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)4482 void ReportErrorToServiceResponse::CheckTypeAndMergeFrom(
4483 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
4484 MergeFrom(*::_pbi::DownCast<const ReportErrorToServiceResponse*>(
4485 &from));
4486 }
4487
MergeFrom(const ReportErrorToServiceResponse & from)4488 void ReportErrorToServiceResponse::MergeFrom(const ReportErrorToServiceResponse& from) {
4489 ReportErrorToServiceResponse* const _this = this;
4490 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.ReportErrorToServiceResponse)
4491 GOOGLE_DCHECK_NE(&from, _this);
4492 ::uint32_t cached_has_bits = 0;
4493 (void) cached_has_bits;
4494
4495 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4496 }
4497
CopyFrom(const ReportErrorToServiceResponse & from)4498 void ReportErrorToServiceResponse::CopyFrom(const ReportErrorToServiceResponse& from) {
4499 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.ReportErrorToServiceResponse)
4500 if (&from == this) return;
4501 Clear();
4502 MergeFrom(from);
4503 }
4504
IsInitialized() const4505 bool ReportErrorToServiceResponse::IsInitialized() const {
4506 return true;
4507 }
4508
InternalSwap(ReportErrorToServiceResponse * other)4509 void ReportErrorToServiceResponse::InternalSwap(ReportErrorToServiceResponse* other) {
4510 using std::swap;
4511 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
4512 }
4513
GetTypeName() const4514 std::string ReportErrorToServiceResponse::GetTypeName() const {
4515 return "tensorflow.ReportErrorToServiceResponse";
4516 }
4517
4518
4519 // ===================================================================
4520
4521 class KeyValueEntry::_Internal {
4522 public:
4523 };
4524
KeyValueEntry(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)4525 KeyValueEntry::KeyValueEntry(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4526 bool is_message_owned)
4527 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
4528 SharedCtor(arena, is_message_owned);
4529 // @@protoc_insertion_point(arena_constructor:tensorflow.KeyValueEntry)
4530 }
KeyValueEntry(const KeyValueEntry & from)4531 KeyValueEntry::KeyValueEntry(const KeyValueEntry& from)
4532 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
4533 KeyValueEntry* const _this = this; (void)_this;
4534 new (&_impl_) Impl_{
4535 decltype(_impl_.key_){}
4536 , decltype(_impl_.value_){}
4537 , /*decltype(_impl_._cached_size_)*/{}};
4538
4539 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4540 _impl_.key_.InitDefault();
4541 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4542 _impl_.key_.Set("", GetArenaForAllocation());
4543 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4544 if (!from._internal_key().empty()) {
4545 _this->_impl_.key_.Set(from._internal_key(),
4546 _this->GetArenaForAllocation());
4547 }
4548 _impl_.value_.InitDefault();
4549 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4550 _impl_.value_.Set("", GetArenaForAllocation());
4551 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4552 if (!from._internal_value().empty()) {
4553 _this->_impl_.value_.Set(from._internal_value(),
4554 _this->GetArenaForAllocation());
4555 }
4556 // @@protoc_insertion_point(copy_constructor:tensorflow.KeyValueEntry)
4557 }
4558
SharedCtor(::_pb::Arena * arena,bool is_message_owned)4559 inline void KeyValueEntry::SharedCtor(
4560 ::_pb::Arena* arena, bool is_message_owned) {
4561 (void)arena;
4562 (void)is_message_owned;
4563 new (&_impl_) Impl_{
4564 decltype(_impl_.key_){}
4565 , decltype(_impl_.value_){}
4566 , /*decltype(_impl_._cached_size_)*/{}
4567 };
4568 _impl_.key_.InitDefault();
4569 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4570 _impl_.key_.Set("", GetArenaForAllocation());
4571 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4572 _impl_.value_.InitDefault();
4573 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4574 _impl_.value_.Set("", GetArenaForAllocation());
4575 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4576 }
4577
~KeyValueEntry()4578 KeyValueEntry::~KeyValueEntry() {
4579 // @@protoc_insertion_point(destructor:tensorflow.KeyValueEntry)
4580 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
4581 (void)arena;
4582 return;
4583 }
4584 SharedDtor();
4585 }
4586
SharedDtor()4587 inline void KeyValueEntry::SharedDtor() {
4588 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
4589 _impl_.key_.Destroy();
4590 _impl_.value_.Destroy();
4591 }
4592
SetCachedSize(int size) const4593 void KeyValueEntry::SetCachedSize(int size) const {
4594 _impl_._cached_size_.Set(size);
4595 }
4596
Clear()4597 void KeyValueEntry::Clear() {
4598 // @@protoc_insertion_point(message_clear_start:tensorflow.KeyValueEntry)
4599 ::uint32_t cached_has_bits = 0;
4600 // Prevent compiler warnings about cached_has_bits being unused
4601 (void) cached_has_bits;
4602
4603 _impl_.key_.ClearToEmpty();
4604 _impl_.value_.ClearToEmpty();
4605 _internal_metadata_.Clear<std::string>();
4606 }
4607
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)4608 const char* KeyValueEntry::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
4609 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
4610 while (!ctx->Done(&ptr)) {
4611 ::uint32_t tag;
4612 ptr = ::_pbi::ReadTag(ptr, &tag);
4613 switch (tag >> 3) {
4614 // string key = 1;
4615 case 1:
4616 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
4617 auto str = _internal_mutable_key();
4618 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
4619 CHK_(ptr);
4620 CHK_(::_pbi::VerifyUTF8(str, nullptr));
4621 } else {
4622 goto handle_unusual;
4623 }
4624 continue;
4625 // bytes value = 2;
4626 case 2:
4627 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
4628 auto str = _internal_mutable_value();
4629 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
4630 CHK_(ptr);
4631 } else {
4632 goto handle_unusual;
4633 }
4634 continue;
4635 default:
4636 goto handle_unusual;
4637 } // switch
4638 handle_unusual:
4639 if ((tag == 0) || ((tag & 7) == 4)) {
4640 CHK_(ptr);
4641 ctx->SetLastTag(tag);
4642 goto message_done;
4643 }
4644 ptr = UnknownFieldParse(
4645 tag,
4646 _internal_metadata_.mutable_unknown_fields<std::string>(),
4647 ptr, ctx);
4648 CHK_(ptr != nullptr);
4649 } // while
4650 message_done:
4651 return ptr;
4652 failure:
4653 ptr = nullptr;
4654 goto message_done;
4655 #undef CHK_
4656 }
4657
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const4658 ::uint8_t* KeyValueEntry::_InternalSerialize(
4659 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
4660 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.KeyValueEntry)
4661 ::uint32_t cached_has_bits = 0;
4662 (void) cached_has_bits;
4663
4664 // string key = 1;
4665 if (!this->_internal_key().empty()) {
4666 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
4667 this->_internal_key().data(), static_cast<int>(this->_internal_key().length()),
4668 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
4669 "tensorflow.KeyValueEntry.key");
4670 target = stream->WriteStringMaybeAliased(
4671 1, this->_internal_key(), target);
4672 }
4673
4674 // bytes value = 2;
4675 if (!this->_internal_value().empty()) {
4676 target = stream->WriteBytesMaybeAliased(
4677 2, this->_internal_value(), target);
4678 }
4679
4680 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4681 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
4682 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
4683 }
4684 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.KeyValueEntry)
4685 return target;
4686 }
4687
ByteSizeLong() const4688 size_t KeyValueEntry::ByteSizeLong() const {
4689 // @@protoc_insertion_point(message_byte_size_start:tensorflow.KeyValueEntry)
4690 size_t total_size = 0;
4691
4692 ::uint32_t cached_has_bits = 0;
4693 // Prevent compiler warnings about cached_has_bits being unused
4694 (void) cached_has_bits;
4695
4696 // string key = 1;
4697 if (!this->_internal_key().empty()) {
4698 total_size += 1 +
4699 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
4700 this->_internal_key());
4701 }
4702
4703 // bytes value = 2;
4704 if (!this->_internal_value().empty()) {
4705 total_size += 1 +
4706 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
4707 this->_internal_value());
4708 }
4709
4710 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4711 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
4712 }
4713 int cached_size = ::_pbi::ToCachedSize(total_size);
4714 SetCachedSize(cached_size);
4715 return total_size;
4716 }
4717
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)4718 void KeyValueEntry::CheckTypeAndMergeFrom(
4719 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
4720 MergeFrom(*::_pbi::DownCast<const KeyValueEntry*>(
4721 &from));
4722 }
4723
MergeFrom(const KeyValueEntry & from)4724 void KeyValueEntry::MergeFrom(const KeyValueEntry& from) {
4725 KeyValueEntry* const _this = this;
4726 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.KeyValueEntry)
4727 GOOGLE_DCHECK_NE(&from, _this);
4728 ::uint32_t cached_has_bits = 0;
4729 (void) cached_has_bits;
4730
4731 if (!from._internal_key().empty()) {
4732 _this->_internal_set_key(from._internal_key());
4733 }
4734 if (!from._internal_value().empty()) {
4735 _this->_internal_set_value(from._internal_value());
4736 }
4737 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4738 }
4739
CopyFrom(const KeyValueEntry & from)4740 void KeyValueEntry::CopyFrom(const KeyValueEntry& from) {
4741 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.KeyValueEntry)
4742 if (&from == this) return;
4743 Clear();
4744 MergeFrom(from);
4745 }
4746
IsInitialized() const4747 bool KeyValueEntry::IsInitialized() const {
4748 return true;
4749 }
4750
InternalSwap(KeyValueEntry * other)4751 void KeyValueEntry::InternalSwap(KeyValueEntry* other) {
4752 using std::swap;
4753 auto* lhs_arena = GetArenaForAllocation();
4754 auto* rhs_arena = other->GetArenaForAllocation();
4755 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
4756 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
4757 &_impl_.key_, lhs_arena,
4758 &other->_impl_.key_, rhs_arena
4759 );
4760 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
4761 &_impl_.value_, lhs_arena,
4762 &other->_impl_.value_, rhs_arena
4763 );
4764 }
4765
GetTypeName() const4766 std::string KeyValueEntry::GetTypeName() const {
4767 return "tensorflow.KeyValueEntry";
4768 }
4769
4770
4771 // ===================================================================
4772
4773 class InsertKeyValueRequest::_Internal {
4774 public:
4775 static const ::tensorflow::KeyValueEntry& kv(const InsertKeyValueRequest* msg);
4776 };
4777
4778 const ::tensorflow::KeyValueEntry&
kv(const InsertKeyValueRequest * msg)4779 InsertKeyValueRequest::_Internal::kv(const InsertKeyValueRequest* msg) {
4780 return *msg->_impl_.kv_;
4781 }
InsertKeyValueRequest(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)4782 InsertKeyValueRequest::InsertKeyValueRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4783 bool is_message_owned)
4784 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
4785 SharedCtor(arena, is_message_owned);
4786 // @@protoc_insertion_point(arena_constructor:tensorflow.InsertKeyValueRequest)
4787 }
InsertKeyValueRequest(const InsertKeyValueRequest & from)4788 InsertKeyValueRequest::InsertKeyValueRequest(const InsertKeyValueRequest& from)
4789 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
4790 InsertKeyValueRequest* const _this = this; (void)_this;
4791 new (&_impl_) Impl_{
4792 decltype(_impl_.kv_){nullptr}
4793 , /*decltype(_impl_._cached_size_)*/{}};
4794
4795 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4796 if (from._internal_has_kv()) {
4797 _this->_impl_.kv_ = new ::tensorflow::KeyValueEntry(*from._impl_.kv_);
4798 }
4799 // @@protoc_insertion_point(copy_constructor:tensorflow.InsertKeyValueRequest)
4800 }
4801
SharedCtor(::_pb::Arena * arena,bool is_message_owned)4802 inline void InsertKeyValueRequest::SharedCtor(
4803 ::_pb::Arena* arena, bool is_message_owned) {
4804 (void)arena;
4805 (void)is_message_owned;
4806 new (&_impl_) Impl_{
4807 decltype(_impl_.kv_){nullptr}
4808 , /*decltype(_impl_._cached_size_)*/{}
4809 };
4810 }
4811
~InsertKeyValueRequest()4812 InsertKeyValueRequest::~InsertKeyValueRequest() {
4813 // @@protoc_insertion_point(destructor:tensorflow.InsertKeyValueRequest)
4814 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
4815 (void)arena;
4816 return;
4817 }
4818 SharedDtor();
4819 }
4820
SharedDtor()4821 inline void InsertKeyValueRequest::SharedDtor() {
4822 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
4823 if (this != internal_default_instance()) delete _impl_.kv_;
4824 }
4825
SetCachedSize(int size) const4826 void InsertKeyValueRequest::SetCachedSize(int size) const {
4827 _impl_._cached_size_.Set(size);
4828 }
4829
Clear()4830 void InsertKeyValueRequest::Clear() {
4831 // @@protoc_insertion_point(message_clear_start:tensorflow.InsertKeyValueRequest)
4832 ::uint32_t cached_has_bits = 0;
4833 // Prevent compiler warnings about cached_has_bits being unused
4834 (void) cached_has_bits;
4835
4836 if (GetArenaForAllocation() == nullptr && _impl_.kv_ != nullptr) {
4837 delete _impl_.kv_;
4838 }
4839 _impl_.kv_ = nullptr;
4840 _internal_metadata_.Clear<std::string>();
4841 }
4842
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)4843 const char* InsertKeyValueRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
4844 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
4845 while (!ctx->Done(&ptr)) {
4846 ::uint32_t tag;
4847 ptr = ::_pbi::ReadTag(ptr, &tag);
4848 switch (tag >> 3) {
4849 // .tensorflow.KeyValueEntry kv = 1;
4850 case 1:
4851 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
4852 ptr = ctx->ParseMessage(_internal_mutable_kv(), ptr);
4853 CHK_(ptr);
4854 } else {
4855 goto handle_unusual;
4856 }
4857 continue;
4858 default:
4859 goto handle_unusual;
4860 } // switch
4861 handle_unusual:
4862 if ((tag == 0) || ((tag & 7) == 4)) {
4863 CHK_(ptr);
4864 ctx->SetLastTag(tag);
4865 goto message_done;
4866 }
4867 ptr = UnknownFieldParse(
4868 tag,
4869 _internal_metadata_.mutable_unknown_fields<std::string>(),
4870 ptr, ctx);
4871 CHK_(ptr != nullptr);
4872 } // while
4873 message_done:
4874 return ptr;
4875 failure:
4876 ptr = nullptr;
4877 goto message_done;
4878 #undef CHK_
4879 }
4880
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const4881 ::uint8_t* InsertKeyValueRequest::_InternalSerialize(
4882 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
4883 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.InsertKeyValueRequest)
4884 ::uint32_t cached_has_bits = 0;
4885 (void) cached_has_bits;
4886
4887 // .tensorflow.KeyValueEntry kv = 1;
4888 if (this->_internal_has_kv()) {
4889 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
4890 InternalWriteMessage(1, _Internal::kv(this),
4891 _Internal::kv(this).GetCachedSize(), target, stream);
4892 }
4893
4894 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4895 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
4896 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
4897 }
4898 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.InsertKeyValueRequest)
4899 return target;
4900 }
4901
ByteSizeLong() const4902 size_t InsertKeyValueRequest::ByteSizeLong() const {
4903 // @@protoc_insertion_point(message_byte_size_start:tensorflow.InsertKeyValueRequest)
4904 size_t total_size = 0;
4905
4906 ::uint32_t cached_has_bits = 0;
4907 // Prevent compiler warnings about cached_has_bits being unused
4908 (void) cached_has_bits;
4909
4910 // .tensorflow.KeyValueEntry kv = 1;
4911 if (this->_internal_has_kv()) {
4912 total_size += 1 +
4913 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
4914 *_impl_.kv_);
4915 }
4916
4917 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4918 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
4919 }
4920 int cached_size = ::_pbi::ToCachedSize(total_size);
4921 SetCachedSize(cached_size);
4922 return total_size;
4923 }
4924
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)4925 void InsertKeyValueRequest::CheckTypeAndMergeFrom(
4926 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
4927 MergeFrom(*::_pbi::DownCast<const InsertKeyValueRequest*>(
4928 &from));
4929 }
4930
MergeFrom(const InsertKeyValueRequest & from)4931 void InsertKeyValueRequest::MergeFrom(const InsertKeyValueRequest& from) {
4932 InsertKeyValueRequest* const _this = this;
4933 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.InsertKeyValueRequest)
4934 GOOGLE_DCHECK_NE(&from, _this);
4935 ::uint32_t cached_has_bits = 0;
4936 (void) cached_has_bits;
4937
4938 if (from._internal_has_kv()) {
4939 _this->_internal_mutable_kv()->::tensorflow::KeyValueEntry::MergeFrom(
4940 from._internal_kv());
4941 }
4942 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4943 }
4944
CopyFrom(const InsertKeyValueRequest & from)4945 void InsertKeyValueRequest::CopyFrom(const InsertKeyValueRequest& from) {
4946 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.InsertKeyValueRequest)
4947 if (&from == this) return;
4948 Clear();
4949 MergeFrom(from);
4950 }
4951
IsInitialized() const4952 bool InsertKeyValueRequest::IsInitialized() const {
4953 return true;
4954 }
4955
InternalSwap(InsertKeyValueRequest * other)4956 void InsertKeyValueRequest::InternalSwap(InsertKeyValueRequest* other) {
4957 using std::swap;
4958 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
4959 swap(_impl_.kv_, other->_impl_.kv_);
4960 }
4961
GetTypeName() const4962 std::string InsertKeyValueRequest::GetTypeName() const {
4963 return "tensorflow.InsertKeyValueRequest";
4964 }
4965
4966
4967 // ===================================================================
4968
4969 class InsertKeyValueResponse::_Internal {
4970 public:
4971 };
4972
InsertKeyValueResponse(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)4973 InsertKeyValueResponse::InsertKeyValueResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4974 bool is_message_owned)
4975 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
4976 SharedCtor(arena, is_message_owned);
4977 // @@protoc_insertion_point(arena_constructor:tensorflow.InsertKeyValueResponse)
4978 }
InsertKeyValueResponse(const InsertKeyValueResponse & from)4979 InsertKeyValueResponse::InsertKeyValueResponse(const InsertKeyValueResponse& from)
4980 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
4981 InsertKeyValueResponse* const _this = this; (void)_this;
4982 new (&_impl_) Impl_{
4983 /*decltype(_impl_._cached_size_)*/{}};
4984
4985 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4986 // @@protoc_insertion_point(copy_constructor:tensorflow.InsertKeyValueResponse)
4987 }
4988
SharedCtor(::_pb::Arena * arena,bool is_message_owned)4989 inline void InsertKeyValueResponse::SharedCtor(
4990 ::_pb::Arena* arena, bool is_message_owned) {
4991 (void)arena;
4992 (void)is_message_owned;
4993 new (&_impl_) Impl_{
4994 /*decltype(_impl_._cached_size_)*/{}
4995 };
4996 }
4997
~InsertKeyValueResponse()4998 InsertKeyValueResponse::~InsertKeyValueResponse() {
4999 // @@protoc_insertion_point(destructor:tensorflow.InsertKeyValueResponse)
5000 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
5001 (void)arena;
5002 return;
5003 }
5004 SharedDtor();
5005 }
5006
SharedDtor()5007 inline void InsertKeyValueResponse::SharedDtor() {
5008 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
5009 }
5010
SetCachedSize(int size) const5011 void InsertKeyValueResponse::SetCachedSize(int size) const {
5012 _impl_._cached_size_.Set(size);
5013 }
5014
Clear()5015 void InsertKeyValueResponse::Clear() {
5016 // @@protoc_insertion_point(message_clear_start:tensorflow.InsertKeyValueResponse)
5017 ::uint32_t cached_has_bits = 0;
5018 // Prevent compiler warnings about cached_has_bits being unused
5019 (void) cached_has_bits;
5020
5021 _internal_metadata_.Clear<std::string>();
5022 }
5023
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)5024 const char* InsertKeyValueResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
5025 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
5026 while (!ctx->Done(&ptr)) {
5027 ::uint32_t tag;
5028 ptr = ::_pbi::ReadTag(ptr, &tag);
5029 if ((tag == 0) || ((tag & 7) == 4)) {
5030 CHK_(ptr);
5031 ctx->SetLastTag(tag);
5032 goto message_done;
5033 }
5034 ptr = UnknownFieldParse(
5035 tag,
5036 _internal_metadata_.mutable_unknown_fields<std::string>(),
5037 ptr, ctx);
5038 CHK_(ptr != nullptr);
5039 } // while
5040 message_done:
5041 return ptr;
5042 failure:
5043 ptr = nullptr;
5044 goto message_done;
5045 #undef CHK_
5046 }
5047
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const5048 ::uint8_t* InsertKeyValueResponse::_InternalSerialize(
5049 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
5050 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.InsertKeyValueResponse)
5051 ::uint32_t cached_has_bits = 0;
5052 (void) cached_has_bits;
5053
5054 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5055 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
5056 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
5057 }
5058 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.InsertKeyValueResponse)
5059 return target;
5060 }
5061
ByteSizeLong() const5062 size_t InsertKeyValueResponse::ByteSizeLong() const {
5063 // @@protoc_insertion_point(message_byte_size_start:tensorflow.InsertKeyValueResponse)
5064 size_t total_size = 0;
5065
5066 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5067 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
5068 }
5069 int cached_size = ::_pbi::ToCachedSize(total_size);
5070 SetCachedSize(cached_size);
5071 return total_size;
5072 }
5073
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)5074 void InsertKeyValueResponse::CheckTypeAndMergeFrom(
5075 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
5076 MergeFrom(*::_pbi::DownCast<const InsertKeyValueResponse*>(
5077 &from));
5078 }
5079
MergeFrom(const InsertKeyValueResponse & from)5080 void InsertKeyValueResponse::MergeFrom(const InsertKeyValueResponse& from) {
5081 InsertKeyValueResponse* const _this = this;
5082 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.InsertKeyValueResponse)
5083 GOOGLE_DCHECK_NE(&from, _this);
5084 ::uint32_t cached_has_bits = 0;
5085 (void) cached_has_bits;
5086
5087 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5088 }
5089
CopyFrom(const InsertKeyValueResponse & from)5090 void InsertKeyValueResponse::CopyFrom(const InsertKeyValueResponse& from) {
5091 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.InsertKeyValueResponse)
5092 if (&from == this) return;
5093 Clear();
5094 MergeFrom(from);
5095 }
5096
IsInitialized() const5097 bool InsertKeyValueResponse::IsInitialized() const {
5098 return true;
5099 }
5100
InternalSwap(InsertKeyValueResponse * other)5101 void InsertKeyValueResponse::InternalSwap(InsertKeyValueResponse* other) {
5102 using std::swap;
5103 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
5104 }
5105
GetTypeName() const5106 std::string InsertKeyValueResponse::GetTypeName() const {
5107 return "tensorflow.InsertKeyValueResponse";
5108 }
5109
5110
5111 // ===================================================================
5112
5113 class GetKeyValueRequest::_Internal {
5114 public:
5115 };
5116
GetKeyValueRequest(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)5117 GetKeyValueRequest::GetKeyValueRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
5118 bool is_message_owned)
5119 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
5120 SharedCtor(arena, is_message_owned);
5121 // @@protoc_insertion_point(arena_constructor:tensorflow.GetKeyValueRequest)
5122 }
GetKeyValueRequest(const GetKeyValueRequest & from)5123 GetKeyValueRequest::GetKeyValueRequest(const GetKeyValueRequest& from)
5124 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
5125 GetKeyValueRequest* const _this = this; (void)_this;
5126 new (&_impl_) Impl_{
5127 decltype(_impl_.key_){}
5128 , /*decltype(_impl_._cached_size_)*/{}};
5129
5130 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5131 _impl_.key_.InitDefault();
5132 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5133 _impl_.key_.Set("", GetArenaForAllocation());
5134 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5135 if (!from._internal_key().empty()) {
5136 _this->_impl_.key_.Set(from._internal_key(),
5137 _this->GetArenaForAllocation());
5138 }
5139 // @@protoc_insertion_point(copy_constructor:tensorflow.GetKeyValueRequest)
5140 }
5141
SharedCtor(::_pb::Arena * arena,bool is_message_owned)5142 inline void GetKeyValueRequest::SharedCtor(
5143 ::_pb::Arena* arena, bool is_message_owned) {
5144 (void)arena;
5145 (void)is_message_owned;
5146 new (&_impl_) Impl_{
5147 decltype(_impl_.key_){}
5148 , /*decltype(_impl_._cached_size_)*/{}
5149 };
5150 _impl_.key_.InitDefault();
5151 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5152 _impl_.key_.Set("", GetArenaForAllocation());
5153 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5154 }
5155
~GetKeyValueRequest()5156 GetKeyValueRequest::~GetKeyValueRequest() {
5157 // @@protoc_insertion_point(destructor:tensorflow.GetKeyValueRequest)
5158 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
5159 (void)arena;
5160 return;
5161 }
5162 SharedDtor();
5163 }
5164
SharedDtor()5165 inline void GetKeyValueRequest::SharedDtor() {
5166 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
5167 _impl_.key_.Destroy();
5168 }
5169
SetCachedSize(int size) const5170 void GetKeyValueRequest::SetCachedSize(int size) const {
5171 _impl_._cached_size_.Set(size);
5172 }
5173
Clear()5174 void GetKeyValueRequest::Clear() {
5175 // @@protoc_insertion_point(message_clear_start:tensorflow.GetKeyValueRequest)
5176 ::uint32_t cached_has_bits = 0;
5177 // Prevent compiler warnings about cached_has_bits being unused
5178 (void) cached_has_bits;
5179
5180 _impl_.key_.ClearToEmpty();
5181 _internal_metadata_.Clear<std::string>();
5182 }
5183
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)5184 const char* GetKeyValueRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
5185 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
5186 while (!ctx->Done(&ptr)) {
5187 ::uint32_t tag;
5188 ptr = ::_pbi::ReadTag(ptr, &tag);
5189 switch (tag >> 3) {
5190 // string key = 1;
5191 case 1:
5192 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
5193 auto str = _internal_mutable_key();
5194 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
5195 CHK_(ptr);
5196 CHK_(::_pbi::VerifyUTF8(str, nullptr));
5197 } else {
5198 goto handle_unusual;
5199 }
5200 continue;
5201 default:
5202 goto handle_unusual;
5203 } // switch
5204 handle_unusual:
5205 if ((tag == 0) || ((tag & 7) == 4)) {
5206 CHK_(ptr);
5207 ctx->SetLastTag(tag);
5208 goto message_done;
5209 }
5210 ptr = UnknownFieldParse(
5211 tag,
5212 _internal_metadata_.mutable_unknown_fields<std::string>(),
5213 ptr, ctx);
5214 CHK_(ptr != nullptr);
5215 } // while
5216 message_done:
5217 return ptr;
5218 failure:
5219 ptr = nullptr;
5220 goto message_done;
5221 #undef CHK_
5222 }
5223
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const5224 ::uint8_t* GetKeyValueRequest::_InternalSerialize(
5225 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
5226 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.GetKeyValueRequest)
5227 ::uint32_t cached_has_bits = 0;
5228 (void) cached_has_bits;
5229
5230 // string key = 1;
5231 if (!this->_internal_key().empty()) {
5232 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
5233 this->_internal_key().data(), static_cast<int>(this->_internal_key().length()),
5234 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
5235 "tensorflow.GetKeyValueRequest.key");
5236 target = stream->WriteStringMaybeAliased(
5237 1, this->_internal_key(), target);
5238 }
5239
5240 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5241 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
5242 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
5243 }
5244 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.GetKeyValueRequest)
5245 return target;
5246 }
5247
ByteSizeLong() const5248 size_t GetKeyValueRequest::ByteSizeLong() const {
5249 // @@protoc_insertion_point(message_byte_size_start:tensorflow.GetKeyValueRequest)
5250 size_t total_size = 0;
5251
5252 ::uint32_t cached_has_bits = 0;
5253 // Prevent compiler warnings about cached_has_bits being unused
5254 (void) cached_has_bits;
5255
5256 // string key = 1;
5257 if (!this->_internal_key().empty()) {
5258 total_size += 1 +
5259 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
5260 this->_internal_key());
5261 }
5262
5263 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5264 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
5265 }
5266 int cached_size = ::_pbi::ToCachedSize(total_size);
5267 SetCachedSize(cached_size);
5268 return total_size;
5269 }
5270
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)5271 void GetKeyValueRequest::CheckTypeAndMergeFrom(
5272 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
5273 MergeFrom(*::_pbi::DownCast<const GetKeyValueRequest*>(
5274 &from));
5275 }
5276
MergeFrom(const GetKeyValueRequest & from)5277 void GetKeyValueRequest::MergeFrom(const GetKeyValueRequest& from) {
5278 GetKeyValueRequest* const _this = this;
5279 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.GetKeyValueRequest)
5280 GOOGLE_DCHECK_NE(&from, _this);
5281 ::uint32_t cached_has_bits = 0;
5282 (void) cached_has_bits;
5283
5284 if (!from._internal_key().empty()) {
5285 _this->_internal_set_key(from._internal_key());
5286 }
5287 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5288 }
5289
CopyFrom(const GetKeyValueRequest & from)5290 void GetKeyValueRequest::CopyFrom(const GetKeyValueRequest& from) {
5291 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.GetKeyValueRequest)
5292 if (&from == this) return;
5293 Clear();
5294 MergeFrom(from);
5295 }
5296
IsInitialized() const5297 bool GetKeyValueRequest::IsInitialized() const {
5298 return true;
5299 }
5300
InternalSwap(GetKeyValueRequest * other)5301 void GetKeyValueRequest::InternalSwap(GetKeyValueRequest* other) {
5302 using std::swap;
5303 auto* lhs_arena = GetArenaForAllocation();
5304 auto* rhs_arena = other->GetArenaForAllocation();
5305 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
5306 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
5307 &_impl_.key_, lhs_arena,
5308 &other->_impl_.key_, rhs_arena
5309 );
5310 }
5311
GetTypeName() const5312 std::string GetKeyValueRequest::GetTypeName() const {
5313 return "tensorflow.GetKeyValueRequest";
5314 }
5315
5316
5317 // ===================================================================
5318
5319 class GetKeyValueResponse::_Internal {
5320 public:
5321 static const ::tensorflow::KeyValueEntry& kv(const GetKeyValueResponse* msg);
5322 };
5323
5324 const ::tensorflow::KeyValueEntry&
kv(const GetKeyValueResponse * msg)5325 GetKeyValueResponse::_Internal::kv(const GetKeyValueResponse* msg) {
5326 return *msg->_impl_.kv_;
5327 }
GetKeyValueResponse(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)5328 GetKeyValueResponse::GetKeyValueResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
5329 bool is_message_owned)
5330 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
5331 SharedCtor(arena, is_message_owned);
5332 // @@protoc_insertion_point(arena_constructor:tensorflow.GetKeyValueResponse)
5333 }
GetKeyValueResponse(const GetKeyValueResponse & from)5334 GetKeyValueResponse::GetKeyValueResponse(const GetKeyValueResponse& from)
5335 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
5336 GetKeyValueResponse* const _this = this; (void)_this;
5337 new (&_impl_) Impl_{
5338 decltype(_impl_.kv_){nullptr}
5339 , /*decltype(_impl_._cached_size_)*/{}};
5340
5341 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5342 if (from._internal_has_kv()) {
5343 _this->_impl_.kv_ = new ::tensorflow::KeyValueEntry(*from._impl_.kv_);
5344 }
5345 // @@protoc_insertion_point(copy_constructor:tensorflow.GetKeyValueResponse)
5346 }
5347
SharedCtor(::_pb::Arena * arena,bool is_message_owned)5348 inline void GetKeyValueResponse::SharedCtor(
5349 ::_pb::Arena* arena, bool is_message_owned) {
5350 (void)arena;
5351 (void)is_message_owned;
5352 new (&_impl_) Impl_{
5353 decltype(_impl_.kv_){nullptr}
5354 , /*decltype(_impl_._cached_size_)*/{}
5355 };
5356 }
5357
~GetKeyValueResponse()5358 GetKeyValueResponse::~GetKeyValueResponse() {
5359 // @@protoc_insertion_point(destructor:tensorflow.GetKeyValueResponse)
5360 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
5361 (void)arena;
5362 return;
5363 }
5364 SharedDtor();
5365 }
5366
SharedDtor()5367 inline void GetKeyValueResponse::SharedDtor() {
5368 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
5369 if (this != internal_default_instance()) delete _impl_.kv_;
5370 }
5371
SetCachedSize(int size) const5372 void GetKeyValueResponse::SetCachedSize(int size) const {
5373 _impl_._cached_size_.Set(size);
5374 }
5375
Clear()5376 void GetKeyValueResponse::Clear() {
5377 // @@protoc_insertion_point(message_clear_start:tensorflow.GetKeyValueResponse)
5378 ::uint32_t cached_has_bits = 0;
5379 // Prevent compiler warnings about cached_has_bits being unused
5380 (void) cached_has_bits;
5381
5382 if (GetArenaForAllocation() == nullptr && _impl_.kv_ != nullptr) {
5383 delete _impl_.kv_;
5384 }
5385 _impl_.kv_ = nullptr;
5386 _internal_metadata_.Clear<std::string>();
5387 }
5388
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)5389 const char* GetKeyValueResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
5390 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
5391 while (!ctx->Done(&ptr)) {
5392 ::uint32_t tag;
5393 ptr = ::_pbi::ReadTag(ptr, &tag);
5394 switch (tag >> 3) {
5395 // .tensorflow.KeyValueEntry kv = 1;
5396 case 1:
5397 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
5398 ptr = ctx->ParseMessage(_internal_mutable_kv(), ptr);
5399 CHK_(ptr);
5400 } else {
5401 goto handle_unusual;
5402 }
5403 continue;
5404 default:
5405 goto handle_unusual;
5406 } // switch
5407 handle_unusual:
5408 if ((tag == 0) || ((tag & 7) == 4)) {
5409 CHK_(ptr);
5410 ctx->SetLastTag(tag);
5411 goto message_done;
5412 }
5413 ptr = UnknownFieldParse(
5414 tag,
5415 _internal_metadata_.mutable_unknown_fields<std::string>(),
5416 ptr, ctx);
5417 CHK_(ptr != nullptr);
5418 } // while
5419 message_done:
5420 return ptr;
5421 failure:
5422 ptr = nullptr;
5423 goto message_done;
5424 #undef CHK_
5425 }
5426
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const5427 ::uint8_t* GetKeyValueResponse::_InternalSerialize(
5428 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
5429 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.GetKeyValueResponse)
5430 ::uint32_t cached_has_bits = 0;
5431 (void) cached_has_bits;
5432
5433 // .tensorflow.KeyValueEntry kv = 1;
5434 if (this->_internal_has_kv()) {
5435 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
5436 InternalWriteMessage(1, _Internal::kv(this),
5437 _Internal::kv(this).GetCachedSize(), target, stream);
5438 }
5439
5440 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5441 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
5442 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
5443 }
5444 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.GetKeyValueResponse)
5445 return target;
5446 }
5447
ByteSizeLong() const5448 size_t GetKeyValueResponse::ByteSizeLong() const {
5449 // @@protoc_insertion_point(message_byte_size_start:tensorflow.GetKeyValueResponse)
5450 size_t total_size = 0;
5451
5452 ::uint32_t cached_has_bits = 0;
5453 // Prevent compiler warnings about cached_has_bits being unused
5454 (void) cached_has_bits;
5455
5456 // .tensorflow.KeyValueEntry kv = 1;
5457 if (this->_internal_has_kv()) {
5458 total_size += 1 +
5459 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
5460 *_impl_.kv_);
5461 }
5462
5463 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5464 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
5465 }
5466 int cached_size = ::_pbi::ToCachedSize(total_size);
5467 SetCachedSize(cached_size);
5468 return total_size;
5469 }
5470
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)5471 void GetKeyValueResponse::CheckTypeAndMergeFrom(
5472 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
5473 MergeFrom(*::_pbi::DownCast<const GetKeyValueResponse*>(
5474 &from));
5475 }
5476
MergeFrom(const GetKeyValueResponse & from)5477 void GetKeyValueResponse::MergeFrom(const GetKeyValueResponse& from) {
5478 GetKeyValueResponse* const _this = this;
5479 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.GetKeyValueResponse)
5480 GOOGLE_DCHECK_NE(&from, _this);
5481 ::uint32_t cached_has_bits = 0;
5482 (void) cached_has_bits;
5483
5484 if (from._internal_has_kv()) {
5485 _this->_internal_mutable_kv()->::tensorflow::KeyValueEntry::MergeFrom(
5486 from._internal_kv());
5487 }
5488 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5489 }
5490
CopyFrom(const GetKeyValueResponse & from)5491 void GetKeyValueResponse::CopyFrom(const GetKeyValueResponse& from) {
5492 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.GetKeyValueResponse)
5493 if (&from == this) return;
5494 Clear();
5495 MergeFrom(from);
5496 }
5497
IsInitialized() const5498 bool GetKeyValueResponse::IsInitialized() const {
5499 return true;
5500 }
5501
InternalSwap(GetKeyValueResponse * other)5502 void GetKeyValueResponse::InternalSwap(GetKeyValueResponse* other) {
5503 using std::swap;
5504 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
5505 swap(_impl_.kv_, other->_impl_.kv_);
5506 }
5507
GetTypeName() const5508 std::string GetKeyValueResponse::GetTypeName() const {
5509 return "tensorflow.GetKeyValueResponse";
5510 }
5511
5512
5513 // ===================================================================
5514
5515 class TryGetKeyValueRequest::_Internal {
5516 public:
5517 };
5518
TryGetKeyValueRequest(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)5519 TryGetKeyValueRequest::TryGetKeyValueRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
5520 bool is_message_owned)
5521 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
5522 SharedCtor(arena, is_message_owned);
5523 // @@protoc_insertion_point(arena_constructor:tensorflow.TryGetKeyValueRequest)
5524 }
TryGetKeyValueRequest(const TryGetKeyValueRequest & from)5525 TryGetKeyValueRequest::TryGetKeyValueRequest(const TryGetKeyValueRequest& from)
5526 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
5527 TryGetKeyValueRequest* const _this = this; (void)_this;
5528 new (&_impl_) Impl_{
5529 decltype(_impl_.key_){}
5530 , /*decltype(_impl_._cached_size_)*/{}};
5531
5532 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5533 _impl_.key_.InitDefault();
5534 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5535 _impl_.key_.Set("", GetArenaForAllocation());
5536 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5537 if (!from._internal_key().empty()) {
5538 _this->_impl_.key_.Set(from._internal_key(),
5539 _this->GetArenaForAllocation());
5540 }
5541 // @@protoc_insertion_point(copy_constructor:tensorflow.TryGetKeyValueRequest)
5542 }
5543
SharedCtor(::_pb::Arena * arena,bool is_message_owned)5544 inline void TryGetKeyValueRequest::SharedCtor(
5545 ::_pb::Arena* arena, bool is_message_owned) {
5546 (void)arena;
5547 (void)is_message_owned;
5548 new (&_impl_) Impl_{
5549 decltype(_impl_.key_){}
5550 , /*decltype(_impl_._cached_size_)*/{}
5551 };
5552 _impl_.key_.InitDefault();
5553 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5554 _impl_.key_.Set("", GetArenaForAllocation());
5555 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5556 }
5557
~TryGetKeyValueRequest()5558 TryGetKeyValueRequest::~TryGetKeyValueRequest() {
5559 // @@protoc_insertion_point(destructor:tensorflow.TryGetKeyValueRequest)
5560 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
5561 (void)arena;
5562 return;
5563 }
5564 SharedDtor();
5565 }
5566
SharedDtor()5567 inline void TryGetKeyValueRequest::SharedDtor() {
5568 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
5569 _impl_.key_.Destroy();
5570 }
5571
SetCachedSize(int size) const5572 void TryGetKeyValueRequest::SetCachedSize(int size) const {
5573 _impl_._cached_size_.Set(size);
5574 }
5575
Clear()5576 void TryGetKeyValueRequest::Clear() {
5577 // @@protoc_insertion_point(message_clear_start:tensorflow.TryGetKeyValueRequest)
5578 ::uint32_t cached_has_bits = 0;
5579 // Prevent compiler warnings about cached_has_bits being unused
5580 (void) cached_has_bits;
5581
5582 _impl_.key_.ClearToEmpty();
5583 _internal_metadata_.Clear<std::string>();
5584 }
5585
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)5586 const char* TryGetKeyValueRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
5587 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
5588 while (!ctx->Done(&ptr)) {
5589 ::uint32_t tag;
5590 ptr = ::_pbi::ReadTag(ptr, &tag);
5591 switch (tag >> 3) {
5592 // string key = 1;
5593 case 1:
5594 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
5595 auto str = _internal_mutable_key();
5596 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
5597 CHK_(ptr);
5598 CHK_(::_pbi::VerifyUTF8(str, nullptr));
5599 } else {
5600 goto handle_unusual;
5601 }
5602 continue;
5603 default:
5604 goto handle_unusual;
5605 } // switch
5606 handle_unusual:
5607 if ((tag == 0) || ((tag & 7) == 4)) {
5608 CHK_(ptr);
5609 ctx->SetLastTag(tag);
5610 goto message_done;
5611 }
5612 ptr = UnknownFieldParse(
5613 tag,
5614 _internal_metadata_.mutable_unknown_fields<std::string>(),
5615 ptr, ctx);
5616 CHK_(ptr != nullptr);
5617 } // while
5618 message_done:
5619 return ptr;
5620 failure:
5621 ptr = nullptr;
5622 goto message_done;
5623 #undef CHK_
5624 }
5625
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const5626 ::uint8_t* TryGetKeyValueRequest::_InternalSerialize(
5627 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
5628 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.TryGetKeyValueRequest)
5629 ::uint32_t cached_has_bits = 0;
5630 (void) cached_has_bits;
5631
5632 // string key = 1;
5633 if (!this->_internal_key().empty()) {
5634 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
5635 this->_internal_key().data(), static_cast<int>(this->_internal_key().length()),
5636 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
5637 "tensorflow.TryGetKeyValueRequest.key");
5638 target = stream->WriteStringMaybeAliased(
5639 1, this->_internal_key(), target);
5640 }
5641
5642 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5643 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
5644 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
5645 }
5646 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.TryGetKeyValueRequest)
5647 return target;
5648 }
5649
ByteSizeLong() const5650 size_t TryGetKeyValueRequest::ByteSizeLong() const {
5651 // @@protoc_insertion_point(message_byte_size_start:tensorflow.TryGetKeyValueRequest)
5652 size_t total_size = 0;
5653
5654 ::uint32_t cached_has_bits = 0;
5655 // Prevent compiler warnings about cached_has_bits being unused
5656 (void) cached_has_bits;
5657
5658 // string key = 1;
5659 if (!this->_internal_key().empty()) {
5660 total_size += 1 +
5661 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
5662 this->_internal_key());
5663 }
5664
5665 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5666 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
5667 }
5668 int cached_size = ::_pbi::ToCachedSize(total_size);
5669 SetCachedSize(cached_size);
5670 return total_size;
5671 }
5672
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)5673 void TryGetKeyValueRequest::CheckTypeAndMergeFrom(
5674 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
5675 MergeFrom(*::_pbi::DownCast<const TryGetKeyValueRequest*>(
5676 &from));
5677 }
5678
MergeFrom(const TryGetKeyValueRequest & from)5679 void TryGetKeyValueRequest::MergeFrom(const TryGetKeyValueRequest& from) {
5680 TryGetKeyValueRequest* const _this = this;
5681 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.TryGetKeyValueRequest)
5682 GOOGLE_DCHECK_NE(&from, _this);
5683 ::uint32_t cached_has_bits = 0;
5684 (void) cached_has_bits;
5685
5686 if (!from._internal_key().empty()) {
5687 _this->_internal_set_key(from._internal_key());
5688 }
5689 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5690 }
5691
CopyFrom(const TryGetKeyValueRequest & from)5692 void TryGetKeyValueRequest::CopyFrom(const TryGetKeyValueRequest& from) {
5693 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.TryGetKeyValueRequest)
5694 if (&from == this) return;
5695 Clear();
5696 MergeFrom(from);
5697 }
5698
IsInitialized() const5699 bool TryGetKeyValueRequest::IsInitialized() const {
5700 return true;
5701 }
5702
InternalSwap(TryGetKeyValueRequest * other)5703 void TryGetKeyValueRequest::InternalSwap(TryGetKeyValueRequest* other) {
5704 using std::swap;
5705 auto* lhs_arena = GetArenaForAllocation();
5706 auto* rhs_arena = other->GetArenaForAllocation();
5707 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
5708 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
5709 &_impl_.key_, lhs_arena,
5710 &other->_impl_.key_, rhs_arena
5711 );
5712 }
5713
GetTypeName() const5714 std::string TryGetKeyValueRequest::GetTypeName() const {
5715 return "tensorflow.TryGetKeyValueRequest";
5716 }
5717
5718
5719 // ===================================================================
5720
5721 class TryGetKeyValueResponse::_Internal {
5722 public:
5723 static const ::tensorflow::KeyValueEntry& kv(const TryGetKeyValueResponse* msg);
5724 };
5725
5726 const ::tensorflow::KeyValueEntry&
kv(const TryGetKeyValueResponse * msg)5727 TryGetKeyValueResponse::_Internal::kv(const TryGetKeyValueResponse* msg) {
5728 return *msg->_impl_.kv_;
5729 }
TryGetKeyValueResponse(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)5730 TryGetKeyValueResponse::TryGetKeyValueResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
5731 bool is_message_owned)
5732 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
5733 SharedCtor(arena, is_message_owned);
5734 // @@protoc_insertion_point(arena_constructor:tensorflow.TryGetKeyValueResponse)
5735 }
TryGetKeyValueResponse(const TryGetKeyValueResponse & from)5736 TryGetKeyValueResponse::TryGetKeyValueResponse(const TryGetKeyValueResponse& from)
5737 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
5738 TryGetKeyValueResponse* const _this = this; (void)_this;
5739 new (&_impl_) Impl_{
5740 decltype(_impl_.kv_){nullptr}
5741 , /*decltype(_impl_._cached_size_)*/{}};
5742
5743 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5744 if (from._internal_has_kv()) {
5745 _this->_impl_.kv_ = new ::tensorflow::KeyValueEntry(*from._impl_.kv_);
5746 }
5747 // @@protoc_insertion_point(copy_constructor:tensorflow.TryGetKeyValueResponse)
5748 }
5749
SharedCtor(::_pb::Arena * arena,bool is_message_owned)5750 inline void TryGetKeyValueResponse::SharedCtor(
5751 ::_pb::Arena* arena, bool is_message_owned) {
5752 (void)arena;
5753 (void)is_message_owned;
5754 new (&_impl_) Impl_{
5755 decltype(_impl_.kv_){nullptr}
5756 , /*decltype(_impl_._cached_size_)*/{}
5757 };
5758 }
5759
~TryGetKeyValueResponse()5760 TryGetKeyValueResponse::~TryGetKeyValueResponse() {
5761 // @@protoc_insertion_point(destructor:tensorflow.TryGetKeyValueResponse)
5762 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
5763 (void)arena;
5764 return;
5765 }
5766 SharedDtor();
5767 }
5768
SharedDtor()5769 inline void TryGetKeyValueResponse::SharedDtor() {
5770 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
5771 if (this != internal_default_instance()) delete _impl_.kv_;
5772 }
5773
SetCachedSize(int size) const5774 void TryGetKeyValueResponse::SetCachedSize(int size) const {
5775 _impl_._cached_size_.Set(size);
5776 }
5777
Clear()5778 void TryGetKeyValueResponse::Clear() {
5779 // @@protoc_insertion_point(message_clear_start:tensorflow.TryGetKeyValueResponse)
5780 ::uint32_t cached_has_bits = 0;
5781 // Prevent compiler warnings about cached_has_bits being unused
5782 (void) cached_has_bits;
5783
5784 if (GetArenaForAllocation() == nullptr && _impl_.kv_ != nullptr) {
5785 delete _impl_.kv_;
5786 }
5787 _impl_.kv_ = nullptr;
5788 _internal_metadata_.Clear<std::string>();
5789 }
5790
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)5791 const char* TryGetKeyValueResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
5792 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
5793 while (!ctx->Done(&ptr)) {
5794 ::uint32_t tag;
5795 ptr = ::_pbi::ReadTag(ptr, &tag);
5796 switch (tag >> 3) {
5797 // .tensorflow.KeyValueEntry kv = 1;
5798 case 1:
5799 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
5800 ptr = ctx->ParseMessage(_internal_mutable_kv(), ptr);
5801 CHK_(ptr);
5802 } else {
5803 goto handle_unusual;
5804 }
5805 continue;
5806 default:
5807 goto handle_unusual;
5808 } // switch
5809 handle_unusual:
5810 if ((tag == 0) || ((tag & 7) == 4)) {
5811 CHK_(ptr);
5812 ctx->SetLastTag(tag);
5813 goto message_done;
5814 }
5815 ptr = UnknownFieldParse(
5816 tag,
5817 _internal_metadata_.mutable_unknown_fields<std::string>(),
5818 ptr, ctx);
5819 CHK_(ptr != nullptr);
5820 } // while
5821 message_done:
5822 return ptr;
5823 failure:
5824 ptr = nullptr;
5825 goto message_done;
5826 #undef CHK_
5827 }
5828
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const5829 ::uint8_t* TryGetKeyValueResponse::_InternalSerialize(
5830 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
5831 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.TryGetKeyValueResponse)
5832 ::uint32_t cached_has_bits = 0;
5833 (void) cached_has_bits;
5834
5835 // .tensorflow.KeyValueEntry kv = 1;
5836 if (this->_internal_has_kv()) {
5837 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
5838 InternalWriteMessage(1, _Internal::kv(this),
5839 _Internal::kv(this).GetCachedSize(), target, stream);
5840 }
5841
5842 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5843 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
5844 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
5845 }
5846 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.TryGetKeyValueResponse)
5847 return target;
5848 }
5849
ByteSizeLong() const5850 size_t TryGetKeyValueResponse::ByteSizeLong() const {
5851 // @@protoc_insertion_point(message_byte_size_start:tensorflow.TryGetKeyValueResponse)
5852 size_t total_size = 0;
5853
5854 ::uint32_t cached_has_bits = 0;
5855 // Prevent compiler warnings about cached_has_bits being unused
5856 (void) cached_has_bits;
5857
5858 // .tensorflow.KeyValueEntry kv = 1;
5859 if (this->_internal_has_kv()) {
5860 total_size += 1 +
5861 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
5862 *_impl_.kv_);
5863 }
5864
5865 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5866 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
5867 }
5868 int cached_size = ::_pbi::ToCachedSize(total_size);
5869 SetCachedSize(cached_size);
5870 return total_size;
5871 }
5872
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)5873 void TryGetKeyValueResponse::CheckTypeAndMergeFrom(
5874 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
5875 MergeFrom(*::_pbi::DownCast<const TryGetKeyValueResponse*>(
5876 &from));
5877 }
5878
MergeFrom(const TryGetKeyValueResponse & from)5879 void TryGetKeyValueResponse::MergeFrom(const TryGetKeyValueResponse& from) {
5880 TryGetKeyValueResponse* const _this = this;
5881 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.TryGetKeyValueResponse)
5882 GOOGLE_DCHECK_NE(&from, _this);
5883 ::uint32_t cached_has_bits = 0;
5884 (void) cached_has_bits;
5885
5886 if (from._internal_has_kv()) {
5887 _this->_internal_mutable_kv()->::tensorflow::KeyValueEntry::MergeFrom(
5888 from._internal_kv());
5889 }
5890 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5891 }
5892
CopyFrom(const TryGetKeyValueResponse & from)5893 void TryGetKeyValueResponse::CopyFrom(const TryGetKeyValueResponse& from) {
5894 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.TryGetKeyValueResponse)
5895 if (&from == this) return;
5896 Clear();
5897 MergeFrom(from);
5898 }
5899
IsInitialized() const5900 bool TryGetKeyValueResponse::IsInitialized() const {
5901 return true;
5902 }
5903
InternalSwap(TryGetKeyValueResponse * other)5904 void TryGetKeyValueResponse::InternalSwap(TryGetKeyValueResponse* other) {
5905 using std::swap;
5906 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
5907 swap(_impl_.kv_, other->_impl_.kv_);
5908 }
5909
GetTypeName() const5910 std::string TryGetKeyValueResponse::GetTypeName() const {
5911 return "tensorflow.TryGetKeyValueResponse";
5912 }
5913
5914
5915 // ===================================================================
5916
5917 class GetKeyValueDirRequest::_Internal {
5918 public:
5919 };
5920
GetKeyValueDirRequest(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)5921 GetKeyValueDirRequest::GetKeyValueDirRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
5922 bool is_message_owned)
5923 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
5924 SharedCtor(arena, is_message_owned);
5925 // @@protoc_insertion_point(arena_constructor:tensorflow.GetKeyValueDirRequest)
5926 }
GetKeyValueDirRequest(const GetKeyValueDirRequest & from)5927 GetKeyValueDirRequest::GetKeyValueDirRequest(const GetKeyValueDirRequest& from)
5928 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
5929 GetKeyValueDirRequest* const _this = this; (void)_this;
5930 new (&_impl_) Impl_{
5931 decltype(_impl_.directory_key_){}
5932 , /*decltype(_impl_._cached_size_)*/{}};
5933
5934 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5935 _impl_.directory_key_.InitDefault();
5936 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5937 _impl_.directory_key_.Set("", GetArenaForAllocation());
5938 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5939 if (!from._internal_directory_key().empty()) {
5940 _this->_impl_.directory_key_.Set(from._internal_directory_key(),
5941 _this->GetArenaForAllocation());
5942 }
5943 // @@protoc_insertion_point(copy_constructor:tensorflow.GetKeyValueDirRequest)
5944 }
5945
SharedCtor(::_pb::Arena * arena,bool is_message_owned)5946 inline void GetKeyValueDirRequest::SharedCtor(
5947 ::_pb::Arena* arena, bool is_message_owned) {
5948 (void)arena;
5949 (void)is_message_owned;
5950 new (&_impl_) Impl_{
5951 decltype(_impl_.directory_key_){}
5952 , /*decltype(_impl_._cached_size_)*/{}
5953 };
5954 _impl_.directory_key_.InitDefault();
5955 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5956 _impl_.directory_key_.Set("", GetArenaForAllocation());
5957 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5958 }
5959
~GetKeyValueDirRequest()5960 GetKeyValueDirRequest::~GetKeyValueDirRequest() {
5961 // @@protoc_insertion_point(destructor:tensorflow.GetKeyValueDirRequest)
5962 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
5963 (void)arena;
5964 return;
5965 }
5966 SharedDtor();
5967 }
5968
SharedDtor()5969 inline void GetKeyValueDirRequest::SharedDtor() {
5970 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
5971 _impl_.directory_key_.Destroy();
5972 }
5973
SetCachedSize(int size) const5974 void GetKeyValueDirRequest::SetCachedSize(int size) const {
5975 _impl_._cached_size_.Set(size);
5976 }
5977
Clear()5978 void GetKeyValueDirRequest::Clear() {
5979 // @@protoc_insertion_point(message_clear_start:tensorflow.GetKeyValueDirRequest)
5980 ::uint32_t cached_has_bits = 0;
5981 // Prevent compiler warnings about cached_has_bits being unused
5982 (void) cached_has_bits;
5983
5984 _impl_.directory_key_.ClearToEmpty();
5985 _internal_metadata_.Clear<std::string>();
5986 }
5987
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)5988 const char* GetKeyValueDirRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
5989 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
5990 while (!ctx->Done(&ptr)) {
5991 ::uint32_t tag;
5992 ptr = ::_pbi::ReadTag(ptr, &tag);
5993 switch (tag >> 3) {
5994 // string directory_key = 1;
5995 case 1:
5996 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
5997 auto str = _internal_mutable_directory_key();
5998 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
5999 CHK_(ptr);
6000 CHK_(::_pbi::VerifyUTF8(str, nullptr));
6001 } else {
6002 goto handle_unusual;
6003 }
6004 continue;
6005 default:
6006 goto handle_unusual;
6007 } // switch
6008 handle_unusual:
6009 if ((tag == 0) || ((tag & 7) == 4)) {
6010 CHK_(ptr);
6011 ctx->SetLastTag(tag);
6012 goto message_done;
6013 }
6014 ptr = UnknownFieldParse(
6015 tag,
6016 _internal_metadata_.mutable_unknown_fields<std::string>(),
6017 ptr, ctx);
6018 CHK_(ptr != nullptr);
6019 } // while
6020 message_done:
6021 return ptr;
6022 failure:
6023 ptr = nullptr;
6024 goto message_done;
6025 #undef CHK_
6026 }
6027
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const6028 ::uint8_t* GetKeyValueDirRequest::_InternalSerialize(
6029 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
6030 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.GetKeyValueDirRequest)
6031 ::uint32_t cached_has_bits = 0;
6032 (void) cached_has_bits;
6033
6034 // string directory_key = 1;
6035 if (!this->_internal_directory_key().empty()) {
6036 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
6037 this->_internal_directory_key().data(), static_cast<int>(this->_internal_directory_key().length()),
6038 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
6039 "tensorflow.GetKeyValueDirRequest.directory_key");
6040 target = stream->WriteStringMaybeAliased(
6041 1, this->_internal_directory_key(), target);
6042 }
6043
6044 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
6045 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
6046 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
6047 }
6048 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.GetKeyValueDirRequest)
6049 return target;
6050 }
6051
ByteSizeLong() const6052 size_t GetKeyValueDirRequest::ByteSizeLong() const {
6053 // @@protoc_insertion_point(message_byte_size_start:tensorflow.GetKeyValueDirRequest)
6054 size_t total_size = 0;
6055
6056 ::uint32_t cached_has_bits = 0;
6057 // Prevent compiler warnings about cached_has_bits being unused
6058 (void) cached_has_bits;
6059
6060 // string directory_key = 1;
6061 if (!this->_internal_directory_key().empty()) {
6062 total_size += 1 +
6063 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
6064 this->_internal_directory_key());
6065 }
6066
6067 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
6068 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
6069 }
6070 int cached_size = ::_pbi::ToCachedSize(total_size);
6071 SetCachedSize(cached_size);
6072 return total_size;
6073 }
6074
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)6075 void GetKeyValueDirRequest::CheckTypeAndMergeFrom(
6076 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
6077 MergeFrom(*::_pbi::DownCast<const GetKeyValueDirRequest*>(
6078 &from));
6079 }
6080
MergeFrom(const GetKeyValueDirRequest & from)6081 void GetKeyValueDirRequest::MergeFrom(const GetKeyValueDirRequest& from) {
6082 GetKeyValueDirRequest* const _this = this;
6083 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.GetKeyValueDirRequest)
6084 GOOGLE_DCHECK_NE(&from, _this);
6085 ::uint32_t cached_has_bits = 0;
6086 (void) cached_has_bits;
6087
6088 if (!from._internal_directory_key().empty()) {
6089 _this->_internal_set_directory_key(from._internal_directory_key());
6090 }
6091 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
6092 }
6093
CopyFrom(const GetKeyValueDirRequest & from)6094 void GetKeyValueDirRequest::CopyFrom(const GetKeyValueDirRequest& from) {
6095 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.GetKeyValueDirRequest)
6096 if (&from == this) return;
6097 Clear();
6098 MergeFrom(from);
6099 }
6100
IsInitialized() const6101 bool GetKeyValueDirRequest::IsInitialized() const {
6102 return true;
6103 }
6104
InternalSwap(GetKeyValueDirRequest * other)6105 void GetKeyValueDirRequest::InternalSwap(GetKeyValueDirRequest* other) {
6106 using std::swap;
6107 auto* lhs_arena = GetArenaForAllocation();
6108 auto* rhs_arena = other->GetArenaForAllocation();
6109 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
6110 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
6111 &_impl_.directory_key_, lhs_arena,
6112 &other->_impl_.directory_key_, rhs_arena
6113 );
6114 }
6115
GetTypeName() const6116 std::string GetKeyValueDirRequest::GetTypeName() const {
6117 return "tensorflow.GetKeyValueDirRequest";
6118 }
6119
6120
6121 // ===================================================================
6122
6123 class GetKeyValueDirResponse::_Internal {
6124 public:
6125 };
6126
GetKeyValueDirResponse(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)6127 GetKeyValueDirResponse::GetKeyValueDirResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
6128 bool is_message_owned)
6129 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
6130 SharedCtor(arena, is_message_owned);
6131 // @@protoc_insertion_point(arena_constructor:tensorflow.GetKeyValueDirResponse)
6132 }
GetKeyValueDirResponse(const GetKeyValueDirResponse & from)6133 GetKeyValueDirResponse::GetKeyValueDirResponse(const GetKeyValueDirResponse& from)
6134 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
6135 GetKeyValueDirResponse* const _this = this; (void)_this;
6136 new (&_impl_) Impl_{
6137 decltype(_impl_.kv_){from._impl_.kv_}
6138 , decltype(_impl_.directory_key_){}
6139 , /*decltype(_impl_._cached_size_)*/{}};
6140
6141 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
6142 _impl_.directory_key_.InitDefault();
6143 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6144 _impl_.directory_key_.Set("", GetArenaForAllocation());
6145 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6146 if (!from._internal_directory_key().empty()) {
6147 _this->_impl_.directory_key_.Set(from._internal_directory_key(),
6148 _this->GetArenaForAllocation());
6149 }
6150 // @@protoc_insertion_point(copy_constructor:tensorflow.GetKeyValueDirResponse)
6151 }
6152
SharedCtor(::_pb::Arena * arena,bool is_message_owned)6153 inline void GetKeyValueDirResponse::SharedCtor(
6154 ::_pb::Arena* arena, bool is_message_owned) {
6155 (void)arena;
6156 (void)is_message_owned;
6157 new (&_impl_) Impl_{
6158 decltype(_impl_.kv_){arena}
6159 , decltype(_impl_.directory_key_){}
6160 , /*decltype(_impl_._cached_size_)*/{}
6161 };
6162 _impl_.directory_key_.InitDefault();
6163 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6164 _impl_.directory_key_.Set("", GetArenaForAllocation());
6165 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6166 }
6167
~GetKeyValueDirResponse()6168 GetKeyValueDirResponse::~GetKeyValueDirResponse() {
6169 // @@protoc_insertion_point(destructor:tensorflow.GetKeyValueDirResponse)
6170 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
6171 (void)arena;
6172 return;
6173 }
6174 SharedDtor();
6175 }
6176
SharedDtor()6177 inline void GetKeyValueDirResponse::SharedDtor() {
6178 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
6179 _impl_.kv_.~RepeatedPtrField();
6180 _impl_.directory_key_.Destroy();
6181 }
6182
SetCachedSize(int size) const6183 void GetKeyValueDirResponse::SetCachedSize(int size) const {
6184 _impl_._cached_size_.Set(size);
6185 }
6186
Clear()6187 void GetKeyValueDirResponse::Clear() {
6188 // @@protoc_insertion_point(message_clear_start:tensorflow.GetKeyValueDirResponse)
6189 ::uint32_t cached_has_bits = 0;
6190 // Prevent compiler warnings about cached_has_bits being unused
6191 (void) cached_has_bits;
6192
6193 _impl_.kv_.Clear();
6194 _impl_.directory_key_.ClearToEmpty();
6195 _internal_metadata_.Clear<std::string>();
6196 }
6197
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)6198 const char* GetKeyValueDirResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
6199 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
6200 while (!ctx->Done(&ptr)) {
6201 ::uint32_t tag;
6202 ptr = ::_pbi::ReadTag(ptr, &tag);
6203 switch (tag >> 3) {
6204 // string directory_key = 1;
6205 case 1:
6206 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
6207 auto str = _internal_mutable_directory_key();
6208 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
6209 CHK_(ptr);
6210 CHK_(::_pbi::VerifyUTF8(str, nullptr));
6211 } else {
6212 goto handle_unusual;
6213 }
6214 continue;
6215 // repeated .tensorflow.KeyValueEntry kv = 2;
6216 case 2:
6217 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
6218 ptr -= 1;
6219 do {
6220 ptr += 1;
6221 ptr = ctx->ParseMessage(_internal_add_kv(), ptr);
6222 CHK_(ptr);
6223 if (!ctx->DataAvailable(ptr)) break;
6224 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
6225 } else {
6226 goto handle_unusual;
6227 }
6228 continue;
6229 default:
6230 goto handle_unusual;
6231 } // switch
6232 handle_unusual:
6233 if ((tag == 0) || ((tag & 7) == 4)) {
6234 CHK_(ptr);
6235 ctx->SetLastTag(tag);
6236 goto message_done;
6237 }
6238 ptr = UnknownFieldParse(
6239 tag,
6240 _internal_metadata_.mutable_unknown_fields<std::string>(),
6241 ptr, ctx);
6242 CHK_(ptr != nullptr);
6243 } // while
6244 message_done:
6245 return ptr;
6246 failure:
6247 ptr = nullptr;
6248 goto message_done;
6249 #undef CHK_
6250 }
6251
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const6252 ::uint8_t* GetKeyValueDirResponse::_InternalSerialize(
6253 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
6254 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.GetKeyValueDirResponse)
6255 ::uint32_t cached_has_bits = 0;
6256 (void) cached_has_bits;
6257
6258 // string directory_key = 1;
6259 if (!this->_internal_directory_key().empty()) {
6260 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
6261 this->_internal_directory_key().data(), static_cast<int>(this->_internal_directory_key().length()),
6262 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
6263 "tensorflow.GetKeyValueDirResponse.directory_key");
6264 target = stream->WriteStringMaybeAliased(
6265 1, this->_internal_directory_key(), target);
6266 }
6267
6268 // repeated .tensorflow.KeyValueEntry kv = 2;
6269 for (unsigned i = 0,
6270 n = static_cast<unsigned>(this->_internal_kv_size()); i < n; i++) {
6271 const auto& repfield = this->_internal_kv(i);
6272 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
6273 InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
6274 }
6275
6276 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
6277 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
6278 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
6279 }
6280 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.GetKeyValueDirResponse)
6281 return target;
6282 }
6283
ByteSizeLong() const6284 size_t GetKeyValueDirResponse::ByteSizeLong() const {
6285 // @@protoc_insertion_point(message_byte_size_start:tensorflow.GetKeyValueDirResponse)
6286 size_t total_size = 0;
6287
6288 ::uint32_t cached_has_bits = 0;
6289 // Prevent compiler warnings about cached_has_bits being unused
6290 (void) cached_has_bits;
6291
6292 // repeated .tensorflow.KeyValueEntry kv = 2;
6293 total_size += 1UL * this->_internal_kv_size();
6294 for (const auto& msg : this->_impl_.kv_) {
6295 total_size +=
6296 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
6297 }
6298
6299 // string directory_key = 1;
6300 if (!this->_internal_directory_key().empty()) {
6301 total_size += 1 +
6302 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
6303 this->_internal_directory_key());
6304 }
6305
6306 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
6307 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
6308 }
6309 int cached_size = ::_pbi::ToCachedSize(total_size);
6310 SetCachedSize(cached_size);
6311 return total_size;
6312 }
6313
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)6314 void GetKeyValueDirResponse::CheckTypeAndMergeFrom(
6315 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
6316 MergeFrom(*::_pbi::DownCast<const GetKeyValueDirResponse*>(
6317 &from));
6318 }
6319
MergeFrom(const GetKeyValueDirResponse & from)6320 void GetKeyValueDirResponse::MergeFrom(const GetKeyValueDirResponse& from) {
6321 GetKeyValueDirResponse* const _this = this;
6322 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.GetKeyValueDirResponse)
6323 GOOGLE_DCHECK_NE(&from, _this);
6324 ::uint32_t cached_has_bits = 0;
6325 (void) cached_has_bits;
6326
6327 _this->_impl_.kv_.MergeFrom(from._impl_.kv_);
6328 if (!from._internal_directory_key().empty()) {
6329 _this->_internal_set_directory_key(from._internal_directory_key());
6330 }
6331 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
6332 }
6333
CopyFrom(const GetKeyValueDirResponse & from)6334 void GetKeyValueDirResponse::CopyFrom(const GetKeyValueDirResponse& from) {
6335 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.GetKeyValueDirResponse)
6336 if (&from == this) return;
6337 Clear();
6338 MergeFrom(from);
6339 }
6340
IsInitialized() const6341 bool GetKeyValueDirResponse::IsInitialized() const {
6342 return true;
6343 }
6344
InternalSwap(GetKeyValueDirResponse * other)6345 void GetKeyValueDirResponse::InternalSwap(GetKeyValueDirResponse* other) {
6346 using std::swap;
6347 auto* lhs_arena = GetArenaForAllocation();
6348 auto* rhs_arena = other->GetArenaForAllocation();
6349 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
6350 _impl_.kv_.InternalSwap(&other->_impl_.kv_);
6351 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
6352 &_impl_.directory_key_, lhs_arena,
6353 &other->_impl_.directory_key_, rhs_arena
6354 );
6355 }
6356
GetTypeName() const6357 std::string GetKeyValueDirResponse::GetTypeName() const {
6358 return "tensorflow.GetKeyValueDirResponse";
6359 }
6360
6361
6362 // ===================================================================
6363
6364 class DeleteKeyValueRequest::_Internal {
6365 public:
6366 };
6367
DeleteKeyValueRequest(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)6368 DeleteKeyValueRequest::DeleteKeyValueRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
6369 bool is_message_owned)
6370 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
6371 SharedCtor(arena, is_message_owned);
6372 // @@protoc_insertion_point(arena_constructor:tensorflow.DeleteKeyValueRequest)
6373 }
DeleteKeyValueRequest(const DeleteKeyValueRequest & from)6374 DeleteKeyValueRequest::DeleteKeyValueRequest(const DeleteKeyValueRequest& from)
6375 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
6376 DeleteKeyValueRequest* const _this = this; (void)_this;
6377 new (&_impl_) Impl_{
6378 decltype(_impl_.key_){}
6379 , decltype(_impl_.is_directory_){}
6380 , /*decltype(_impl_._cached_size_)*/{}};
6381
6382 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
6383 _impl_.key_.InitDefault();
6384 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6385 _impl_.key_.Set("", GetArenaForAllocation());
6386 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6387 if (!from._internal_key().empty()) {
6388 _this->_impl_.key_.Set(from._internal_key(),
6389 _this->GetArenaForAllocation());
6390 }
6391 _this->_impl_.is_directory_ = from._impl_.is_directory_;
6392 // @@protoc_insertion_point(copy_constructor:tensorflow.DeleteKeyValueRequest)
6393 }
6394
SharedCtor(::_pb::Arena * arena,bool is_message_owned)6395 inline void DeleteKeyValueRequest::SharedCtor(
6396 ::_pb::Arena* arena, bool is_message_owned) {
6397 (void)arena;
6398 (void)is_message_owned;
6399 new (&_impl_) Impl_{
6400 decltype(_impl_.key_){}
6401 , decltype(_impl_.is_directory_){false}
6402 , /*decltype(_impl_._cached_size_)*/{}
6403 };
6404 _impl_.key_.InitDefault();
6405 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6406 _impl_.key_.Set("", GetArenaForAllocation());
6407 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6408 }
6409
~DeleteKeyValueRequest()6410 DeleteKeyValueRequest::~DeleteKeyValueRequest() {
6411 // @@protoc_insertion_point(destructor:tensorflow.DeleteKeyValueRequest)
6412 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
6413 (void)arena;
6414 return;
6415 }
6416 SharedDtor();
6417 }
6418
SharedDtor()6419 inline void DeleteKeyValueRequest::SharedDtor() {
6420 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
6421 _impl_.key_.Destroy();
6422 }
6423
SetCachedSize(int size) const6424 void DeleteKeyValueRequest::SetCachedSize(int size) const {
6425 _impl_._cached_size_.Set(size);
6426 }
6427
Clear()6428 void DeleteKeyValueRequest::Clear() {
6429 // @@protoc_insertion_point(message_clear_start:tensorflow.DeleteKeyValueRequest)
6430 ::uint32_t cached_has_bits = 0;
6431 // Prevent compiler warnings about cached_has_bits being unused
6432 (void) cached_has_bits;
6433
6434 _impl_.key_.ClearToEmpty();
6435 _impl_.is_directory_ = false;
6436 _internal_metadata_.Clear<std::string>();
6437 }
6438
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)6439 const char* DeleteKeyValueRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
6440 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
6441 while (!ctx->Done(&ptr)) {
6442 ::uint32_t tag;
6443 ptr = ::_pbi::ReadTag(ptr, &tag);
6444 switch (tag >> 3) {
6445 // string key = 1;
6446 case 1:
6447 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
6448 auto str = _internal_mutable_key();
6449 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
6450 CHK_(ptr);
6451 CHK_(::_pbi::VerifyUTF8(str, nullptr));
6452 } else {
6453 goto handle_unusual;
6454 }
6455 continue;
6456 // bool is_directory = 2;
6457 case 2:
6458 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
6459 _impl_.is_directory_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
6460 CHK_(ptr);
6461 } else {
6462 goto handle_unusual;
6463 }
6464 continue;
6465 default:
6466 goto handle_unusual;
6467 } // switch
6468 handle_unusual:
6469 if ((tag == 0) || ((tag & 7) == 4)) {
6470 CHK_(ptr);
6471 ctx->SetLastTag(tag);
6472 goto message_done;
6473 }
6474 ptr = UnknownFieldParse(
6475 tag,
6476 _internal_metadata_.mutable_unknown_fields<std::string>(),
6477 ptr, ctx);
6478 CHK_(ptr != nullptr);
6479 } // while
6480 message_done:
6481 return ptr;
6482 failure:
6483 ptr = nullptr;
6484 goto message_done;
6485 #undef CHK_
6486 }
6487
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const6488 ::uint8_t* DeleteKeyValueRequest::_InternalSerialize(
6489 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
6490 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.DeleteKeyValueRequest)
6491 ::uint32_t cached_has_bits = 0;
6492 (void) cached_has_bits;
6493
6494 // string key = 1;
6495 if (!this->_internal_key().empty()) {
6496 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
6497 this->_internal_key().data(), static_cast<int>(this->_internal_key().length()),
6498 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
6499 "tensorflow.DeleteKeyValueRequest.key");
6500 target = stream->WriteStringMaybeAliased(
6501 1, this->_internal_key(), target);
6502 }
6503
6504 // bool is_directory = 2;
6505 if (this->_internal_is_directory() != 0) {
6506 target = stream->EnsureSpace(target);
6507 target = ::_pbi::WireFormatLite::WriteBoolToArray(2, this->_internal_is_directory(), target);
6508 }
6509
6510 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
6511 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
6512 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
6513 }
6514 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.DeleteKeyValueRequest)
6515 return target;
6516 }
6517
ByteSizeLong() const6518 size_t DeleteKeyValueRequest::ByteSizeLong() const {
6519 // @@protoc_insertion_point(message_byte_size_start:tensorflow.DeleteKeyValueRequest)
6520 size_t total_size = 0;
6521
6522 ::uint32_t cached_has_bits = 0;
6523 // Prevent compiler warnings about cached_has_bits being unused
6524 (void) cached_has_bits;
6525
6526 // string key = 1;
6527 if (!this->_internal_key().empty()) {
6528 total_size += 1 +
6529 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
6530 this->_internal_key());
6531 }
6532
6533 // bool is_directory = 2;
6534 if (this->_internal_is_directory() != 0) {
6535 total_size += 1 + 1;
6536 }
6537
6538 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
6539 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
6540 }
6541 int cached_size = ::_pbi::ToCachedSize(total_size);
6542 SetCachedSize(cached_size);
6543 return total_size;
6544 }
6545
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)6546 void DeleteKeyValueRequest::CheckTypeAndMergeFrom(
6547 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
6548 MergeFrom(*::_pbi::DownCast<const DeleteKeyValueRequest*>(
6549 &from));
6550 }
6551
MergeFrom(const DeleteKeyValueRequest & from)6552 void DeleteKeyValueRequest::MergeFrom(const DeleteKeyValueRequest& from) {
6553 DeleteKeyValueRequest* const _this = this;
6554 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.DeleteKeyValueRequest)
6555 GOOGLE_DCHECK_NE(&from, _this);
6556 ::uint32_t cached_has_bits = 0;
6557 (void) cached_has_bits;
6558
6559 if (!from._internal_key().empty()) {
6560 _this->_internal_set_key(from._internal_key());
6561 }
6562 if (from._internal_is_directory() != 0) {
6563 _this->_internal_set_is_directory(from._internal_is_directory());
6564 }
6565 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
6566 }
6567
CopyFrom(const DeleteKeyValueRequest & from)6568 void DeleteKeyValueRequest::CopyFrom(const DeleteKeyValueRequest& from) {
6569 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.DeleteKeyValueRequest)
6570 if (&from == this) return;
6571 Clear();
6572 MergeFrom(from);
6573 }
6574
IsInitialized() const6575 bool DeleteKeyValueRequest::IsInitialized() const {
6576 return true;
6577 }
6578
InternalSwap(DeleteKeyValueRequest * other)6579 void DeleteKeyValueRequest::InternalSwap(DeleteKeyValueRequest* other) {
6580 using std::swap;
6581 auto* lhs_arena = GetArenaForAllocation();
6582 auto* rhs_arena = other->GetArenaForAllocation();
6583 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
6584 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
6585 &_impl_.key_, lhs_arena,
6586 &other->_impl_.key_, rhs_arena
6587 );
6588 swap(_impl_.is_directory_, other->_impl_.is_directory_);
6589 }
6590
GetTypeName() const6591 std::string DeleteKeyValueRequest::GetTypeName() const {
6592 return "tensorflow.DeleteKeyValueRequest";
6593 }
6594
6595
6596 // ===================================================================
6597
6598 class DeleteKeyValueResponse::_Internal {
6599 public:
6600 };
6601
DeleteKeyValueResponse(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)6602 DeleteKeyValueResponse::DeleteKeyValueResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
6603 bool is_message_owned)
6604 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
6605 SharedCtor(arena, is_message_owned);
6606 // @@protoc_insertion_point(arena_constructor:tensorflow.DeleteKeyValueResponse)
6607 }
DeleteKeyValueResponse(const DeleteKeyValueResponse & from)6608 DeleteKeyValueResponse::DeleteKeyValueResponse(const DeleteKeyValueResponse& from)
6609 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
6610 DeleteKeyValueResponse* const _this = this; (void)_this;
6611 new (&_impl_) Impl_{
6612 /*decltype(_impl_._cached_size_)*/{}};
6613
6614 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
6615 // @@protoc_insertion_point(copy_constructor:tensorflow.DeleteKeyValueResponse)
6616 }
6617
SharedCtor(::_pb::Arena * arena,bool is_message_owned)6618 inline void DeleteKeyValueResponse::SharedCtor(
6619 ::_pb::Arena* arena, bool is_message_owned) {
6620 (void)arena;
6621 (void)is_message_owned;
6622 new (&_impl_) Impl_{
6623 /*decltype(_impl_._cached_size_)*/{}
6624 };
6625 }
6626
~DeleteKeyValueResponse()6627 DeleteKeyValueResponse::~DeleteKeyValueResponse() {
6628 // @@protoc_insertion_point(destructor:tensorflow.DeleteKeyValueResponse)
6629 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
6630 (void)arena;
6631 return;
6632 }
6633 SharedDtor();
6634 }
6635
SharedDtor()6636 inline void DeleteKeyValueResponse::SharedDtor() {
6637 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
6638 }
6639
SetCachedSize(int size) const6640 void DeleteKeyValueResponse::SetCachedSize(int size) const {
6641 _impl_._cached_size_.Set(size);
6642 }
6643
Clear()6644 void DeleteKeyValueResponse::Clear() {
6645 // @@protoc_insertion_point(message_clear_start:tensorflow.DeleteKeyValueResponse)
6646 ::uint32_t cached_has_bits = 0;
6647 // Prevent compiler warnings about cached_has_bits being unused
6648 (void) cached_has_bits;
6649
6650 _internal_metadata_.Clear<std::string>();
6651 }
6652
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)6653 const char* DeleteKeyValueResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
6654 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
6655 while (!ctx->Done(&ptr)) {
6656 ::uint32_t tag;
6657 ptr = ::_pbi::ReadTag(ptr, &tag);
6658 if ((tag == 0) || ((tag & 7) == 4)) {
6659 CHK_(ptr);
6660 ctx->SetLastTag(tag);
6661 goto message_done;
6662 }
6663 ptr = UnknownFieldParse(
6664 tag,
6665 _internal_metadata_.mutable_unknown_fields<std::string>(),
6666 ptr, ctx);
6667 CHK_(ptr != nullptr);
6668 } // while
6669 message_done:
6670 return ptr;
6671 failure:
6672 ptr = nullptr;
6673 goto message_done;
6674 #undef CHK_
6675 }
6676
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const6677 ::uint8_t* DeleteKeyValueResponse::_InternalSerialize(
6678 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
6679 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.DeleteKeyValueResponse)
6680 ::uint32_t cached_has_bits = 0;
6681 (void) cached_has_bits;
6682
6683 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
6684 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
6685 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
6686 }
6687 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.DeleteKeyValueResponse)
6688 return target;
6689 }
6690
ByteSizeLong() const6691 size_t DeleteKeyValueResponse::ByteSizeLong() const {
6692 // @@protoc_insertion_point(message_byte_size_start:tensorflow.DeleteKeyValueResponse)
6693 size_t total_size = 0;
6694
6695 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
6696 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
6697 }
6698 int cached_size = ::_pbi::ToCachedSize(total_size);
6699 SetCachedSize(cached_size);
6700 return total_size;
6701 }
6702
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)6703 void DeleteKeyValueResponse::CheckTypeAndMergeFrom(
6704 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
6705 MergeFrom(*::_pbi::DownCast<const DeleteKeyValueResponse*>(
6706 &from));
6707 }
6708
MergeFrom(const DeleteKeyValueResponse & from)6709 void DeleteKeyValueResponse::MergeFrom(const DeleteKeyValueResponse& from) {
6710 DeleteKeyValueResponse* const _this = this;
6711 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.DeleteKeyValueResponse)
6712 GOOGLE_DCHECK_NE(&from, _this);
6713 ::uint32_t cached_has_bits = 0;
6714 (void) cached_has_bits;
6715
6716 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
6717 }
6718
CopyFrom(const DeleteKeyValueResponse & from)6719 void DeleteKeyValueResponse::CopyFrom(const DeleteKeyValueResponse& from) {
6720 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.DeleteKeyValueResponse)
6721 if (&from == this) return;
6722 Clear();
6723 MergeFrom(from);
6724 }
6725
IsInitialized() const6726 bool DeleteKeyValueResponse::IsInitialized() const {
6727 return true;
6728 }
6729
InternalSwap(DeleteKeyValueResponse * other)6730 void DeleteKeyValueResponse::InternalSwap(DeleteKeyValueResponse* other) {
6731 using std::swap;
6732 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
6733 }
6734
GetTypeName() const6735 std::string DeleteKeyValueResponse::GetTypeName() const {
6736 return "tensorflow.DeleteKeyValueResponse";
6737 }
6738
6739
6740 // ===================================================================
6741
6742 class BarrierRequest::_Internal {
6743 public:
6744 static const ::tensorflow::CoordinatedTask& source_task(const BarrierRequest* msg);
6745 };
6746
6747 const ::tensorflow::CoordinatedTask&
source_task(const BarrierRequest * msg)6748 BarrierRequest::_Internal::source_task(const BarrierRequest* msg) {
6749 return *msg->_impl_.source_task_;
6750 }
BarrierRequest(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)6751 BarrierRequest::BarrierRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
6752 bool is_message_owned)
6753 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
6754 SharedCtor(arena, is_message_owned);
6755 // @@protoc_insertion_point(arena_constructor:tensorflow.BarrierRequest)
6756 }
BarrierRequest(const BarrierRequest & from)6757 BarrierRequest::BarrierRequest(const BarrierRequest& from)
6758 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
6759 BarrierRequest* const _this = this; (void)_this;
6760 new (&_impl_) Impl_{
6761 decltype(_impl_.tasks_){from._impl_.tasks_}
6762 , decltype(_impl_.barrier_id_){}
6763 , decltype(_impl_.source_task_){nullptr}
6764 , decltype(_impl_.barrier_timeout_in_ms_){}
6765 , /*decltype(_impl_._cached_size_)*/{}};
6766
6767 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
6768 _impl_.barrier_id_.InitDefault();
6769 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6770 _impl_.barrier_id_.Set("", GetArenaForAllocation());
6771 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6772 if (!from._internal_barrier_id().empty()) {
6773 _this->_impl_.barrier_id_.Set(from._internal_barrier_id(),
6774 _this->GetArenaForAllocation());
6775 }
6776 if (from._internal_has_source_task()) {
6777 _this->_impl_.source_task_ = new ::tensorflow::CoordinatedTask(*from._impl_.source_task_);
6778 }
6779 _this->_impl_.barrier_timeout_in_ms_ = from._impl_.barrier_timeout_in_ms_;
6780 // @@protoc_insertion_point(copy_constructor:tensorflow.BarrierRequest)
6781 }
6782
SharedCtor(::_pb::Arena * arena,bool is_message_owned)6783 inline void BarrierRequest::SharedCtor(
6784 ::_pb::Arena* arena, bool is_message_owned) {
6785 (void)arena;
6786 (void)is_message_owned;
6787 new (&_impl_) Impl_{
6788 decltype(_impl_.tasks_){arena}
6789 , decltype(_impl_.barrier_id_){}
6790 , decltype(_impl_.source_task_){nullptr}
6791 , decltype(_impl_.barrier_timeout_in_ms_){::int64_t{0}}
6792 , /*decltype(_impl_._cached_size_)*/{}
6793 };
6794 _impl_.barrier_id_.InitDefault();
6795 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6796 _impl_.barrier_id_.Set("", GetArenaForAllocation());
6797 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6798 }
6799
~BarrierRequest()6800 BarrierRequest::~BarrierRequest() {
6801 // @@protoc_insertion_point(destructor:tensorflow.BarrierRequest)
6802 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
6803 (void)arena;
6804 return;
6805 }
6806 SharedDtor();
6807 }
6808
SharedDtor()6809 inline void BarrierRequest::SharedDtor() {
6810 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
6811 _impl_.tasks_.~RepeatedPtrField();
6812 _impl_.barrier_id_.Destroy();
6813 if (this != internal_default_instance()) delete _impl_.source_task_;
6814 }
6815
SetCachedSize(int size) const6816 void BarrierRequest::SetCachedSize(int size) const {
6817 _impl_._cached_size_.Set(size);
6818 }
6819
Clear()6820 void BarrierRequest::Clear() {
6821 // @@protoc_insertion_point(message_clear_start:tensorflow.BarrierRequest)
6822 ::uint32_t cached_has_bits = 0;
6823 // Prevent compiler warnings about cached_has_bits being unused
6824 (void) cached_has_bits;
6825
6826 _impl_.tasks_.Clear();
6827 _impl_.barrier_id_.ClearToEmpty();
6828 if (GetArenaForAllocation() == nullptr && _impl_.source_task_ != nullptr) {
6829 delete _impl_.source_task_;
6830 }
6831 _impl_.source_task_ = nullptr;
6832 _impl_.barrier_timeout_in_ms_ = ::int64_t{0};
6833 _internal_metadata_.Clear<std::string>();
6834 }
6835
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)6836 const char* BarrierRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
6837 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
6838 while (!ctx->Done(&ptr)) {
6839 ::uint32_t tag;
6840 ptr = ::_pbi::ReadTag(ptr, &tag);
6841 switch (tag >> 3) {
6842 // string barrier_id = 1;
6843 case 1:
6844 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
6845 auto str = _internal_mutable_barrier_id();
6846 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
6847 CHK_(ptr);
6848 CHK_(::_pbi::VerifyUTF8(str, nullptr));
6849 } else {
6850 goto handle_unusual;
6851 }
6852 continue;
6853 // int64 barrier_timeout_in_ms = 2;
6854 case 2:
6855 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
6856 _impl_.barrier_timeout_in_ms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
6857 CHK_(ptr);
6858 } else {
6859 goto handle_unusual;
6860 }
6861 continue;
6862 // repeated .tensorflow.CoordinatedTask tasks = 3;
6863 case 3:
6864 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
6865 ptr -= 1;
6866 do {
6867 ptr += 1;
6868 ptr = ctx->ParseMessage(_internal_add_tasks(), ptr);
6869 CHK_(ptr);
6870 if (!ctx->DataAvailable(ptr)) break;
6871 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
6872 } else {
6873 goto handle_unusual;
6874 }
6875 continue;
6876 // .tensorflow.CoordinatedTask source_task = 4;
6877 case 4:
6878 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
6879 ptr = ctx->ParseMessage(_internal_mutable_source_task(), ptr);
6880 CHK_(ptr);
6881 } else {
6882 goto handle_unusual;
6883 }
6884 continue;
6885 default:
6886 goto handle_unusual;
6887 } // switch
6888 handle_unusual:
6889 if ((tag == 0) || ((tag & 7) == 4)) {
6890 CHK_(ptr);
6891 ctx->SetLastTag(tag);
6892 goto message_done;
6893 }
6894 ptr = UnknownFieldParse(
6895 tag,
6896 _internal_metadata_.mutable_unknown_fields<std::string>(),
6897 ptr, ctx);
6898 CHK_(ptr != nullptr);
6899 } // while
6900 message_done:
6901 return ptr;
6902 failure:
6903 ptr = nullptr;
6904 goto message_done;
6905 #undef CHK_
6906 }
6907
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const6908 ::uint8_t* BarrierRequest::_InternalSerialize(
6909 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
6910 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.BarrierRequest)
6911 ::uint32_t cached_has_bits = 0;
6912 (void) cached_has_bits;
6913
6914 // string barrier_id = 1;
6915 if (!this->_internal_barrier_id().empty()) {
6916 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
6917 this->_internal_barrier_id().data(), static_cast<int>(this->_internal_barrier_id().length()),
6918 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
6919 "tensorflow.BarrierRequest.barrier_id");
6920 target = stream->WriteStringMaybeAliased(
6921 1, this->_internal_barrier_id(), target);
6922 }
6923
6924 // int64 barrier_timeout_in_ms = 2;
6925 if (this->_internal_barrier_timeout_in_ms() != 0) {
6926 target = stream->EnsureSpace(target);
6927 target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_barrier_timeout_in_ms(), target);
6928 }
6929
6930 // repeated .tensorflow.CoordinatedTask tasks = 3;
6931 for (unsigned i = 0,
6932 n = static_cast<unsigned>(this->_internal_tasks_size()); i < n; i++) {
6933 const auto& repfield = this->_internal_tasks(i);
6934 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
6935 InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream);
6936 }
6937
6938 // .tensorflow.CoordinatedTask source_task = 4;
6939 if (this->_internal_has_source_task()) {
6940 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
6941 InternalWriteMessage(4, _Internal::source_task(this),
6942 _Internal::source_task(this).GetCachedSize(), target, stream);
6943 }
6944
6945 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
6946 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
6947 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
6948 }
6949 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.BarrierRequest)
6950 return target;
6951 }
6952
ByteSizeLong() const6953 size_t BarrierRequest::ByteSizeLong() const {
6954 // @@protoc_insertion_point(message_byte_size_start:tensorflow.BarrierRequest)
6955 size_t total_size = 0;
6956
6957 ::uint32_t cached_has_bits = 0;
6958 // Prevent compiler warnings about cached_has_bits being unused
6959 (void) cached_has_bits;
6960
6961 // repeated .tensorflow.CoordinatedTask tasks = 3;
6962 total_size += 1UL * this->_internal_tasks_size();
6963 for (const auto& msg : this->_impl_.tasks_) {
6964 total_size +=
6965 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
6966 }
6967
6968 // string barrier_id = 1;
6969 if (!this->_internal_barrier_id().empty()) {
6970 total_size += 1 +
6971 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
6972 this->_internal_barrier_id());
6973 }
6974
6975 // .tensorflow.CoordinatedTask source_task = 4;
6976 if (this->_internal_has_source_task()) {
6977 total_size += 1 +
6978 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
6979 *_impl_.source_task_);
6980 }
6981
6982 // int64 barrier_timeout_in_ms = 2;
6983 if (this->_internal_barrier_timeout_in_ms() != 0) {
6984 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_barrier_timeout_in_ms());
6985 }
6986
6987 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
6988 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
6989 }
6990 int cached_size = ::_pbi::ToCachedSize(total_size);
6991 SetCachedSize(cached_size);
6992 return total_size;
6993 }
6994
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)6995 void BarrierRequest::CheckTypeAndMergeFrom(
6996 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
6997 MergeFrom(*::_pbi::DownCast<const BarrierRequest*>(
6998 &from));
6999 }
7000
MergeFrom(const BarrierRequest & from)7001 void BarrierRequest::MergeFrom(const BarrierRequest& from) {
7002 BarrierRequest* const _this = this;
7003 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.BarrierRequest)
7004 GOOGLE_DCHECK_NE(&from, _this);
7005 ::uint32_t cached_has_bits = 0;
7006 (void) cached_has_bits;
7007
7008 _this->_impl_.tasks_.MergeFrom(from._impl_.tasks_);
7009 if (!from._internal_barrier_id().empty()) {
7010 _this->_internal_set_barrier_id(from._internal_barrier_id());
7011 }
7012 if (from._internal_has_source_task()) {
7013 _this->_internal_mutable_source_task()->::tensorflow::CoordinatedTask::MergeFrom(
7014 from._internal_source_task());
7015 }
7016 if (from._internal_barrier_timeout_in_ms() != 0) {
7017 _this->_internal_set_barrier_timeout_in_ms(from._internal_barrier_timeout_in_ms());
7018 }
7019 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
7020 }
7021
CopyFrom(const BarrierRequest & from)7022 void BarrierRequest::CopyFrom(const BarrierRequest& from) {
7023 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.BarrierRequest)
7024 if (&from == this) return;
7025 Clear();
7026 MergeFrom(from);
7027 }
7028
IsInitialized() const7029 bool BarrierRequest::IsInitialized() const {
7030 return true;
7031 }
7032
InternalSwap(BarrierRequest * other)7033 void BarrierRequest::InternalSwap(BarrierRequest* other) {
7034 using std::swap;
7035 auto* lhs_arena = GetArenaForAllocation();
7036 auto* rhs_arena = other->GetArenaForAllocation();
7037 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
7038 _impl_.tasks_.InternalSwap(&other->_impl_.tasks_);
7039 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
7040 &_impl_.barrier_id_, lhs_arena,
7041 &other->_impl_.barrier_id_, rhs_arena
7042 );
7043 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
7044 PROTOBUF_FIELD_OFFSET(BarrierRequest, _impl_.barrier_timeout_in_ms_)
7045 + sizeof(BarrierRequest::_impl_.barrier_timeout_in_ms_) // NOLINT
7046 - PROTOBUF_FIELD_OFFSET(BarrierRequest, _impl_.source_task_)>(
7047 reinterpret_cast<char*>(&_impl_.source_task_),
7048 reinterpret_cast<char*>(&other->_impl_.source_task_));
7049 }
7050
GetTypeName() const7051 std::string BarrierRequest::GetTypeName() const {
7052 return "tensorflow.BarrierRequest";
7053 }
7054
7055
7056 // ===================================================================
7057
7058 class BarrierResponse::_Internal {
7059 public:
7060 };
7061
BarrierResponse(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)7062 BarrierResponse::BarrierResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
7063 bool is_message_owned)
7064 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
7065 SharedCtor(arena, is_message_owned);
7066 // @@protoc_insertion_point(arena_constructor:tensorflow.BarrierResponse)
7067 }
BarrierResponse(const BarrierResponse & from)7068 BarrierResponse::BarrierResponse(const BarrierResponse& from)
7069 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
7070 BarrierResponse* const _this = this; (void)_this;
7071 new (&_impl_) Impl_{
7072 /*decltype(_impl_._cached_size_)*/{}};
7073
7074 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
7075 // @@protoc_insertion_point(copy_constructor:tensorflow.BarrierResponse)
7076 }
7077
SharedCtor(::_pb::Arena * arena,bool is_message_owned)7078 inline void BarrierResponse::SharedCtor(
7079 ::_pb::Arena* arena, bool is_message_owned) {
7080 (void)arena;
7081 (void)is_message_owned;
7082 new (&_impl_) Impl_{
7083 /*decltype(_impl_._cached_size_)*/{}
7084 };
7085 }
7086
~BarrierResponse()7087 BarrierResponse::~BarrierResponse() {
7088 // @@protoc_insertion_point(destructor:tensorflow.BarrierResponse)
7089 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
7090 (void)arena;
7091 return;
7092 }
7093 SharedDtor();
7094 }
7095
SharedDtor()7096 inline void BarrierResponse::SharedDtor() {
7097 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
7098 }
7099
SetCachedSize(int size) const7100 void BarrierResponse::SetCachedSize(int size) const {
7101 _impl_._cached_size_.Set(size);
7102 }
7103
Clear()7104 void BarrierResponse::Clear() {
7105 // @@protoc_insertion_point(message_clear_start:tensorflow.BarrierResponse)
7106 ::uint32_t cached_has_bits = 0;
7107 // Prevent compiler warnings about cached_has_bits being unused
7108 (void) cached_has_bits;
7109
7110 _internal_metadata_.Clear<std::string>();
7111 }
7112
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)7113 const char* BarrierResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
7114 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
7115 while (!ctx->Done(&ptr)) {
7116 ::uint32_t tag;
7117 ptr = ::_pbi::ReadTag(ptr, &tag);
7118 if ((tag == 0) || ((tag & 7) == 4)) {
7119 CHK_(ptr);
7120 ctx->SetLastTag(tag);
7121 goto message_done;
7122 }
7123 ptr = UnknownFieldParse(
7124 tag,
7125 _internal_metadata_.mutable_unknown_fields<std::string>(),
7126 ptr, ctx);
7127 CHK_(ptr != nullptr);
7128 } // while
7129 message_done:
7130 return ptr;
7131 failure:
7132 ptr = nullptr;
7133 goto message_done;
7134 #undef CHK_
7135 }
7136
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const7137 ::uint8_t* BarrierResponse::_InternalSerialize(
7138 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
7139 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.BarrierResponse)
7140 ::uint32_t cached_has_bits = 0;
7141 (void) cached_has_bits;
7142
7143 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
7144 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
7145 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
7146 }
7147 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.BarrierResponse)
7148 return target;
7149 }
7150
ByteSizeLong() const7151 size_t BarrierResponse::ByteSizeLong() const {
7152 // @@protoc_insertion_point(message_byte_size_start:tensorflow.BarrierResponse)
7153 size_t total_size = 0;
7154
7155 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
7156 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
7157 }
7158 int cached_size = ::_pbi::ToCachedSize(total_size);
7159 SetCachedSize(cached_size);
7160 return total_size;
7161 }
7162
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)7163 void BarrierResponse::CheckTypeAndMergeFrom(
7164 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
7165 MergeFrom(*::_pbi::DownCast<const BarrierResponse*>(
7166 &from));
7167 }
7168
MergeFrom(const BarrierResponse & from)7169 void BarrierResponse::MergeFrom(const BarrierResponse& from) {
7170 BarrierResponse* const _this = this;
7171 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.BarrierResponse)
7172 GOOGLE_DCHECK_NE(&from, _this);
7173 ::uint32_t cached_has_bits = 0;
7174 (void) cached_has_bits;
7175
7176 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
7177 }
7178
CopyFrom(const BarrierResponse & from)7179 void BarrierResponse::CopyFrom(const BarrierResponse& from) {
7180 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.BarrierResponse)
7181 if (&from == this) return;
7182 Clear();
7183 MergeFrom(from);
7184 }
7185
IsInitialized() const7186 bool BarrierResponse::IsInitialized() const {
7187 return true;
7188 }
7189
InternalSwap(BarrierResponse * other)7190 void BarrierResponse::InternalSwap(BarrierResponse* other) {
7191 using std::swap;
7192 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
7193 }
7194
GetTypeName() const7195 std::string BarrierResponse::GetTypeName() const {
7196 return "tensorflow.BarrierResponse";
7197 }
7198
7199
7200 // ===================================================================
7201
7202 class CancelBarrierRequest::_Internal {
7203 public:
7204 static const ::tensorflow::CoordinatedTask& source_task(const CancelBarrierRequest* msg);
7205 };
7206
7207 const ::tensorflow::CoordinatedTask&
source_task(const CancelBarrierRequest * msg)7208 CancelBarrierRequest::_Internal::source_task(const CancelBarrierRequest* msg) {
7209 return *msg->_impl_.source_task_;
7210 }
CancelBarrierRequest(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)7211 CancelBarrierRequest::CancelBarrierRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
7212 bool is_message_owned)
7213 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
7214 SharedCtor(arena, is_message_owned);
7215 // @@protoc_insertion_point(arena_constructor:tensorflow.CancelBarrierRequest)
7216 }
CancelBarrierRequest(const CancelBarrierRequest & from)7217 CancelBarrierRequest::CancelBarrierRequest(const CancelBarrierRequest& from)
7218 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
7219 CancelBarrierRequest* const _this = this; (void)_this;
7220 new (&_impl_) Impl_{
7221 decltype(_impl_.barrier_id_){}
7222 , decltype(_impl_.source_task_){nullptr}
7223 , /*decltype(_impl_._cached_size_)*/{}};
7224
7225 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
7226 _impl_.barrier_id_.InitDefault();
7227 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
7228 _impl_.barrier_id_.Set("", GetArenaForAllocation());
7229 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
7230 if (!from._internal_barrier_id().empty()) {
7231 _this->_impl_.barrier_id_.Set(from._internal_barrier_id(),
7232 _this->GetArenaForAllocation());
7233 }
7234 if (from._internal_has_source_task()) {
7235 _this->_impl_.source_task_ = new ::tensorflow::CoordinatedTask(*from._impl_.source_task_);
7236 }
7237 // @@protoc_insertion_point(copy_constructor:tensorflow.CancelBarrierRequest)
7238 }
7239
SharedCtor(::_pb::Arena * arena,bool is_message_owned)7240 inline void CancelBarrierRequest::SharedCtor(
7241 ::_pb::Arena* arena, bool is_message_owned) {
7242 (void)arena;
7243 (void)is_message_owned;
7244 new (&_impl_) Impl_{
7245 decltype(_impl_.barrier_id_){}
7246 , decltype(_impl_.source_task_){nullptr}
7247 , /*decltype(_impl_._cached_size_)*/{}
7248 };
7249 _impl_.barrier_id_.InitDefault();
7250 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
7251 _impl_.barrier_id_.Set("", GetArenaForAllocation());
7252 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
7253 }
7254
~CancelBarrierRequest()7255 CancelBarrierRequest::~CancelBarrierRequest() {
7256 // @@protoc_insertion_point(destructor:tensorflow.CancelBarrierRequest)
7257 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
7258 (void)arena;
7259 return;
7260 }
7261 SharedDtor();
7262 }
7263
SharedDtor()7264 inline void CancelBarrierRequest::SharedDtor() {
7265 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
7266 _impl_.barrier_id_.Destroy();
7267 if (this != internal_default_instance()) delete _impl_.source_task_;
7268 }
7269
SetCachedSize(int size) const7270 void CancelBarrierRequest::SetCachedSize(int size) const {
7271 _impl_._cached_size_.Set(size);
7272 }
7273
Clear()7274 void CancelBarrierRequest::Clear() {
7275 // @@protoc_insertion_point(message_clear_start:tensorflow.CancelBarrierRequest)
7276 ::uint32_t cached_has_bits = 0;
7277 // Prevent compiler warnings about cached_has_bits being unused
7278 (void) cached_has_bits;
7279
7280 _impl_.barrier_id_.ClearToEmpty();
7281 if (GetArenaForAllocation() == nullptr && _impl_.source_task_ != nullptr) {
7282 delete _impl_.source_task_;
7283 }
7284 _impl_.source_task_ = nullptr;
7285 _internal_metadata_.Clear<std::string>();
7286 }
7287
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)7288 const char* CancelBarrierRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
7289 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
7290 while (!ctx->Done(&ptr)) {
7291 ::uint32_t tag;
7292 ptr = ::_pbi::ReadTag(ptr, &tag);
7293 switch (tag >> 3) {
7294 // string barrier_id = 1;
7295 case 1:
7296 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
7297 auto str = _internal_mutable_barrier_id();
7298 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
7299 CHK_(ptr);
7300 CHK_(::_pbi::VerifyUTF8(str, nullptr));
7301 } else {
7302 goto handle_unusual;
7303 }
7304 continue;
7305 // .tensorflow.CoordinatedTask source_task = 2;
7306 case 2:
7307 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
7308 ptr = ctx->ParseMessage(_internal_mutable_source_task(), ptr);
7309 CHK_(ptr);
7310 } else {
7311 goto handle_unusual;
7312 }
7313 continue;
7314 default:
7315 goto handle_unusual;
7316 } // switch
7317 handle_unusual:
7318 if ((tag == 0) || ((tag & 7) == 4)) {
7319 CHK_(ptr);
7320 ctx->SetLastTag(tag);
7321 goto message_done;
7322 }
7323 ptr = UnknownFieldParse(
7324 tag,
7325 _internal_metadata_.mutable_unknown_fields<std::string>(),
7326 ptr, ctx);
7327 CHK_(ptr != nullptr);
7328 } // while
7329 message_done:
7330 return ptr;
7331 failure:
7332 ptr = nullptr;
7333 goto message_done;
7334 #undef CHK_
7335 }
7336
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const7337 ::uint8_t* CancelBarrierRequest::_InternalSerialize(
7338 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
7339 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.CancelBarrierRequest)
7340 ::uint32_t cached_has_bits = 0;
7341 (void) cached_has_bits;
7342
7343 // string barrier_id = 1;
7344 if (!this->_internal_barrier_id().empty()) {
7345 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
7346 this->_internal_barrier_id().data(), static_cast<int>(this->_internal_barrier_id().length()),
7347 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
7348 "tensorflow.CancelBarrierRequest.barrier_id");
7349 target = stream->WriteStringMaybeAliased(
7350 1, this->_internal_barrier_id(), target);
7351 }
7352
7353 // .tensorflow.CoordinatedTask source_task = 2;
7354 if (this->_internal_has_source_task()) {
7355 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
7356 InternalWriteMessage(2, _Internal::source_task(this),
7357 _Internal::source_task(this).GetCachedSize(), target, stream);
7358 }
7359
7360 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
7361 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
7362 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
7363 }
7364 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.CancelBarrierRequest)
7365 return target;
7366 }
7367
ByteSizeLong() const7368 size_t CancelBarrierRequest::ByteSizeLong() const {
7369 // @@protoc_insertion_point(message_byte_size_start:tensorflow.CancelBarrierRequest)
7370 size_t total_size = 0;
7371
7372 ::uint32_t cached_has_bits = 0;
7373 // Prevent compiler warnings about cached_has_bits being unused
7374 (void) cached_has_bits;
7375
7376 // string barrier_id = 1;
7377 if (!this->_internal_barrier_id().empty()) {
7378 total_size += 1 +
7379 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
7380 this->_internal_barrier_id());
7381 }
7382
7383 // .tensorflow.CoordinatedTask source_task = 2;
7384 if (this->_internal_has_source_task()) {
7385 total_size += 1 +
7386 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
7387 *_impl_.source_task_);
7388 }
7389
7390 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
7391 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
7392 }
7393 int cached_size = ::_pbi::ToCachedSize(total_size);
7394 SetCachedSize(cached_size);
7395 return total_size;
7396 }
7397
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)7398 void CancelBarrierRequest::CheckTypeAndMergeFrom(
7399 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
7400 MergeFrom(*::_pbi::DownCast<const CancelBarrierRequest*>(
7401 &from));
7402 }
7403
MergeFrom(const CancelBarrierRequest & from)7404 void CancelBarrierRequest::MergeFrom(const CancelBarrierRequest& from) {
7405 CancelBarrierRequest* const _this = this;
7406 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.CancelBarrierRequest)
7407 GOOGLE_DCHECK_NE(&from, _this);
7408 ::uint32_t cached_has_bits = 0;
7409 (void) cached_has_bits;
7410
7411 if (!from._internal_barrier_id().empty()) {
7412 _this->_internal_set_barrier_id(from._internal_barrier_id());
7413 }
7414 if (from._internal_has_source_task()) {
7415 _this->_internal_mutable_source_task()->::tensorflow::CoordinatedTask::MergeFrom(
7416 from._internal_source_task());
7417 }
7418 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
7419 }
7420
CopyFrom(const CancelBarrierRequest & from)7421 void CancelBarrierRequest::CopyFrom(const CancelBarrierRequest& from) {
7422 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.CancelBarrierRequest)
7423 if (&from == this) return;
7424 Clear();
7425 MergeFrom(from);
7426 }
7427
IsInitialized() const7428 bool CancelBarrierRequest::IsInitialized() const {
7429 return true;
7430 }
7431
InternalSwap(CancelBarrierRequest * other)7432 void CancelBarrierRequest::InternalSwap(CancelBarrierRequest* other) {
7433 using std::swap;
7434 auto* lhs_arena = GetArenaForAllocation();
7435 auto* rhs_arena = other->GetArenaForAllocation();
7436 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
7437 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
7438 &_impl_.barrier_id_, lhs_arena,
7439 &other->_impl_.barrier_id_, rhs_arena
7440 );
7441 swap(_impl_.source_task_, other->_impl_.source_task_);
7442 }
7443
GetTypeName() const7444 std::string CancelBarrierRequest::GetTypeName() const {
7445 return "tensorflow.CancelBarrierRequest";
7446 }
7447
7448
7449 // ===================================================================
7450
7451 class CancelBarrierResponse::_Internal {
7452 public:
7453 };
7454
CancelBarrierResponse(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)7455 CancelBarrierResponse::CancelBarrierResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
7456 bool is_message_owned)
7457 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
7458 SharedCtor(arena, is_message_owned);
7459 // @@protoc_insertion_point(arena_constructor:tensorflow.CancelBarrierResponse)
7460 }
CancelBarrierResponse(const CancelBarrierResponse & from)7461 CancelBarrierResponse::CancelBarrierResponse(const CancelBarrierResponse& from)
7462 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
7463 CancelBarrierResponse* const _this = this; (void)_this;
7464 new (&_impl_) Impl_{
7465 /*decltype(_impl_._cached_size_)*/{}};
7466
7467 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
7468 // @@protoc_insertion_point(copy_constructor:tensorflow.CancelBarrierResponse)
7469 }
7470
SharedCtor(::_pb::Arena * arena,bool is_message_owned)7471 inline void CancelBarrierResponse::SharedCtor(
7472 ::_pb::Arena* arena, bool is_message_owned) {
7473 (void)arena;
7474 (void)is_message_owned;
7475 new (&_impl_) Impl_{
7476 /*decltype(_impl_._cached_size_)*/{}
7477 };
7478 }
7479
~CancelBarrierResponse()7480 CancelBarrierResponse::~CancelBarrierResponse() {
7481 // @@protoc_insertion_point(destructor:tensorflow.CancelBarrierResponse)
7482 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
7483 (void)arena;
7484 return;
7485 }
7486 SharedDtor();
7487 }
7488
SharedDtor()7489 inline void CancelBarrierResponse::SharedDtor() {
7490 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
7491 }
7492
SetCachedSize(int size) const7493 void CancelBarrierResponse::SetCachedSize(int size) const {
7494 _impl_._cached_size_.Set(size);
7495 }
7496
Clear()7497 void CancelBarrierResponse::Clear() {
7498 // @@protoc_insertion_point(message_clear_start:tensorflow.CancelBarrierResponse)
7499 ::uint32_t cached_has_bits = 0;
7500 // Prevent compiler warnings about cached_has_bits being unused
7501 (void) cached_has_bits;
7502
7503 _internal_metadata_.Clear<std::string>();
7504 }
7505
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)7506 const char* CancelBarrierResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
7507 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
7508 while (!ctx->Done(&ptr)) {
7509 ::uint32_t tag;
7510 ptr = ::_pbi::ReadTag(ptr, &tag);
7511 if ((tag == 0) || ((tag & 7) == 4)) {
7512 CHK_(ptr);
7513 ctx->SetLastTag(tag);
7514 goto message_done;
7515 }
7516 ptr = UnknownFieldParse(
7517 tag,
7518 _internal_metadata_.mutable_unknown_fields<std::string>(),
7519 ptr, ctx);
7520 CHK_(ptr != nullptr);
7521 } // while
7522 message_done:
7523 return ptr;
7524 failure:
7525 ptr = nullptr;
7526 goto message_done;
7527 #undef CHK_
7528 }
7529
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const7530 ::uint8_t* CancelBarrierResponse::_InternalSerialize(
7531 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
7532 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.CancelBarrierResponse)
7533 ::uint32_t cached_has_bits = 0;
7534 (void) cached_has_bits;
7535
7536 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
7537 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
7538 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
7539 }
7540 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.CancelBarrierResponse)
7541 return target;
7542 }
7543
ByteSizeLong() const7544 size_t CancelBarrierResponse::ByteSizeLong() const {
7545 // @@protoc_insertion_point(message_byte_size_start:tensorflow.CancelBarrierResponse)
7546 size_t total_size = 0;
7547
7548 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
7549 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
7550 }
7551 int cached_size = ::_pbi::ToCachedSize(total_size);
7552 SetCachedSize(cached_size);
7553 return total_size;
7554 }
7555
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)7556 void CancelBarrierResponse::CheckTypeAndMergeFrom(
7557 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
7558 MergeFrom(*::_pbi::DownCast<const CancelBarrierResponse*>(
7559 &from));
7560 }
7561
MergeFrom(const CancelBarrierResponse & from)7562 void CancelBarrierResponse::MergeFrom(const CancelBarrierResponse& from) {
7563 CancelBarrierResponse* const _this = this;
7564 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.CancelBarrierResponse)
7565 GOOGLE_DCHECK_NE(&from, _this);
7566 ::uint32_t cached_has_bits = 0;
7567 (void) cached_has_bits;
7568
7569 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
7570 }
7571
CopyFrom(const CancelBarrierResponse & from)7572 void CancelBarrierResponse::CopyFrom(const CancelBarrierResponse& from) {
7573 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.CancelBarrierResponse)
7574 if (&from == this) return;
7575 Clear();
7576 MergeFrom(from);
7577 }
7578
IsInitialized() const7579 bool CancelBarrierResponse::IsInitialized() const {
7580 return true;
7581 }
7582
InternalSwap(CancelBarrierResponse * other)7583 void CancelBarrierResponse::InternalSwap(CancelBarrierResponse* other) {
7584 using std::swap;
7585 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
7586 }
7587
GetTypeName() const7588 std::string CancelBarrierResponse::GetTypeName() const {
7589 return "tensorflow.CancelBarrierResponse";
7590 }
7591
7592
7593 // @@protoc_insertion_point(namespace_scope)
7594 } // namespace tensorflow
7595 PROTOBUF_NAMESPACE_OPEN
7596 template<> PROTOBUF_NOINLINE ::tensorflow::CoordinatedTask*
CreateMaybeMessage(Arena * arena)7597 Arena::CreateMaybeMessage< ::tensorflow::CoordinatedTask >(Arena* arena) {
7598 return Arena::CreateMessageInternal< ::tensorflow::CoordinatedTask >(arena);
7599 }
7600 template<> PROTOBUF_NOINLINE ::tensorflow::CoordinationServiceError*
CreateMaybeMessage(Arena * arena)7601 Arena::CreateMaybeMessage< ::tensorflow::CoordinationServiceError >(Arena* arena) {
7602 return Arena::CreateMessageInternal< ::tensorflow::CoordinationServiceError >(arena);
7603 }
7604 template<> PROTOBUF_NOINLINE ::tensorflow::TfDeviceList*
CreateMaybeMessage(Arena * arena)7605 Arena::CreateMaybeMessage< ::tensorflow::TfDeviceList >(Arena* arena) {
7606 return Arena::CreateMessageInternal< ::tensorflow::TfDeviceList >(arena);
7607 }
7608 template<> PROTOBUF_NOINLINE ::tensorflow::XlaDeviceList*
CreateMaybeMessage(Arena * arena)7609 Arena::CreateMaybeMessage< ::tensorflow::XlaDeviceList >(Arena* arena) {
7610 return Arena::CreateMessageInternal< ::tensorflow::XlaDeviceList >(arena);
7611 }
7612 template<> PROTOBUF_NOINLINE ::tensorflow::CoordinationServiceDeviceInfo*
CreateMaybeMessage(Arena * arena)7613 Arena::CreateMaybeMessage< ::tensorflow::CoordinationServiceDeviceInfo >(Arena* arena) {
7614 return Arena::CreateMessageInternal< ::tensorflow::CoordinationServiceDeviceInfo >(arena);
7615 }
7616 template<> PROTOBUF_NOINLINE ::tensorflow::RegisterTaskRequest*
CreateMaybeMessage(Arena * arena)7617 Arena::CreateMaybeMessage< ::tensorflow::RegisterTaskRequest >(Arena* arena) {
7618 return Arena::CreateMessageInternal< ::tensorflow::RegisterTaskRequest >(arena);
7619 }
7620 template<> PROTOBUF_NOINLINE ::tensorflow::RegisterTaskResponse*
CreateMaybeMessage(Arena * arena)7621 Arena::CreateMaybeMessage< ::tensorflow::RegisterTaskResponse >(Arena* arena) {
7622 return Arena::CreateMessageInternal< ::tensorflow::RegisterTaskResponse >(arena);
7623 }
7624 template<> PROTOBUF_NOINLINE ::tensorflow::HeartbeatRequest*
CreateMaybeMessage(Arena * arena)7625 Arena::CreateMaybeMessage< ::tensorflow::HeartbeatRequest >(Arena* arena) {
7626 return Arena::CreateMessageInternal< ::tensorflow::HeartbeatRequest >(arena);
7627 }
7628 template<> PROTOBUF_NOINLINE ::tensorflow::HeartbeatResponse*
CreateMaybeMessage(Arena * arena)7629 Arena::CreateMaybeMessage< ::tensorflow::HeartbeatResponse >(Arena* arena) {
7630 return Arena::CreateMessageInternal< ::tensorflow::HeartbeatResponse >(arena);
7631 }
7632 template<> PROTOBUF_NOINLINE ::tensorflow::WaitForAllTasksRequest*
CreateMaybeMessage(Arena * arena)7633 Arena::CreateMaybeMessage< ::tensorflow::WaitForAllTasksRequest >(Arena* arena) {
7634 return Arena::CreateMessageInternal< ::tensorflow::WaitForAllTasksRequest >(arena);
7635 }
7636 template<> PROTOBUF_NOINLINE ::tensorflow::WaitForAllTasksResponse*
CreateMaybeMessage(Arena * arena)7637 Arena::CreateMaybeMessage< ::tensorflow::WaitForAllTasksResponse >(Arena* arena) {
7638 return Arena::CreateMessageInternal< ::tensorflow::WaitForAllTasksResponse >(arena);
7639 }
7640 template<> PROTOBUF_NOINLINE ::tensorflow::ShutdownTaskRequest*
CreateMaybeMessage(Arena * arena)7641 Arena::CreateMaybeMessage< ::tensorflow::ShutdownTaskRequest >(Arena* arena) {
7642 return Arena::CreateMessageInternal< ::tensorflow::ShutdownTaskRequest >(arena);
7643 }
7644 template<> PROTOBUF_NOINLINE ::tensorflow::ShutdownTaskResponse*
CreateMaybeMessage(Arena * arena)7645 Arena::CreateMaybeMessage< ::tensorflow::ShutdownTaskResponse >(Arena* arena) {
7646 return Arena::CreateMessageInternal< ::tensorflow::ShutdownTaskResponse >(arena);
7647 }
7648 template<> PROTOBUF_NOINLINE ::tensorflow::ResetTaskRequest*
CreateMaybeMessage(Arena * arena)7649 Arena::CreateMaybeMessage< ::tensorflow::ResetTaskRequest >(Arena* arena) {
7650 return Arena::CreateMessageInternal< ::tensorflow::ResetTaskRequest >(arena);
7651 }
7652 template<> PROTOBUF_NOINLINE ::tensorflow::ResetTaskResponse*
CreateMaybeMessage(Arena * arena)7653 Arena::CreateMaybeMessage< ::tensorflow::ResetTaskResponse >(Arena* arena) {
7654 return Arena::CreateMessageInternal< ::tensorflow::ResetTaskResponse >(arena);
7655 }
7656 template<> PROTOBUF_NOINLINE ::tensorflow::ReportErrorToTaskRequest*
CreateMaybeMessage(Arena * arena)7657 Arena::CreateMaybeMessage< ::tensorflow::ReportErrorToTaskRequest >(Arena* arena) {
7658 return Arena::CreateMessageInternal< ::tensorflow::ReportErrorToTaskRequest >(arena);
7659 }
7660 template<> PROTOBUF_NOINLINE ::tensorflow::ReportErrorToTaskResponse*
CreateMaybeMessage(Arena * arena)7661 Arena::CreateMaybeMessage< ::tensorflow::ReportErrorToTaskResponse >(Arena* arena) {
7662 return Arena::CreateMessageInternal< ::tensorflow::ReportErrorToTaskResponse >(arena);
7663 }
7664 template<> PROTOBUF_NOINLINE ::tensorflow::ReportErrorToServiceRequest*
CreateMaybeMessage(Arena * arena)7665 Arena::CreateMaybeMessage< ::tensorflow::ReportErrorToServiceRequest >(Arena* arena) {
7666 return Arena::CreateMessageInternal< ::tensorflow::ReportErrorToServiceRequest >(arena);
7667 }
7668 template<> PROTOBUF_NOINLINE ::tensorflow::ReportErrorToServiceResponse*
CreateMaybeMessage(Arena * arena)7669 Arena::CreateMaybeMessage< ::tensorflow::ReportErrorToServiceResponse >(Arena* arena) {
7670 return Arena::CreateMessageInternal< ::tensorflow::ReportErrorToServiceResponse >(arena);
7671 }
7672 template<> PROTOBUF_NOINLINE ::tensorflow::KeyValueEntry*
CreateMaybeMessage(Arena * arena)7673 Arena::CreateMaybeMessage< ::tensorflow::KeyValueEntry >(Arena* arena) {
7674 return Arena::CreateMessageInternal< ::tensorflow::KeyValueEntry >(arena);
7675 }
7676 template<> PROTOBUF_NOINLINE ::tensorflow::InsertKeyValueRequest*
CreateMaybeMessage(Arena * arena)7677 Arena::CreateMaybeMessage< ::tensorflow::InsertKeyValueRequest >(Arena* arena) {
7678 return Arena::CreateMessageInternal< ::tensorflow::InsertKeyValueRequest >(arena);
7679 }
7680 template<> PROTOBUF_NOINLINE ::tensorflow::InsertKeyValueResponse*
CreateMaybeMessage(Arena * arena)7681 Arena::CreateMaybeMessage< ::tensorflow::InsertKeyValueResponse >(Arena* arena) {
7682 return Arena::CreateMessageInternal< ::tensorflow::InsertKeyValueResponse >(arena);
7683 }
7684 template<> PROTOBUF_NOINLINE ::tensorflow::GetKeyValueRequest*
CreateMaybeMessage(Arena * arena)7685 Arena::CreateMaybeMessage< ::tensorflow::GetKeyValueRequest >(Arena* arena) {
7686 return Arena::CreateMessageInternal< ::tensorflow::GetKeyValueRequest >(arena);
7687 }
7688 template<> PROTOBUF_NOINLINE ::tensorflow::GetKeyValueResponse*
CreateMaybeMessage(Arena * arena)7689 Arena::CreateMaybeMessage< ::tensorflow::GetKeyValueResponse >(Arena* arena) {
7690 return Arena::CreateMessageInternal< ::tensorflow::GetKeyValueResponse >(arena);
7691 }
7692 template<> PROTOBUF_NOINLINE ::tensorflow::TryGetKeyValueRequest*
CreateMaybeMessage(Arena * arena)7693 Arena::CreateMaybeMessage< ::tensorflow::TryGetKeyValueRequest >(Arena* arena) {
7694 return Arena::CreateMessageInternal< ::tensorflow::TryGetKeyValueRequest >(arena);
7695 }
7696 template<> PROTOBUF_NOINLINE ::tensorflow::TryGetKeyValueResponse*
CreateMaybeMessage(Arena * arena)7697 Arena::CreateMaybeMessage< ::tensorflow::TryGetKeyValueResponse >(Arena* arena) {
7698 return Arena::CreateMessageInternal< ::tensorflow::TryGetKeyValueResponse >(arena);
7699 }
7700 template<> PROTOBUF_NOINLINE ::tensorflow::GetKeyValueDirRequest*
CreateMaybeMessage(Arena * arena)7701 Arena::CreateMaybeMessage< ::tensorflow::GetKeyValueDirRequest >(Arena* arena) {
7702 return Arena::CreateMessageInternal< ::tensorflow::GetKeyValueDirRequest >(arena);
7703 }
7704 template<> PROTOBUF_NOINLINE ::tensorflow::GetKeyValueDirResponse*
CreateMaybeMessage(Arena * arena)7705 Arena::CreateMaybeMessage< ::tensorflow::GetKeyValueDirResponse >(Arena* arena) {
7706 return Arena::CreateMessageInternal< ::tensorflow::GetKeyValueDirResponse >(arena);
7707 }
7708 template<> PROTOBUF_NOINLINE ::tensorflow::DeleteKeyValueRequest*
CreateMaybeMessage(Arena * arena)7709 Arena::CreateMaybeMessage< ::tensorflow::DeleteKeyValueRequest >(Arena* arena) {
7710 return Arena::CreateMessageInternal< ::tensorflow::DeleteKeyValueRequest >(arena);
7711 }
7712 template<> PROTOBUF_NOINLINE ::tensorflow::DeleteKeyValueResponse*
CreateMaybeMessage(Arena * arena)7713 Arena::CreateMaybeMessage< ::tensorflow::DeleteKeyValueResponse >(Arena* arena) {
7714 return Arena::CreateMessageInternal< ::tensorflow::DeleteKeyValueResponse >(arena);
7715 }
7716 template<> PROTOBUF_NOINLINE ::tensorflow::BarrierRequest*
CreateMaybeMessage(Arena * arena)7717 Arena::CreateMaybeMessage< ::tensorflow::BarrierRequest >(Arena* arena) {
7718 return Arena::CreateMessageInternal< ::tensorflow::BarrierRequest >(arena);
7719 }
7720 template<> PROTOBUF_NOINLINE ::tensorflow::BarrierResponse*
CreateMaybeMessage(Arena * arena)7721 Arena::CreateMaybeMessage< ::tensorflow::BarrierResponse >(Arena* arena) {
7722 return Arena::CreateMessageInternal< ::tensorflow::BarrierResponse >(arena);
7723 }
7724 template<> PROTOBUF_NOINLINE ::tensorflow::CancelBarrierRequest*
CreateMaybeMessage(Arena * arena)7725 Arena::CreateMaybeMessage< ::tensorflow::CancelBarrierRequest >(Arena* arena) {
7726 return Arena::CreateMessageInternal< ::tensorflow::CancelBarrierRequest >(arena);
7727 }
7728 template<> PROTOBUF_NOINLINE ::tensorflow::CancelBarrierResponse*
CreateMaybeMessage(Arena * arena)7729 Arena::CreateMaybeMessage< ::tensorflow::CancelBarrierResponse >(Arena* arena) {
7730 return Arena::CreateMessageInternal< ::tensorflow::CancelBarrierResponse >(arena);
7731 }
7732 PROTOBUF_NAMESPACE_CLOSE
7733
7734 // @@protoc_insertion_point(global_scope)
7735 #include <google/protobuf/port_undef.inc>
7736