1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: tensorflow/core/util/event.proto
3
4 #include "tensorflow/core/util/event.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 {
Event(::_pbi::ConstantInitialized)22 PROTOBUF_CONSTEXPR Event::Event(
23 ::_pbi::ConstantInitialized): _impl_{
24 /*decltype(_impl_.wall_time_)*/0
25 , /*decltype(_impl_.step_)*/::int64_t{0}
26 , /*decltype(_impl_.what_)*/{}
27 , /*decltype(_impl_._cached_size_)*/{}
28 , /*decltype(_impl_._oneof_case_)*/{}} {}
29 struct EventDefaultTypeInternal {
EventDefaultTypeInternaltensorflow::EventDefaultTypeInternal30 PROTOBUF_CONSTEXPR EventDefaultTypeInternal()
31 : _instance(::_pbi::ConstantInitialized{}) {}
~EventDefaultTypeInternaltensorflow::EventDefaultTypeInternal32 ~EventDefaultTypeInternal() {}
33 union { // NOLINT(misc-non-private-member-variables-in-classes)
34 Event _instance;
35 };
36 };
37 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EventDefaultTypeInternal _Event_default_instance_;
LogMessage(::_pbi::ConstantInitialized)38 PROTOBUF_CONSTEXPR LogMessage::LogMessage(
39 ::_pbi::ConstantInitialized): _impl_{
40 /*decltype(_impl_.message_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
41 , /*decltype(_impl_.level_)*/0
42 , /*decltype(_impl_._cached_size_)*/{}} {}
43 struct LogMessageDefaultTypeInternal {
LogMessageDefaultTypeInternaltensorflow::LogMessageDefaultTypeInternal44 PROTOBUF_CONSTEXPR LogMessageDefaultTypeInternal()
45 : _instance(::_pbi::ConstantInitialized{}) {}
~LogMessageDefaultTypeInternaltensorflow::LogMessageDefaultTypeInternal46 ~LogMessageDefaultTypeInternal() {}
47 union { // NOLINT(misc-non-private-member-variables-in-classes)
48 LogMessage _instance;
49 };
50 };
51 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LogMessageDefaultTypeInternal _LogMessage_default_instance_;
SessionLog(::_pbi::ConstantInitialized)52 PROTOBUF_CONSTEXPR SessionLog::SessionLog(
53 ::_pbi::ConstantInitialized): _impl_{
54 /*decltype(_impl_.checkpoint_path_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
55 , /*decltype(_impl_.msg_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
56 , /*decltype(_impl_.status_)*/0
57 , /*decltype(_impl_._cached_size_)*/{}} {}
58 struct SessionLogDefaultTypeInternal {
SessionLogDefaultTypeInternaltensorflow::SessionLogDefaultTypeInternal59 PROTOBUF_CONSTEXPR SessionLogDefaultTypeInternal()
60 : _instance(::_pbi::ConstantInitialized{}) {}
~SessionLogDefaultTypeInternaltensorflow::SessionLogDefaultTypeInternal61 ~SessionLogDefaultTypeInternal() {}
62 union { // NOLINT(misc-non-private-member-variables-in-classes)
63 SessionLog _instance;
64 };
65 };
66 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SessionLogDefaultTypeInternal _SessionLog_default_instance_;
TaggedRunMetadata(::_pbi::ConstantInitialized)67 PROTOBUF_CONSTEXPR TaggedRunMetadata::TaggedRunMetadata(
68 ::_pbi::ConstantInitialized): _impl_{
69 /*decltype(_impl_.tag_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
70 , /*decltype(_impl_.run_metadata_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
71 , /*decltype(_impl_._cached_size_)*/{}} {}
72 struct TaggedRunMetadataDefaultTypeInternal {
TaggedRunMetadataDefaultTypeInternaltensorflow::TaggedRunMetadataDefaultTypeInternal73 PROTOBUF_CONSTEXPR TaggedRunMetadataDefaultTypeInternal()
74 : _instance(::_pbi::ConstantInitialized{}) {}
~TaggedRunMetadataDefaultTypeInternaltensorflow::TaggedRunMetadataDefaultTypeInternal75 ~TaggedRunMetadataDefaultTypeInternal() {}
76 union { // NOLINT(misc-non-private-member-variables-in-classes)
77 TaggedRunMetadata _instance;
78 };
79 };
80 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TaggedRunMetadataDefaultTypeInternal _TaggedRunMetadata_default_instance_;
WatchdogConfig(::_pbi::ConstantInitialized)81 PROTOBUF_CONSTEXPR WatchdogConfig::WatchdogConfig(
82 ::_pbi::ConstantInitialized): _impl_{
83 /*decltype(_impl_.timeout_ms_)*/::int64_t{0}
84 , /*decltype(_impl_._cached_size_)*/{}} {}
85 struct WatchdogConfigDefaultTypeInternal {
WatchdogConfigDefaultTypeInternaltensorflow::WatchdogConfigDefaultTypeInternal86 PROTOBUF_CONSTEXPR WatchdogConfigDefaultTypeInternal()
87 : _instance(::_pbi::ConstantInitialized{}) {}
~WatchdogConfigDefaultTypeInternaltensorflow::WatchdogConfigDefaultTypeInternal88 ~WatchdogConfigDefaultTypeInternal() {}
89 union { // NOLINT(misc-non-private-member-variables-in-classes)
90 WatchdogConfig _instance;
91 };
92 };
93 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WatchdogConfigDefaultTypeInternal _WatchdogConfig_default_instance_;
RequestedExitCode(::_pbi::ConstantInitialized)94 PROTOBUF_CONSTEXPR RequestedExitCode::RequestedExitCode(
95 ::_pbi::ConstantInitialized): _impl_{
96 /*decltype(_impl_.exit_code_)*/0
97 , /*decltype(_impl_._cached_size_)*/{}} {}
98 struct RequestedExitCodeDefaultTypeInternal {
RequestedExitCodeDefaultTypeInternaltensorflow::RequestedExitCodeDefaultTypeInternal99 PROTOBUF_CONSTEXPR RequestedExitCodeDefaultTypeInternal()
100 : _instance(::_pbi::ConstantInitialized{}) {}
~RequestedExitCodeDefaultTypeInternaltensorflow::RequestedExitCodeDefaultTypeInternal101 ~RequestedExitCodeDefaultTypeInternal() {}
102 union { // NOLINT(misc-non-private-member-variables-in-classes)
103 RequestedExitCode _instance;
104 };
105 };
106 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RequestedExitCodeDefaultTypeInternal _RequestedExitCode_default_instance_;
WorkerHeartbeatRequest(::_pbi::ConstantInitialized)107 PROTOBUF_CONSTEXPR WorkerHeartbeatRequest::WorkerHeartbeatRequest(
108 ::_pbi::ConstantInitialized): _impl_{
109 /*decltype(_impl_.watchdog_config_)*/nullptr
110 , /*decltype(_impl_.exit_code_)*/nullptr
111 , /*decltype(_impl_.shutdown_mode_)*/0
112 , /*decltype(_impl_._cached_size_)*/{}} {}
113 struct WorkerHeartbeatRequestDefaultTypeInternal {
WorkerHeartbeatRequestDefaultTypeInternaltensorflow::WorkerHeartbeatRequestDefaultTypeInternal114 PROTOBUF_CONSTEXPR WorkerHeartbeatRequestDefaultTypeInternal()
115 : _instance(::_pbi::ConstantInitialized{}) {}
~WorkerHeartbeatRequestDefaultTypeInternaltensorflow::WorkerHeartbeatRequestDefaultTypeInternal116 ~WorkerHeartbeatRequestDefaultTypeInternal() {}
117 union { // NOLINT(misc-non-private-member-variables-in-classes)
118 WorkerHeartbeatRequest _instance;
119 };
120 };
121 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WorkerHeartbeatRequestDefaultTypeInternal _WorkerHeartbeatRequest_default_instance_;
WorkerHeartbeatResponse(::_pbi::ConstantInitialized)122 PROTOBUF_CONSTEXPR WorkerHeartbeatResponse::WorkerHeartbeatResponse(
123 ::_pbi::ConstantInitialized): _impl_{
124 /*decltype(_impl_.worker_log_)*/{}
125 , /*decltype(_impl_.hostname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
126 , /*decltype(_impl_.health_status_)*/0
127 , /*decltype(_impl_._cached_size_)*/{}} {}
128 struct WorkerHeartbeatResponseDefaultTypeInternal {
WorkerHeartbeatResponseDefaultTypeInternaltensorflow::WorkerHeartbeatResponseDefaultTypeInternal129 PROTOBUF_CONSTEXPR WorkerHeartbeatResponseDefaultTypeInternal()
130 : _instance(::_pbi::ConstantInitialized{}) {}
~WorkerHeartbeatResponseDefaultTypeInternaltensorflow::WorkerHeartbeatResponseDefaultTypeInternal131 ~WorkerHeartbeatResponseDefaultTypeInternal() {}
132 union { // NOLINT(misc-non-private-member-variables-in-classes)
133 WorkerHeartbeatResponse _instance;
134 };
135 };
136 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WorkerHeartbeatResponseDefaultTypeInternal _WorkerHeartbeatResponse_default_instance_;
137 } // namespace tensorflow
138 namespace tensorflow {
LogMessage_Level_IsValid(int value)139 bool LogMessage_Level_IsValid(int value) {
140 switch (value) {
141 case 0:
142 case 10:
143 case 20:
144 case 30:
145 case 40:
146 case 50:
147 return true;
148 default:
149 return false;
150 }
151 }
152
153 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> LogMessage_Level_strings[6] = {};
154
155 static const char LogMessage_Level_names[] =
156 "DEBUGGING"
157 "ERROR"
158 "FATAL"
159 "INFO"
160 "UNKNOWN"
161 "WARN";
162
163 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry LogMessage_Level_entries[] = {
164 { {LogMessage_Level_names + 0, 9}, 10 },
165 { {LogMessage_Level_names + 9, 5}, 40 },
166 { {LogMessage_Level_names + 14, 5}, 50 },
167 { {LogMessage_Level_names + 19, 4}, 20 },
168 { {LogMessage_Level_names + 23, 7}, 0 },
169 { {LogMessage_Level_names + 30, 4}, 30 },
170 };
171
172 static const int LogMessage_Level_entries_by_number[] = {
173 4, // 0 -> UNKNOWN
174 0, // 10 -> DEBUGGING
175 3, // 20 -> INFO
176 5, // 30 -> WARN
177 1, // 40 -> ERROR
178 2, // 50 -> FATAL
179 };
180
LogMessage_Level_Name(LogMessage_Level value)181 const std::string& LogMessage_Level_Name(
182 LogMessage_Level value) {
183 static const bool dummy =
184 ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
185 LogMessage_Level_entries,
186 LogMessage_Level_entries_by_number,
187 6, LogMessage_Level_strings);
188 (void) dummy;
189 int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
190 LogMessage_Level_entries,
191 LogMessage_Level_entries_by_number,
192 6, value);
193 return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
194 LogMessage_Level_strings[idx].get();
195 }
LogMessage_Level_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,LogMessage_Level * value)196 bool LogMessage_Level_Parse(
197 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LogMessage_Level* value) {
198 int int_value;
199 bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
200 LogMessage_Level_entries, 6, name, &int_value);
201 if (success) {
202 *value = static_cast<LogMessage_Level>(int_value);
203 }
204 return success;
205 }
206 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
207 constexpr LogMessage_Level LogMessage::UNKNOWN;
208 constexpr LogMessage_Level LogMessage::DEBUGGING;
209 constexpr LogMessage_Level LogMessage::INFO;
210 constexpr LogMessage_Level LogMessage::WARN;
211 constexpr LogMessage_Level LogMessage::ERROR;
212 constexpr LogMessage_Level LogMessage::FATAL;
213 constexpr LogMessage_Level LogMessage::Level_MIN;
214 constexpr LogMessage_Level LogMessage::Level_MAX;
215 constexpr int LogMessage::Level_ARRAYSIZE;
216 #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
SessionLog_SessionStatus_IsValid(int value)217 bool SessionLog_SessionStatus_IsValid(int value) {
218 switch (value) {
219 case 0:
220 case 1:
221 case 2:
222 case 3:
223 return true;
224 default:
225 return false;
226 }
227 }
228
229 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> SessionLog_SessionStatus_strings[4] = {};
230
231 static const char SessionLog_SessionStatus_names[] =
232 "CHECKPOINT"
233 "START"
234 "STATUS_UNSPECIFIED"
235 "STOP";
236
237 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry SessionLog_SessionStatus_entries[] = {
238 { {SessionLog_SessionStatus_names + 0, 10}, 3 },
239 { {SessionLog_SessionStatus_names + 10, 5}, 1 },
240 { {SessionLog_SessionStatus_names + 15, 18}, 0 },
241 { {SessionLog_SessionStatus_names + 33, 4}, 2 },
242 };
243
244 static const int SessionLog_SessionStatus_entries_by_number[] = {
245 2, // 0 -> STATUS_UNSPECIFIED
246 1, // 1 -> START
247 3, // 2 -> STOP
248 0, // 3 -> CHECKPOINT
249 };
250
SessionLog_SessionStatus_Name(SessionLog_SessionStatus value)251 const std::string& SessionLog_SessionStatus_Name(
252 SessionLog_SessionStatus value) {
253 static const bool dummy =
254 ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
255 SessionLog_SessionStatus_entries,
256 SessionLog_SessionStatus_entries_by_number,
257 4, SessionLog_SessionStatus_strings);
258 (void) dummy;
259 int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
260 SessionLog_SessionStatus_entries,
261 SessionLog_SessionStatus_entries_by_number,
262 4, value);
263 return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
264 SessionLog_SessionStatus_strings[idx].get();
265 }
SessionLog_SessionStatus_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,SessionLog_SessionStatus * value)266 bool SessionLog_SessionStatus_Parse(
267 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SessionLog_SessionStatus* value) {
268 int int_value;
269 bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
270 SessionLog_SessionStatus_entries, 4, name, &int_value);
271 if (success) {
272 *value = static_cast<SessionLog_SessionStatus>(int_value);
273 }
274 return success;
275 }
276 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
277 constexpr SessionLog_SessionStatus SessionLog::STATUS_UNSPECIFIED;
278 constexpr SessionLog_SessionStatus SessionLog::START;
279 constexpr SessionLog_SessionStatus SessionLog::STOP;
280 constexpr SessionLog_SessionStatus SessionLog::CHECKPOINT;
281 constexpr SessionLog_SessionStatus SessionLog::SessionStatus_MIN;
282 constexpr SessionLog_SessionStatus SessionLog::SessionStatus_MAX;
283 constexpr int SessionLog::SessionStatus_ARRAYSIZE;
284 #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
WorkerHealth_IsValid(int value)285 bool WorkerHealth_IsValid(int value) {
286 switch (value) {
287 case 0:
288 case 1:
289 case 2:
290 case 3:
291 return true;
292 default:
293 return false;
294 }
295 }
296
297 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> WorkerHealth_strings[4] = {};
298
299 static const char WorkerHealth_names[] =
300 "INTERNAL_ERROR"
301 "OK"
302 "RECEIVED_SHUTDOWN_SIGNAL"
303 "SHUTTING_DOWN";
304
305 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry WorkerHealth_entries[] = {
306 { {WorkerHealth_names + 0, 14}, 2 },
307 { {WorkerHealth_names + 14, 2}, 0 },
308 { {WorkerHealth_names + 16, 24}, 1 },
309 { {WorkerHealth_names + 40, 13}, 3 },
310 };
311
312 static const int WorkerHealth_entries_by_number[] = {
313 1, // 0 -> OK
314 2, // 1 -> RECEIVED_SHUTDOWN_SIGNAL
315 0, // 2 -> INTERNAL_ERROR
316 3, // 3 -> SHUTTING_DOWN
317 };
318
WorkerHealth_Name(WorkerHealth value)319 const std::string& WorkerHealth_Name(
320 WorkerHealth value) {
321 static const bool dummy =
322 ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
323 WorkerHealth_entries,
324 WorkerHealth_entries_by_number,
325 4, WorkerHealth_strings);
326 (void) dummy;
327 int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
328 WorkerHealth_entries,
329 WorkerHealth_entries_by_number,
330 4, value);
331 return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
332 WorkerHealth_strings[idx].get();
333 }
WorkerHealth_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,WorkerHealth * value)334 bool WorkerHealth_Parse(
335 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WorkerHealth* value) {
336 int int_value;
337 bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
338 WorkerHealth_entries, 4, name, &int_value);
339 if (success) {
340 *value = static_cast<WorkerHealth>(int_value);
341 }
342 return success;
343 }
WorkerShutdownMode_IsValid(int value)344 bool WorkerShutdownMode_IsValid(int value) {
345 switch (value) {
346 case 0:
347 case 1:
348 case 2:
349 case 3:
350 return true;
351 default:
352 return false;
353 }
354 }
355
356 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> WorkerShutdownMode_strings[4] = {};
357
358 static const char WorkerShutdownMode_names[] =
359 "DEFAULT"
360 "NOT_CONFIGURED"
361 "SHUTDOWN_AFTER_TIMEOUT"
362 "WAIT_FOR_COORDINATOR";
363
364 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry WorkerShutdownMode_entries[] = {
365 { {WorkerShutdownMode_names + 0, 7}, 0 },
366 { {WorkerShutdownMode_names + 7, 14}, 1 },
367 { {WorkerShutdownMode_names + 21, 22}, 3 },
368 { {WorkerShutdownMode_names + 43, 20}, 2 },
369 };
370
371 static const int WorkerShutdownMode_entries_by_number[] = {
372 0, // 0 -> DEFAULT
373 1, // 1 -> NOT_CONFIGURED
374 3, // 2 -> WAIT_FOR_COORDINATOR
375 2, // 3 -> SHUTDOWN_AFTER_TIMEOUT
376 };
377
WorkerShutdownMode_Name(WorkerShutdownMode value)378 const std::string& WorkerShutdownMode_Name(
379 WorkerShutdownMode value) {
380 static const bool dummy =
381 ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
382 WorkerShutdownMode_entries,
383 WorkerShutdownMode_entries_by_number,
384 4, WorkerShutdownMode_strings);
385 (void) dummy;
386 int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
387 WorkerShutdownMode_entries,
388 WorkerShutdownMode_entries_by_number,
389 4, value);
390 return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
391 WorkerShutdownMode_strings[idx].get();
392 }
WorkerShutdownMode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,WorkerShutdownMode * value)393 bool WorkerShutdownMode_Parse(
394 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WorkerShutdownMode* value) {
395 int int_value;
396 bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
397 WorkerShutdownMode_entries, 4, name, &int_value);
398 if (success) {
399 *value = static_cast<WorkerShutdownMode>(int_value);
400 }
401 return success;
402 }
403
404 // ===================================================================
405
406 class Event::_Internal {
407 public:
408 static const ::tensorflow::Summary& summary(const Event* msg);
409 static const ::tensorflow::LogMessage& log_message(const Event* msg);
410 static const ::tensorflow::SessionLog& session_log(const Event* msg);
411 static const ::tensorflow::TaggedRunMetadata& tagged_run_metadata(const Event* msg);
412 };
413
414 const ::tensorflow::Summary&
summary(const Event * msg)415 Event::_Internal::summary(const Event* msg) {
416 return *msg->_impl_.what_.summary_;
417 }
418 const ::tensorflow::LogMessage&
log_message(const Event * msg)419 Event::_Internal::log_message(const Event* msg) {
420 return *msg->_impl_.what_.log_message_;
421 }
422 const ::tensorflow::SessionLog&
session_log(const Event * msg)423 Event::_Internal::session_log(const Event* msg) {
424 return *msg->_impl_.what_.session_log_;
425 }
426 const ::tensorflow::TaggedRunMetadata&
tagged_run_metadata(const Event * msg)427 Event::_Internal::tagged_run_metadata(const Event* msg) {
428 return *msg->_impl_.what_.tagged_run_metadata_;
429 }
set_allocated_summary(::tensorflow::Summary * summary)430 void Event::set_allocated_summary(::tensorflow::Summary* summary) {
431 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
432 clear_what();
433 if (summary) {
434 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
435 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
436 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(summary));
437 if (message_arena != submessage_arena) {
438 summary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
439 message_arena, summary, submessage_arena);
440 }
441 set_has_summary();
442 _impl_.what_.summary_ = summary;
443 }
444 // @@protoc_insertion_point(field_set_allocated:tensorflow.Event.summary)
445 }
clear_summary()446 void Event::clear_summary() {
447 if (_internal_has_summary()) {
448 if (GetArenaForAllocation() == nullptr) {
449 delete _impl_.what_.summary_;
450 }
451 clear_has_what();
452 }
453 }
set_allocated_log_message(::tensorflow::LogMessage * log_message)454 void Event::set_allocated_log_message(::tensorflow::LogMessage* log_message) {
455 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
456 clear_what();
457 if (log_message) {
458 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
459 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(log_message);
460 if (message_arena != submessage_arena) {
461 log_message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
462 message_arena, log_message, submessage_arena);
463 }
464 set_has_log_message();
465 _impl_.what_.log_message_ = log_message;
466 }
467 // @@protoc_insertion_point(field_set_allocated:tensorflow.Event.log_message)
468 }
set_allocated_session_log(::tensorflow::SessionLog * session_log)469 void Event::set_allocated_session_log(::tensorflow::SessionLog* session_log) {
470 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
471 clear_what();
472 if (session_log) {
473 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
474 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(session_log);
475 if (message_arena != submessage_arena) {
476 session_log = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
477 message_arena, session_log, submessage_arena);
478 }
479 set_has_session_log();
480 _impl_.what_.session_log_ = session_log;
481 }
482 // @@protoc_insertion_point(field_set_allocated:tensorflow.Event.session_log)
483 }
set_allocated_tagged_run_metadata(::tensorflow::TaggedRunMetadata * tagged_run_metadata)484 void Event::set_allocated_tagged_run_metadata(::tensorflow::TaggedRunMetadata* tagged_run_metadata) {
485 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
486 clear_what();
487 if (tagged_run_metadata) {
488 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
489 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(tagged_run_metadata);
490 if (message_arena != submessage_arena) {
491 tagged_run_metadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
492 message_arena, tagged_run_metadata, submessage_arena);
493 }
494 set_has_tagged_run_metadata();
495 _impl_.what_.tagged_run_metadata_ = tagged_run_metadata;
496 }
497 // @@protoc_insertion_point(field_set_allocated:tensorflow.Event.tagged_run_metadata)
498 }
Event(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)499 Event::Event(::PROTOBUF_NAMESPACE_ID::Arena* arena,
500 bool is_message_owned)
501 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
502 SharedCtor(arena, is_message_owned);
503 // @@protoc_insertion_point(arena_constructor:tensorflow.Event)
504 }
Event(const Event & from)505 Event::Event(const Event& from)
506 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
507 Event* const _this = this; (void)_this;
508 new (&_impl_) Impl_{
509 decltype(_impl_.wall_time_){}
510 , decltype(_impl_.step_){}
511 , decltype(_impl_.what_){}
512 , /*decltype(_impl_._cached_size_)*/{}
513 , /*decltype(_impl_._oneof_case_)*/{}};
514
515 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
516 ::memcpy(&_impl_.wall_time_, &from._impl_.wall_time_,
517 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.step_) -
518 reinterpret_cast<char*>(&_impl_.wall_time_)) + sizeof(_impl_.step_));
519 clear_has_what();
520 switch (from.what_case()) {
521 case kFileVersion: {
522 _this->_internal_set_file_version(from._internal_file_version());
523 break;
524 }
525 case kGraphDef: {
526 _this->_internal_set_graph_def(from._internal_graph_def());
527 break;
528 }
529 case kSummary: {
530 _this->_internal_mutable_summary()->::tensorflow::Summary::MergeFrom(
531 from._internal_summary());
532 break;
533 }
534 case kLogMessage: {
535 _this->_internal_mutable_log_message()->::tensorflow::LogMessage::MergeFrom(
536 from._internal_log_message());
537 break;
538 }
539 case kSessionLog: {
540 _this->_internal_mutable_session_log()->::tensorflow::SessionLog::MergeFrom(
541 from._internal_session_log());
542 break;
543 }
544 case kTaggedRunMetadata: {
545 _this->_internal_mutable_tagged_run_metadata()->::tensorflow::TaggedRunMetadata::MergeFrom(
546 from._internal_tagged_run_metadata());
547 break;
548 }
549 case kMetaGraphDef: {
550 _this->_internal_set_meta_graph_def(from._internal_meta_graph_def());
551 break;
552 }
553 case WHAT_NOT_SET: {
554 break;
555 }
556 }
557 // @@protoc_insertion_point(copy_constructor:tensorflow.Event)
558 }
559
SharedCtor(::_pb::Arena * arena,bool is_message_owned)560 inline void Event::SharedCtor(
561 ::_pb::Arena* arena, bool is_message_owned) {
562 (void)arena;
563 (void)is_message_owned;
564 new (&_impl_) Impl_{
565 decltype(_impl_.wall_time_){0}
566 , decltype(_impl_.step_){::int64_t{0}}
567 , decltype(_impl_.what_){}
568 , /*decltype(_impl_._cached_size_)*/{}
569 , /*decltype(_impl_._oneof_case_)*/{}
570 };
571 clear_has_what();
572 }
573
~Event()574 Event::~Event() {
575 // @@protoc_insertion_point(destructor:tensorflow.Event)
576 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
577 (void)arena;
578 return;
579 }
580 SharedDtor();
581 }
582
SharedDtor()583 inline void Event::SharedDtor() {
584 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
585 if (has_what()) {
586 clear_what();
587 }
588 }
589
SetCachedSize(int size) const590 void Event::SetCachedSize(int size) const {
591 _impl_._cached_size_.Set(size);
592 }
593
clear_what()594 void Event::clear_what() {
595 // @@protoc_insertion_point(one_of_clear_start:tensorflow.Event)
596 switch (what_case()) {
597 case kFileVersion: {
598 _impl_.what_.file_version_.Destroy();
599 break;
600 }
601 case kGraphDef: {
602 _impl_.what_.graph_def_.Destroy();
603 break;
604 }
605 case kSummary: {
606 if (GetArenaForAllocation() == nullptr) {
607 delete _impl_.what_.summary_;
608 }
609 break;
610 }
611 case kLogMessage: {
612 if (GetArenaForAllocation() == nullptr) {
613 delete _impl_.what_.log_message_;
614 }
615 break;
616 }
617 case kSessionLog: {
618 if (GetArenaForAllocation() == nullptr) {
619 delete _impl_.what_.session_log_;
620 }
621 break;
622 }
623 case kTaggedRunMetadata: {
624 if (GetArenaForAllocation() == nullptr) {
625 delete _impl_.what_.tagged_run_metadata_;
626 }
627 break;
628 }
629 case kMetaGraphDef: {
630 _impl_.what_.meta_graph_def_.Destroy();
631 break;
632 }
633 case WHAT_NOT_SET: {
634 break;
635 }
636 }
637 _impl_._oneof_case_[0] = WHAT_NOT_SET;
638 }
639
640
Clear()641 void Event::Clear() {
642 // @@protoc_insertion_point(message_clear_start:tensorflow.Event)
643 ::uint32_t cached_has_bits = 0;
644 // Prevent compiler warnings about cached_has_bits being unused
645 (void) cached_has_bits;
646
647 ::memset(&_impl_.wall_time_, 0, static_cast<size_t>(
648 reinterpret_cast<char*>(&_impl_.step_) -
649 reinterpret_cast<char*>(&_impl_.wall_time_)) + sizeof(_impl_.step_));
650 clear_what();
651 _internal_metadata_.Clear<std::string>();
652 }
653
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)654 const char* Event::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
655 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
656 while (!ctx->Done(&ptr)) {
657 ::uint32_t tag;
658 ptr = ::_pbi::ReadTag(ptr, &tag);
659 switch (tag >> 3) {
660 // double wall_time = 1;
661 case 1:
662 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 9)) {
663 _impl_.wall_time_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
664 ptr += sizeof(double);
665 } else {
666 goto handle_unusual;
667 }
668 continue;
669 // int64 step = 2;
670 case 2:
671 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
672 _impl_.step_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
673 CHK_(ptr);
674 } else {
675 goto handle_unusual;
676 }
677 continue;
678 // string file_version = 3;
679 case 3:
680 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
681 auto str = _internal_mutable_file_version();
682 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
683 CHK_(ptr);
684 CHK_(::_pbi::VerifyUTF8(str, nullptr));
685 } else {
686 goto handle_unusual;
687 }
688 continue;
689 // bytes graph_def = 4;
690 case 4:
691 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
692 auto str = _internal_mutable_graph_def();
693 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
694 CHK_(ptr);
695 } else {
696 goto handle_unusual;
697 }
698 continue;
699 // .tensorflow.Summary summary = 5;
700 case 5:
701 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
702 ptr = ctx->ParseMessage(_internal_mutable_summary(), ptr);
703 CHK_(ptr);
704 } else {
705 goto handle_unusual;
706 }
707 continue;
708 // .tensorflow.LogMessage log_message = 6 [deprecated = true];
709 case 6:
710 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
711 ptr = ctx->ParseMessage(_internal_mutable_log_message(), ptr);
712 CHK_(ptr);
713 } else {
714 goto handle_unusual;
715 }
716 continue;
717 // .tensorflow.SessionLog session_log = 7;
718 case 7:
719 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 58)) {
720 ptr = ctx->ParseMessage(_internal_mutable_session_log(), ptr);
721 CHK_(ptr);
722 } else {
723 goto handle_unusual;
724 }
725 continue;
726 // .tensorflow.TaggedRunMetadata tagged_run_metadata = 8;
727 case 8:
728 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 66)) {
729 ptr = ctx->ParseMessage(_internal_mutable_tagged_run_metadata(), ptr);
730 CHK_(ptr);
731 } else {
732 goto handle_unusual;
733 }
734 continue;
735 // bytes meta_graph_def = 9;
736 case 9:
737 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 74)) {
738 auto str = _internal_mutable_meta_graph_def();
739 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
740 CHK_(ptr);
741 } else {
742 goto handle_unusual;
743 }
744 continue;
745 default:
746 goto handle_unusual;
747 } // switch
748 handle_unusual:
749 if ((tag == 0) || ((tag & 7) == 4)) {
750 CHK_(ptr);
751 ctx->SetLastTag(tag);
752 goto message_done;
753 }
754 ptr = UnknownFieldParse(
755 tag,
756 _internal_metadata_.mutable_unknown_fields<std::string>(),
757 ptr, ctx);
758 CHK_(ptr != nullptr);
759 } // while
760 message_done:
761 return ptr;
762 failure:
763 ptr = nullptr;
764 goto message_done;
765 #undef CHK_
766 }
767
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const768 ::uint8_t* Event::_InternalSerialize(
769 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
770 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.Event)
771 ::uint32_t cached_has_bits = 0;
772 (void) cached_has_bits;
773
774 // double wall_time = 1;
775 static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size.");
776 double tmp_wall_time = this->_internal_wall_time();
777 ::uint64_t raw_wall_time;
778 memcpy(&raw_wall_time, &tmp_wall_time, sizeof(tmp_wall_time));
779 if (raw_wall_time != 0) {
780 target = stream->EnsureSpace(target);
781 target = ::_pbi::WireFormatLite::WriteDoubleToArray(1, this->_internal_wall_time(), target);
782 }
783
784 // int64 step = 2;
785 if (this->_internal_step() != 0) {
786 target = stream->EnsureSpace(target);
787 target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_step(), target);
788 }
789
790 // string file_version = 3;
791 if (_internal_has_file_version()) {
792 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
793 this->_internal_file_version().data(), static_cast<int>(this->_internal_file_version().length()),
794 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
795 "tensorflow.Event.file_version");
796 target = stream->WriteStringMaybeAliased(
797 3, this->_internal_file_version(), target);
798 }
799
800 // bytes graph_def = 4;
801 if (_internal_has_graph_def()) {
802 target = stream->WriteBytesMaybeAliased(
803 4, this->_internal_graph_def(), target);
804 }
805
806 // .tensorflow.Summary summary = 5;
807 if (_internal_has_summary()) {
808 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
809 InternalWriteMessage(5, _Internal::summary(this),
810 _Internal::summary(this).GetCachedSize(), target, stream);
811 }
812
813 // .tensorflow.LogMessage log_message = 6 [deprecated = true];
814 if (_internal_has_log_message()) {
815 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
816 InternalWriteMessage(6, _Internal::log_message(this),
817 _Internal::log_message(this).GetCachedSize(), target, stream);
818 }
819
820 // .tensorflow.SessionLog session_log = 7;
821 if (_internal_has_session_log()) {
822 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
823 InternalWriteMessage(7, _Internal::session_log(this),
824 _Internal::session_log(this).GetCachedSize(), target, stream);
825 }
826
827 // .tensorflow.TaggedRunMetadata tagged_run_metadata = 8;
828 if (_internal_has_tagged_run_metadata()) {
829 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
830 InternalWriteMessage(8, _Internal::tagged_run_metadata(this),
831 _Internal::tagged_run_metadata(this).GetCachedSize(), target, stream);
832 }
833
834 // bytes meta_graph_def = 9;
835 if (_internal_has_meta_graph_def()) {
836 target = stream->WriteBytesMaybeAliased(
837 9, this->_internal_meta_graph_def(), target);
838 }
839
840 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
841 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
842 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
843 }
844 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.Event)
845 return target;
846 }
847
ByteSizeLong() const848 size_t Event::ByteSizeLong() const {
849 // @@protoc_insertion_point(message_byte_size_start:tensorflow.Event)
850 size_t total_size = 0;
851
852 ::uint32_t cached_has_bits = 0;
853 // Prevent compiler warnings about cached_has_bits being unused
854 (void) cached_has_bits;
855
856 // double wall_time = 1;
857 static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size.");
858 double tmp_wall_time = this->_internal_wall_time();
859 ::uint64_t raw_wall_time;
860 memcpy(&raw_wall_time, &tmp_wall_time, sizeof(tmp_wall_time));
861 if (raw_wall_time != 0) {
862 total_size += 1 + 8;
863 }
864
865 // int64 step = 2;
866 if (this->_internal_step() != 0) {
867 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_step());
868 }
869
870 switch (what_case()) {
871 // string file_version = 3;
872 case kFileVersion: {
873 total_size += 1 +
874 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
875 this->_internal_file_version());
876 break;
877 }
878 // bytes graph_def = 4;
879 case kGraphDef: {
880 total_size += 1 +
881 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
882 this->_internal_graph_def());
883 break;
884 }
885 // .tensorflow.Summary summary = 5;
886 case kSummary: {
887 total_size += 1 +
888 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
889 *_impl_.what_.summary_);
890 break;
891 }
892 // .tensorflow.LogMessage log_message = 6 [deprecated = true];
893 case kLogMessage: {
894 total_size += 1 +
895 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
896 *_impl_.what_.log_message_);
897 break;
898 }
899 // .tensorflow.SessionLog session_log = 7;
900 case kSessionLog: {
901 total_size += 1 +
902 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
903 *_impl_.what_.session_log_);
904 break;
905 }
906 // .tensorflow.TaggedRunMetadata tagged_run_metadata = 8;
907 case kTaggedRunMetadata: {
908 total_size += 1 +
909 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
910 *_impl_.what_.tagged_run_metadata_);
911 break;
912 }
913 // bytes meta_graph_def = 9;
914 case kMetaGraphDef: {
915 total_size += 1 +
916 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
917 this->_internal_meta_graph_def());
918 break;
919 }
920 case WHAT_NOT_SET: {
921 break;
922 }
923 }
924 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
925 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
926 }
927 int cached_size = ::_pbi::ToCachedSize(total_size);
928 SetCachedSize(cached_size);
929 return total_size;
930 }
931
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)932 void Event::CheckTypeAndMergeFrom(
933 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
934 MergeFrom(*::_pbi::DownCast<const Event*>(
935 &from));
936 }
937
MergeFrom(const Event & from)938 void Event::MergeFrom(const Event& from) {
939 Event* const _this = this;
940 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.Event)
941 GOOGLE_DCHECK_NE(&from, _this);
942 ::uint32_t cached_has_bits = 0;
943 (void) cached_has_bits;
944
945 static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size.");
946 double tmp_wall_time = from._internal_wall_time();
947 ::uint64_t raw_wall_time;
948 memcpy(&raw_wall_time, &tmp_wall_time, sizeof(tmp_wall_time));
949 if (raw_wall_time != 0) {
950 _this->_internal_set_wall_time(from._internal_wall_time());
951 }
952 if (from._internal_step() != 0) {
953 _this->_internal_set_step(from._internal_step());
954 }
955 switch (from.what_case()) {
956 case kFileVersion: {
957 _this->_internal_set_file_version(from._internal_file_version());
958 break;
959 }
960 case kGraphDef: {
961 _this->_internal_set_graph_def(from._internal_graph_def());
962 break;
963 }
964 case kSummary: {
965 _this->_internal_mutable_summary()->::tensorflow::Summary::MergeFrom(
966 from._internal_summary());
967 break;
968 }
969 case kLogMessage: {
970 _this->_internal_mutable_log_message()->::tensorflow::LogMessage::MergeFrom(
971 from._internal_log_message());
972 break;
973 }
974 case kSessionLog: {
975 _this->_internal_mutable_session_log()->::tensorflow::SessionLog::MergeFrom(
976 from._internal_session_log());
977 break;
978 }
979 case kTaggedRunMetadata: {
980 _this->_internal_mutable_tagged_run_metadata()->::tensorflow::TaggedRunMetadata::MergeFrom(
981 from._internal_tagged_run_metadata());
982 break;
983 }
984 case kMetaGraphDef: {
985 _this->_internal_set_meta_graph_def(from._internal_meta_graph_def());
986 break;
987 }
988 case WHAT_NOT_SET: {
989 break;
990 }
991 }
992 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
993 }
994
CopyFrom(const Event & from)995 void Event::CopyFrom(const Event& from) {
996 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.Event)
997 if (&from == this) return;
998 Clear();
999 MergeFrom(from);
1000 }
1001
IsInitialized() const1002 bool Event::IsInitialized() const {
1003 return true;
1004 }
1005
InternalSwap(Event * other)1006 void Event::InternalSwap(Event* other) {
1007 using std::swap;
1008 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1009 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1010 PROTOBUF_FIELD_OFFSET(Event, _impl_.step_)
1011 + sizeof(Event::_impl_.step_) // NOLINT
1012 - PROTOBUF_FIELD_OFFSET(Event, _impl_.wall_time_)>(
1013 reinterpret_cast<char*>(&_impl_.wall_time_),
1014 reinterpret_cast<char*>(&other->_impl_.wall_time_));
1015 swap(_impl_.what_, other->_impl_.what_);
1016 swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
1017 }
1018
GetTypeName() const1019 std::string Event::GetTypeName() const {
1020 return "tensorflow.Event";
1021 }
1022
1023
1024 // ===================================================================
1025
1026 class LogMessage::_Internal {
1027 public:
1028 };
1029
LogMessage(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1030 LogMessage::LogMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1031 bool is_message_owned)
1032 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1033 SharedCtor(arena, is_message_owned);
1034 // @@protoc_insertion_point(arena_constructor:tensorflow.LogMessage)
1035 }
LogMessage(const LogMessage & from)1036 LogMessage::LogMessage(const LogMessage& from)
1037 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1038 LogMessage* const _this = this; (void)_this;
1039 new (&_impl_) Impl_{
1040 decltype(_impl_.message_){}
1041 , decltype(_impl_.level_){}
1042 , /*decltype(_impl_._cached_size_)*/{}};
1043
1044 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1045 _impl_.message_.InitDefault();
1046 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1047 _impl_.message_.Set("", GetArenaForAllocation());
1048 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1049 if (!from._internal_message().empty()) {
1050 _this->_impl_.message_.Set(from._internal_message(),
1051 _this->GetArenaForAllocation());
1052 }
1053 _this->_impl_.level_ = from._impl_.level_;
1054 // @@protoc_insertion_point(copy_constructor:tensorflow.LogMessage)
1055 }
1056
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1057 inline void LogMessage::SharedCtor(
1058 ::_pb::Arena* arena, bool is_message_owned) {
1059 (void)arena;
1060 (void)is_message_owned;
1061 new (&_impl_) Impl_{
1062 decltype(_impl_.message_){}
1063 , decltype(_impl_.level_){0}
1064 , /*decltype(_impl_._cached_size_)*/{}
1065 };
1066 _impl_.message_.InitDefault();
1067 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1068 _impl_.message_.Set("", GetArenaForAllocation());
1069 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1070 }
1071
~LogMessage()1072 LogMessage::~LogMessage() {
1073 // @@protoc_insertion_point(destructor:tensorflow.LogMessage)
1074 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1075 (void)arena;
1076 return;
1077 }
1078 SharedDtor();
1079 }
1080
SharedDtor()1081 inline void LogMessage::SharedDtor() {
1082 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1083 _impl_.message_.Destroy();
1084 }
1085
SetCachedSize(int size) const1086 void LogMessage::SetCachedSize(int size) const {
1087 _impl_._cached_size_.Set(size);
1088 }
1089
Clear()1090 void LogMessage::Clear() {
1091 // @@protoc_insertion_point(message_clear_start:tensorflow.LogMessage)
1092 ::uint32_t cached_has_bits = 0;
1093 // Prevent compiler warnings about cached_has_bits being unused
1094 (void) cached_has_bits;
1095
1096 _impl_.message_.ClearToEmpty();
1097 _impl_.level_ = 0;
1098 _internal_metadata_.Clear<std::string>();
1099 }
1100
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1101 const char* LogMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1102 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1103 while (!ctx->Done(&ptr)) {
1104 ::uint32_t tag;
1105 ptr = ::_pbi::ReadTag(ptr, &tag);
1106 switch (tag >> 3) {
1107 // .tensorflow.LogMessage.Level level = 1;
1108 case 1:
1109 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1110 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1111 CHK_(ptr);
1112 _internal_set_level(static_cast<::tensorflow::LogMessage_Level>(val));
1113 } else {
1114 goto handle_unusual;
1115 }
1116 continue;
1117 // string message = 2;
1118 case 2:
1119 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1120 auto str = _internal_mutable_message();
1121 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1122 CHK_(ptr);
1123 CHK_(::_pbi::VerifyUTF8(str, nullptr));
1124 } else {
1125 goto handle_unusual;
1126 }
1127 continue;
1128 default:
1129 goto handle_unusual;
1130 } // switch
1131 handle_unusual:
1132 if ((tag == 0) || ((tag & 7) == 4)) {
1133 CHK_(ptr);
1134 ctx->SetLastTag(tag);
1135 goto message_done;
1136 }
1137 ptr = UnknownFieldParse(
1138 tag,
1139 _internal_metadata_.mutable_unknown_fields<std::string>(),
1140 ptr, ctx);
1141 CHK_(ptr != nullptr);
1142 } // while
1143 message_done:
1144 return ptr;
1145 failure:
1146 ptr = nullptr;
1147 goto message_done;
1148 #undef CHK_
1149 }
1150
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1151 ::uint8_t* LogMessage::_InternalSerialize(
1152 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1153 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.LogMessage)
1154 ::uint32_t cached_has_bits = 0;
1155 (void) cached_has_bits;
1156
1157 // .tensorflow.LogMessage.Level level = 1;
1158 if (this->_internal_level() != 0) {
1159 target = stream->EnsureSpace(target);
1160 target = ::_pbi::WireFormatLite::WriteEnumToArray(
1161 1, this->_internal_level(), target);
1162 }
1163
1164 // string message = 2;
1165 if (!this->_internal_message().empty()) {
1166 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1167 this->_internal_message().data(), static_cast<int>(this->_internal_message().length()),
1168 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1169 "tensorflow.LogMessage.message");
1170 target = stream->WriteStringMaybeAliased(
1171 2, this->_internal_message(), target);
1172 }
1173
1174 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1175 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1176 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1177 }
1178 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.LogMessage)
1179 return target;
1180 }
1181
ByteSizeLong() const1182 size_t LogMessage::ByteSizeLong() const {
1183 // @@protoc_insertion_point(message_byte_size_start:tensorflow.LogMessage)
1184 size_t total_size = 0;
1185
1186 ::uint32_t cached_has_bits = 0;
1187 // Prevent compiler warnings about cached_has_bits being unused
1188 (void) cached_has_bits;
1189
1190 // string message = 2;
1191 if (!this->_internal_message().empty()) {
1192 total_size += 1 +
1193 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1194 this->_internal_message());
1195 }
1196
1197 // .tensorflow.LogMessage.Level level = 1;
1198 if (this->_internal_level() != 0) {
1199 total_size += 1 +
1200 ::_pbi::WireFormatLite::EnumSize(this->_internal_level());
1201 }
1202
1203 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1204 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1205 }
1206 int cached_size = ::_pbi::ToCachedSize(total_size);
1207 SetCachedSize(cached_size);
1208 return total_size;
1209 }
1210
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1211 void LogMessage::CheckTypeAndMergeFrom(
1212 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1213 MergeFrom(*::_pbi::DownCast<const LogMessage*>(
1214 &from));
1215 }
1216
MergeFrom(const LogMessage & from)1217 void LogMessage::MergeFrom(const LogMessage& from) {
1218 LogMessage* const _this = this;
1219 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.LogMessage)
1220 GOOGLE_DCHECK_NE(&from, _this);
1221 ::uint32_t cached_has_bits = 0;
1222 (void) cached_has_bits;
1223
1224 if (!from._internal_message().empty()) {
1225 _this->_internal_set_message(from._internal_message());
1226 }
1227 if (from._internal_level() != 0) {
1228 _this->_internal_set_level(from._internal_level());
1229 }
1230 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1231 }
1232
CopyFrom(const LogMessage & from)1233 void LogMessage::CopyFrom(const LogMessage& from) {
1234 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.LogMessage)
1235 if (&from == this) return;
1236 Clear();
1237 MergeFrom(from);
1238 }
1239
IsInitialized() const1240 bool LogMessage::IsInitialized() const {
1241 return true;
1242 }
1243
InternalSwap(LogMessage * other)1244 void LogMessage::InternalSwap(LogMessage* other) {
1245 using std::swap;
1246 auto* lhs_arena = GetArenaForAllocation();
1247 auto* rhs_arena = other->GetArenaForAllocation();
1248 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1249 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1250 &_impl_.message_, lhs_arena,
1251 &other->_impl_.message_, rhs_arena
1252 );
1253 swap(_impl_.level_, other->_impl_.level_);
1254 }
1255
GetTypeName() const1256 std::string LogMessage::GetTypeName() const {
1257 return "tensorflow.LogMessage";
1258 }
1259
1260
1261 // ===================================================================
1262
1263 class SessionLog::_Internal {
1264 public:
1265 };
1266
SessionLog(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1267 SessionLog::SessionLog(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1268 bool is_message_owned)
1269 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1270 SharedCtor(arena, is_message_owned);
1271 // @@protoc_insertion_point(arena_constructor:tensorflow.SessionLog)
1272 }
SessionLog(const SessionLog & from)1273 SessionLog::SessionLog(const SessionLog& from)
1274 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1275 SessionLog* const _this = this; (void)_this;
1276 new (&_impl_) Impl_{
1277 decltype(_impl_.checkpoint_path_){}
1278 , decltype(_impl_.msg_){}
1279 , decltype(_impl_.status_){}
1280 , /*decltype(_impl_._cached_size_)*/{}};
1281
1282 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1283 _impl_.checkpoint_path_.InitDefault();
1284 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1285 _impl_.checkpoint_path_.Set("", GetArenaForAllocation());
1286 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1287 if (!from._internal_checkpoint_path().empty()) {
1288 _this->_impl_.checkpoint_path_.Set(from._internal_checkpoint_path(),
1289 _this->GetArenaForAllocation());
1290 }
1291 _impl_.msg_.InitDefault();
1292 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1293 _impl_.msg_.Set("", GetArenaForAllocation());
1294 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1295 if (!from._internal_msg().empty()) {
1296 _this->_impl_.msg_.Set(from._internal_msg(),
1297 _this->GetArenaForAllocation());
1298 }
1299 _this->_impl_.status_ = from._impl_.status_;
1300 // @@protoc_insertion_point(copy_constructor:tensorflow.SessionLog)
1301 }
1302
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1303 inline void SessionLog::SharedCtor(
1304 ::_pb::Arena* arena, bool is_message_owned) {
1305 (void)arena;
1306 (void)is_message_owned;
1307 new (&_impl_) Impl_{
1308 decltype(_impl_.checkpoint_path_){}
1309 , decltype(_impl_.msg_){}
1310 , decltype(_impl_.status_){0}
1311 , /*decltype(_impl_._cached_size_)*/{}
1312 };
1313 _impl_.checkpoint_path_.InitDefault();
1314 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1315 _impl_.checkpoint_path_.Set("", GetArenaForAllocation());
1316 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1317 _impl_.msg_.InitDefault();
1318 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1319 _impl_.msg_.Set("", GetArenaForAllocation());
1320 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1321 }
1322
~SessionLog()1323 SessionLog::~SessionLog() {
1324 // @@protoc_insertion_point(destructor:tensorflow.SessionLog)
1325 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1326 (void)arena;
1327 return;
1328 }
1329 SharedDtor();
1330 }
1331
SharedDtor()1332 inline void SessionLog::SharedDtor() {
1333 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1334 _impl_.checkpoint_path_.Destroy();
1335 _impl_.msg_.Destroy();
1336 }
1337
SetCachedSize(int size) const1338 void SessionLog::SetCachedSize(int size) const {
1339 _impl_._cached_size_.Set(size);
1340 }
1341
Clear()1342 void SessionLog::Clear() {
1343 // @@protoc_insertion_point(message_clear_start:tensorflow.SessionLog)
1344 ::uint32_t cached_has_bits = 0;
1345 // Prevent compiler warnings about cached_has_bits being unused
1346 (void) cached_has_bits;
1347
1348 _impl_.checkpoint_path_.ClearToEmpty();
1349 _impl_.msg_.ClearToEmpty();
1350 _impl_.status_ = 0;
1351 _internal_metadata_.Clear<std::string>();
1352 }
1353
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1354 const char* SessionLog::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1355 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1356 while (!ctx->Done(&ptr)) {
1357 ::uint32_t tag;
1358 ptr = ::_pbi::ReadTag(ptr, &tag);
1359 switch (tag >> 3) {
1360 // .tensorflow.SessionLog.SessionStatus status = 1;
1361 case 1:
1362 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1363 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1364 CHK_(ptr);
1365 _internal_set_status(static_cast<::tensorflow::SessionLog_SessionStatus>(val));
1366 } else {
1367 goto handle_unusual;
1368 }
1369 continue;
1370 // string checkpoint_path = 2;
1371 case 2:
1372 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1373 auto str = _internal_mutable_checkpoint_path();
1374 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1375 CHK_(ptr);
1376 CHK_(::_pbi::VerifyUTF8(str, nullptr));
1377 } else {
1378 goto handle_unusual;
1379 }
1380 continue;
1381 // string msg = 3;
1382 case 3:
1383 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
1384 auto str = _internal_mutable_msg();
1385 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1386 CHK_(ptr);
1387 CHK_(::_pbi::VerifyUTF8(str, nullptr));
1388 } else {
1389 goto handle_unusual;
1390 }
1391 continue;
1392 default:
1393 goto handle_unusual;
1394 } // switch
1395 handle_unusual:
1396 if ((tag == 0) || ((tag & 7) == 4)) {
1397 CHK_(ptr);
1398 ctx->SetLastTag(tag);
1399 goto message_done;
1400 }
1401 ptr = UnknownFieldParse(
1402 tag,
1403 _internal_metadata_.mutable_unknown_fields<std::string>(),
1404 ptr, ctx);
1405 CHK_(ptr != nullptr);
1406 } // while
1407 message_done:
1408 return ptr;
1409 failure:
1410 ptr = nullptr;
1411 goto message_done;
1412 #undef CHK_
1413 }
1414
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1415 ::uint8_t* SessionLog::_InternalSerialize(
1416 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1417 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.SessionLog)
1418 ::uint32_t cached_has_bits = 0;
1419 (void) cached_has_bits;
1420
1421 // .tensorflow.SessionLog.SessionStatus status = 1;
1422 if (this->_internal_status() != 0) {
1423 target = stream->EnsureSpace(target);
1424 target = ::_pbi::WireFormatLite::WriteEnumToArray(
1425 1, this->_internal_status(), target);
1426 }
1427
1428 // string checkpoint_path = 2;
1429 if (!this->_internal_checkpoint_path().empty()) {
1430 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1431 this->_internal_checkpoint_path().data(), static_cast<int>(this->_internal_checkpoint_path().length()),
1432 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1433 "tensorflow.SessionLog.checkpoint_path");
1434 target = stream->WriteStringMaybeAliased(
1435 2, this->_internal_checkpoint_path(), target);
1436 }
1437
1438 // string msg = 3;
1439 if (!this->_internal_msg().empty()) {
1440 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1441 this->_internal_msg().data(), static_cast<int>(this->_internal_msg().length()),
1442 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1443 "tensorflow.SessionLog.msg");
1444 target = stream->WriteStringMaybeAliased(
1445 3, this->_internal_msg(), target);
1446 }
1447
1448 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1449 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1450 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1451 }
1452 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.SessionLog)
1453 return target;
1454 }
1455
ByteSizeLong() const1456 size_t SessionLog::ByteSizeLong() const {
1457 // @@protoc_insertion_point(message_byte_size_start:tensorflow.SessionLog)
1458 size_t total_size = 0;
1459
1460 ::uint32_t cached_has_bits = 0;
1461 // Prevent compiler warnings about cached_has_bits being unused
1462 (void) cached_has_bits;
1463
1464 // string checkpoint_path = 2;
1465 if (!this->_internal_checkpoint_path().empty()) {
1466 total_size += 1 +
1467 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1468 this->_internal_checkpoint_path());
1469 }
1470
1471 // string msg = 3;
1472 if (!this->_internal_msg().empty()) {
1473 total_size += 1 +
1474 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1475 this->_internal_msg());
1476 }
1477
1478 // .tensorflow.SessionLog.SessionStatus status = 1;
1479 if (this->_internal_status() != 0) {
1480 total_size += 1 +
1481 ::_pbi::WireFormatLite::EnumSize(this->_internal_status());
1482 }
1483
1484 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1485 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1486 }
1487 int cached_size = ::_pbi::ToCachedSize(total_size);
1488 SetCachedSize(cached_size);
1489 return total_size;
1490 }
1491
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1492 void SessionLog::CheckTypeAndMergeFrom(
1493 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1494 MergeFrom(*::_pbi::DownCast<const SessionLog*>(
1495 &from));
1496 }
1497
MergeFrom(const SessionLog & from)1498 void SessionLog::MergeFrom(const SessionLog& from) {
1499 SessionLog* const _this = this;
1500 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.SessionLog)
1501 GOOGLE_DCHECK_NE(&from, _this);
1502 ::uint32_t cached_has_bits = 0;
1503 (void) cached_has_bits;
1504
1505 if (!from._internal_checkpoint_path().empty()) {
1506 _this->_internal_set_checkpoint_path(from._internal_checkpoint_path());
1507 }
1508 if (!from._internal_msg().empty()) {
1509 _this->_internal_set_msg(from._internal_msg());
1510 }
1511 if (from._internal_status() != 0) {
1512 _this->_internal_set_status(from._internal_status());
1513 }
1514 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1515 }
1516
CopyFrom(const SessionLog & from)1517 void SessionLog::CopyFrom(const SessionLog& from) {
1518 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.SessionLog)
1519 if (&from == this) return;
1520 Clear();
1521 MergeFrom(from);
1522 }
1523
IsInitialized() const1524 bool SessionLog::IsInitialized() const {
1525 return true;
1526 }
1527
InternalSwap(SessionLog * other)1528 void SessionLog::InternalSwap(SessionLog* other) {
1529 using std::swap;
1530 auto* lhs_arena = GetArenaForAllocation();
1531 auto* rhs_arena = other->GetArenaForAllocation();
1532 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1533 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1534 &_impl_.checkpoint_path_, lhs_arena,
1535 &other->_impl_.checkpoint_path_, rhs_arena
1536 );
1537 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1538 &_impl_.msg_, lhs_arena,
1539 &other->_impl_.msg_, rhs_arena
1540 );
1541 swap(_impl_.status_, other->_impl_.status_);
1542 }
1543
GetTypeName() const1544 std::string SessionLog::GetTypeName() const {
1545 return "tensorflow.SessionLog";
1546 }
1547
1548
1549 // ===================================================================
1550
1551 class TaggedRunMetadata::_Internal {
1552 public:
1553 };
1554
TaggedRunMetadata(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1555 TaggedRunMetadata::TaggedRunMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1556 bool is_message_owned)
1557 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1558 SharedCtor(arena, is_message_owned);
1559 // @@protoc_insertion_point(arena_constructor:tensorflow.TaggedRunMetadata)
1560 }
TaggedRunMetadata(const TaggedRunMetadata & from)1561 TaggedRunMetadata::TaggedRunMetadata(const TaggedRunMetadata& from)
1562 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1563 TaggedRunMetadata* const _this = this; (void)_this;
1564 new (&_impl_) Impl_{
1565 decltype(_impl_.tag_){}
1566 , decltype(_impl_.run_metadata_){}
1567 , /*decltype(_impl_._cached_size_)*/{}};
1568
1569 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1570 _impl_.tag_.InitDefault();
1571 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1572 _impl_.tag_.Set("", GetArenaForAllocation());
1573 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1574 if (!from._internal_tag().empty()) {
1575 _this->_impl_.tag_.Set(from._internal_tag(),
1576 _this->GetArenaForAllocation());
1577 }
1578 _impl_.run_metadata_.InitDefault();
1579 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1580 _impl_.run_metadata_.Set("", GetArenaForAllocation());
1581 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1582 if (!from._internal_run_metadata().empty()) {
1583 _this->_impl_.run_metadata_.Set(from._internal_run_metadata(),
1584 _this->GetArenaForAllocation());
1585 }
1586 // @@protoc_insertion_point(copy_constructor:tensorflow.TaggedRunMetadata)
1587 }
1588
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1589 inline void TaggedRunMetadata::SharedCtor(
1590 ::_pb::Arena* arena, bool is_message_owned) {
1591 (void)arena;
1592 (void)is_message_owned;
1593 new (&_impl_) Impl_{
1594 decltype(_impl_.tag_){}
1595 , decltype(_impl_.run_metadata_){}
1596 , /*decltype(_impl_._cached_size_)*/{}
1597 };
1598 _impl_.tag_.InitDefault();
1599 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1600 _impl_.tag_.Set("", GetArenaForAllocation());
1601 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1602 _impl_.run_metadata_.InitDefault();
1603 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1604 _impl_.run_metadata_.Set("", GetArenaForAllocation());
1605 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1606 }
1607
~TaggedRunMetadata()1608 TaggedRunMetadata::~TaggedRunMetadata() {
1609 // @@protoc_insertion_point(destructor:tensorflow.TaggedRunMetadata)
1610 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1611 (void)arena;
1612 return;
1613 }
1614 SharedDtor();
1615 }
1616
SharedDtor()1617 inline void TaggedRunMetadata::SharedDtor() {
1618 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1619 _impl_.tag_.Destroy();
1620 _impl_.run_metadata_.Destroy();
1621 }
1622
SetCachedSize(int size) const1623 void TaggedRunMetadata::SetCachedSize(int size) const {
1624 _impl_._cached_size_.Set(size);
1625 }
1626
Clear()1627 void TaggedRunMetadata::Clear() {
1628 // @@protoc_insertion_point(message_clear_start:tensorflow.TaggedRunMetadata)
1629 ::uint32_t cached_has_bits = 0;
1630 // Prevent compiler warnings about cached_has_bits being unused
1631 (void) cached_has_bits;
1632
1633 _impl_.tag_.ClearToEmpty();
1634 _impl_.run_metadata_.ClearToEmpty();
1635 _internal_metadata_.Clear<std::string>();
1636 }
1637
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1638 const char* TaggedRunMetadata::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1639 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1640 while (!ctx->Done(&ptr)) {
1641 ::uint32_t tag;
1642 ptr = ::_pbi::ReadTag(ptr, &tag);
1643 switch (tag >> 3) {
1644 // string tag = 1;
1645 case 1:
1646 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1647 auto str = _internal_mutable_tag();
1648 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1649 CHK_(ptr);
1650 CHK_(::_pbi::VerifyUTF8(str, nullptr));
1651 } else {
1652 goto handle_unusual;
1653 }
1654 continue;
1655 // bytes run_metadata = 2;
1656 case 2:
1657 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1658 auto str = _internal_mutable_run_metadata();
1659 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1660 CHK_(ptr);
1661 } else {
1662 goto handle_unusual;
1663 }
1664 continue;
1665 default:
1666 goto handle_unusual;
1667 } // switch
1668 handle_unusual:
1669 if ((tag == 0) || ((tag & 7) == 4)) {
1670 CHK_(ptr);
1671 ctx->SetLastTag(tag);
1672 goto message_done;
1673 }
1674 ptr = UnknownFieldParse(
1675 tag,
1676 _internal_metadata_.mutable_unknown_fields<std::string>(),
1677 ptr, ctx);
1678 CHK_(ptr != nullptr);
1679 } // while
1680 message_done:
1681 return ptr;
1682 failure:
1683 ptr = nullptr;
1684 goto message_done;
1685 #undef CHK_
1686 }
1687
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1688 ::uint8_t* TaggedRunMetadata::_InternalSerialize(
1689 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1690 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.TaggedRunMetadata)
1691 ::uint32_t cached_has_bits = 0;
1692 (void) cached_has_bits;
1693
1694 // string tag = 1;
1695 if (!this->_internal_tag().empty()) {
1696 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1697 this->_internal_tag().data(), static_cast<int>(this->_internal_tag().length()),
1698 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1699 "tensorflow.TaggedRunMetadata.tag");
1700 target = stream->WriteStringMaybeAliased(
1701 1, this->_internal_tag(), target);
1702 }
1703
1704 // bytes run_metadata = 2;
1705 if (!this->_internal_run_metadata().empty()) {
1706 target = stream->WriteBytesMaybeAliased(
1707 2, this->_internal_run_metadata(), target);
1708 }
1709
1710 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1711 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1712 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1713 }
1714 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.TaggedRunMetadata)
1715 return target;
1716 }
1717
ByteSizeLong() const1718 size_t TaggedRunMetadata::ByteSizeLong() const {
1719 // @@protoc_insertion_point(message_byte_size_start:tensorflow.TaggedRunMetadata)
1720 size_t total_size = 0;
1721
1722 ::uint32_t cached_has_bits = 0;
1723 // Prevent compiler warnings about cached_has_bits being unused
1724 (void) cached_has_bits;
1725
1726 // string tag = 1;
1727 if (!this->_internal_tag().empty()) {
1728 total_size += 1 +
1729 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1730 this->_internal_tag());
1731 }
1732
1733 // bytes run_metadata = 2;
1734 if (!this->_internal_run_metadata().empty()) {
1735 total_size += 1 +
1736 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
1737 this->_internal_run_metadata());
1738 }
1739
1740 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1741 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1742 }
1743 int cached_size = ::_pbi::ToCachedSize(total_size);
1744 SetCachedSize(cached_size);
1745 return total_size;
1746 }
1747
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1748 void TaggedRunMetadata::CheckTypeAndMergeFrom(
1749 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1750 MergeFrom(*::_pbi::DownCast<const TaggedRunMetadata*>(
1751 &from));
1752 }
1753
MergeFrom(const TaggedRunMetadata & from)1754 void TaggedRunMetadata::MergeFrom(const TaggedRunMetadata& from) {
1755 TaggedRunMetadata* const _this = this;
1756 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.TaggedRunMetadata)
1757 GOOGLE_DCHECK_NE(&from, _this);
1758 ::uint32_t cached_has_bits = 0;
1759 (void) cached_has_bits;
1760
1761 if (!from._internal_tag().empty()) {
1762 _this->_internal_set_tag(from._internal_tag());
1763 }
1764 if (!from._internal_run_metadata().empty()) {
1765 _this->_internal_set_run_metadata(from._internal_run_metadata());
1766 }
1767 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1768 }
1769
CopyFrom(const TaggedRunMetadata & from)1770 void TaggedRunMetadata::CopyFrom(const TaggedRunMetadata& from) {
1771 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.TaggedRunMetadata)
1772 if (&from == this) return;
1773 Clear();
1774 MergeFrom(from);
1775 }
1776
IsInitialized() const1777 bool TaggedRunMetadata::IsInitialized() const {
1778 return true;
1779 }
1780
InternalSwap(TaggedRunMetadata * other)1781 void TaggedRunMetadata::InternalSwap(TaggedRunMetadata* other) {
1782 using std::swap;
1783 auto* lhs_arena = GetArenaForAllocation();
1784 auto* rhs_arena = other->GetArenaForAllocation();
1785 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1786 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1787 &_impl_.tag_, lhs_arena,
1788 &other->_impl_.tag_, rhs_arena
1789 );
1790 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1791 &_impl_.run_metadata_, lhs_arena,
1792 &other->_impl_.run_metadata_, rhs_arena
1793 );
1794 }
1795
GetTypeName() const1796 std::string TaggedRunMetadata::GetTypeName() const {
1797 return "tensorflow.TaggedRunMetadata";
1798 }
1799
1800
1801 // ===================================================================
1802
1803 class WatchdogConfig::_Internal {
1804 public:
1805 };
1806
WatchdogConfig(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1807 WatchdogConfig::WatchdogConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1808 bool is_message_owned)
1809 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1810 SharedCtor(arena, is_message_owned);
1811 // @@protoc_insertion_point(arena_constructor:tensorflow.WatchdogConfig)
1812 }
WatchdogConfig(const WatchdogConfig & from)1813 WatchdogConfig::WatchdogConfig(const WatchdogConfig& from)
1814 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1815 WatchdogConfig* const _this = this; (void)_this;
1816 new (&_impl_) Impl_{
1817 decltype(_impl_.timeout_ms_){}
1818 , /*decltype(_impl_._cached_size_)*/{}};
1819
1820 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1821 _this->_impl_.timeout_ms_ = from._impl_.timeout_ms_;
1822 // @@protoc_insertion_point(copy_constructor:tensorflow.WatchdogConfig)
1823 }
1824
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1825 inline void WatchdogConfig::SharedCtor(
1826 ::_pb::Arena* arena, bool is_message_owned) {
1827 (void)arena;
1828 (void)is_message_owned;
1829 new (&_impl_) Impl_{
1830 decltype(_impl_.timeout_ms_){::int64_t{0}}
1831 , /*decltype(_impl_._cached_size_)*/{}
1832 };
1833 }
1834
~WatchdogConfig()1835 WatchdogConfig::~WatchdogConfig() {
1836 // @@protoc_insertion_point(destructor:tensorflow.WatchdogConfig)
1837 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1838 (void)arena;
1839 return;
1840 }
1841 SharedDtor();
1842 }
1843
SharedDtor()1844 inline void WatchdogConfig::SharedDtor() {
1845 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1846 }
1847
SetCachedSize(int size) const1848 void WatchdogConfig::SetCachedSize(int size) const {
1849 _impl_._cached_size_.Set(size);
1850 }
1851
Clear()1852 void WatchdogConfig::Clear() {
1853 // @@protoc_insertion_point(message_clear_start:tensorflow.WatchdogConfig)
1854 ::uint32_t cached_has_bits = 0;
1855 // Prevent compiler warnings about cached_has_bits being unused
1856 (void) cached_has_bits;
1857
1858 _impl_.timeout_ms_ = ::int64_t{0};
1859 _internal_metadata_.Clear<std::string>();
1860 }
1861
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1862 const char* WatchdogConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1863 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1864 while (!ctx->Done(&ptr)) {
1865 ::uint32_t tag;
1866 ptr = ::_pbi::ReadTag(ptr, &tag);
1867 switch (tag >> 3) {
1868 // int64 timeout_ms = 1;
1869 case 1:
1870 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1871 _impl_.timeout_ms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1872 CHK_(ptr);
1873 } else {
1874 goto handle_unusual;
1875 }
1876 continue;
1877 default:
1878 goto handle_unusual;
1879 } // switch
1880 handle_unusual:
1881 if ((tag == 0) || ((tag & 7) == 4)) {
1882 CHK_(ptr);
1883 ctx->SetLastTag(tag);
1884 goto message_done;
1885 }
1886 ptr = UnknownFieldParse(
1887 tag,
1888 _internal_metadata_.mutable_unknown_fields<std::string>(),
1889 ptr, ctx);
1890 CHK_(ptr != nullptr);
1891 } // while
1892 message_done:
1893 return ptr;
1894 failure:
1895 ptr = nullptr;
1896 goto message_done;
1897 #undef CHK_
1898 }
1899
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1900 ::uint8_t* WatchdogConfig::_InternalSerialize(
1901 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1902 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.WatchdogConfig)
1903 ::uint32_t cached_has_bits = 0;
1904 (void) cached_has_bits;
1905
1906 // int64 timeout_ms = 1;
1907 if (this->_internal_timeout_ms() != 0) {
1908 target = stream->EnsureSpace(target);
1909 target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_timeout_ms(), target);
1910 }
1911
1912 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1913 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1914 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1915 }
1916 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.WatchdogConfig)
1917 return target;
1918 }
1919
ByteSizeLong() const1920 size_t WatchdogConfig::ByteSizeLong() const {
1921 // @@protoc_insertion_point(message_byte_size_start:tensorflow.WatchdogConfig)
1922 size_t total_size = 0;
1923
1924 ::uint32_t cached_has_bits = 0;
1925 // Prevent compiler warnings about cached_has_bits being unused
1926 (void) cached_has_bits;
1927
1928 // int64 timeout_ms = 1;
1929 if (this->_internal_timeout_ms() != 0) {
1930 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_timeout_ms());
1931 }
1932
1933 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1934 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1935 }
1936 int cached_size = ::_pbi::ToCachedSize(total_size);
1937 SetCachedSize(cached_size);
1938 return total_size;
1939 }
1940
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1941 void WatchdogConfig::CheckTypeAndMergeFrom(
1942 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1943 MergeFrom(*::_pbi::DownCast<const WatchdogConfig*>(
1944 &from));
1945 }
1946
MergeFrom(const WatchdogConfig & from)1947 void WatchdogConfig::MergeFrom(const WatchdogConfig& from) {
1948 WatchdogConfig* const _this = this;
1949 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.WatchdogConfig)
1950 GOOGLE_DCHECK_NE(&from, _this);
1951 ::uint32_t cached_has_bits = 0;
1952 (void) cached_has_bits;
1953
1954 if (from._internal_timeout_ms() != 0) {
1955 _this->_internal_set_timeout_ms(from._internal_timeout_ms());
1956 }
1957 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1958 }
1959
CopyFrom(const WatchdogConfig & from)1960 void WatchdogConfig::CopyFrom(const WatchdogConfig& from) {
1961 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.WatchdogConfig)
1962 if (&from == this) return;
1963 Clear();
1964 MergeFrom(from);
1965 }
1966
IsInitialized() const1967 bool WatchdogConfig::IsInitialized() const {
1968 return true;
1969 }
1970
InternalSwap(WatchdogConfig * other)1971 void WatchdogConfig::InternalSwap(WatchdogConfig* other) {
1972 using std::swap;
1973 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1974 swap(_impl_.timeout_ms_, other->_impl_.timeout_ms_);
1975 }
1976
GetTypeName() const1977 std::string WatchdogConfig::GetTypeName() const {
1978 return "tensorflow.WatchdogConfig";
1979 }
1980
1981
1982 // ===================================================================
1983
1984 class RequestedExitCode::_Internal {
1985 public:
1986 };
1987
RequestedExitCode(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1988 RequestedExitCode::RequestedExitCode(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1989 bool is_message_owned)
1990 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1991 SharedCtor(arena, is_message_owned);
1992 // @@protoc_insertion_point(arena_constructor:tensorflow.RequestedExitCode)
1993 }
RequestedExitCode(const RequestedExitCode & from)1994 RequestedExitCode::RequestedExitCode(const RequestedExitCode& from)
1995 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1996 RequestedExitCode* const _this = this; (void)_this;
1997 new (&_impl_) Impl_{
1998 decltype(_impl_.exit_code_){}
1999 , /*decltype(_impl_._cached_size_)*/{}};
2000
2001 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2002 _this->_impl_.exit_code_ = from._impl_.exit_code_;
2003 // @@protoc_insertion_point(copy_constructor:tensorflow.RequestedExitCode)
2004 }
2005
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2006 inline void RequestedExitCode::SharedCtor(
2007 ::_pb::Arena* arena, bool is_message_owned) {
2008 (void)arena;
2009 (void)is_message_owned;
2010 new (&_impl_) Impl_{
2011 decltype(_impl_.exit_code_){0}
2012 , /*decltype(_impl_._cached_size_)*/{}
2013 };
2014 }
2015
~RequestedExitCode()2016 RequestedExitCode::~RequestedExitCode() {
2017 // @@protoc_insertion_point(destructor:tensorflow.RequestedExitCode)
2018 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2019 (void)arena;
2020 return;
2021 }
2022 SharedDtor();
2023 }
2024
SharedDtor()2025 inline void RequestedExitCode::SharedDtor() {
2026 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2027 }
2028
SetCachedSize(int size) const2029 void RequestedExitCode::SetCachedSize(int size) const {
2030 _impl_._cached_size_.Set(size);
2031 }
2032
Clear()2033 void RequestedExitCode::Clear() {
2034 // @@protoc_insertion_point(message_clear_start:tensorflow.RequestedExitCode)
2035 ::uint32_t cached_has_bits = 0;
2036 // Prevent compiler warnings about cached_has_bits being unused
2037 (void) cached_has_bits;
2038
2039 _impl_.exit_code_ = 0;
2040 _internal_metadata_.Clear<std::string>();
2041 }
2042
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2043 const char* RequestedExitCode::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2044 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2045 while (!ctx->Done(&ptr)) {
2046 ::uint32_t tag;
2047 ptr = ::_pbi::ReadTag(ptr, &tag);
2048 switch (tag >> 3) {
2049 // int32 exit_code = 1;
2050 case 1:
2051 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2052 _impl_.exit_code_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2053 CHK_(ptr);
2054 } else {
2055 goto handle_unusual;
2056 }
2057 continue;
2058 default:
2059 goto handle_unusual;
2060 } // switch
2061 handle_unusual:
2062 if ((tag == 0) || ((tag & 7) == 4)) {
2063 CHK_(ptr);
2064 ctx->SetLastTag(tag);
2065 goto message_done;
2066 }
2067 ptr = UnknownFieldParse(
2068 tag,
2069 _internal_metadata_.mutable_unknown_fields<std::string>(),
2070 ptr, ctx);
2071 CHK_(ptr != nullptr);
2072 } // while
2073 message_done:
2074 return ptr;
2075 failure:
2076 ptr = nullptr;
2077 goto message_done;
2078 #undef CHK_
2079 }
2080
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2081 ::uint8_t* RequestedExitCode::_InternalSerialize(
2082 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2083 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.RequestedExitCode)
2084 ::uint32_t cached_has_bits = 0;
2085 (void) cached_has_bits;
2086
2087 // int32 exit_code = 1;
2088 if (this->_internal_exit_code() != 0) {
2089 target = stream->EnsureSpace(target);
2090 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_exit_code(), target);
2091 }
2092
2093 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2094 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2095 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2096 }
2097 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.RequestedExitCode)
2098 return target;
2099 }
2100
ByteSizeLong() const2101 size_t RequestedExitCode::ByteSizeLong() const {
2102 // @@protoc_insertion_point(message_byte_size_start:tensorflow.RequestedExitCode)
2103 size_t total_size = 0;
2104
2105 ::uint32_t cached_has_bits = 0;
2106 // Prevent compiler warnings about cached_has_bits being unused
2107 (void) cached_has_bits;
2108
2109 // int32 exit_code = 1;
2110 if (this->_internal_exit_code() != 0) {
2111 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_exit_code());
2112 }
2113
2114 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2115 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2116 }
2117 int cached_size = ::_pbi::ToCachedSize(total_size);
2118 SetCachedSize(cached_size);
2119 return total_size;
2120 }
2121
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2122 void RequestedExitCode::CheckTypeAndMergeFrom(
2123 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2124 MergeFrom(*::_pbi::DownCast<const RequestedExitCode*>(
2125 &from));
2126 }
2127
MergeFrom(const RequestedExitCode & from)2128 void RequestedExitCode::MergeFrom(const RequestedExitCode& from) {
2129 RequestedExitCode* const _this = this;
2130 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.RequestedExitCode)
2131 GOOGLE_DCHECK_NE(&from, _this);
2132 ::uint32_t cached_has_bits = 0;
2133 (void) cached_has_bits;
2134
2135 if (from._internal_exit_code() != 0) {
2136 _this->_internal_set_exit_code(from._internal_exit_code());
2137 }
2138 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2139 }
2140
CopyFrom(const RequestedExitCode & from)2141 void RequestedExitCode::CopyFrom(const RequestedExitCode& from) {
2142 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.RequestedExitCode)
2143 if (&from == this) return;
2144 Clear();
2145 MergeFrom(from);
2146 }
2147
IsInitialized() const2148 bool RequestedExitCode::IsInitialized() const {
2149 return true;
2150 }
2151
InternalSwap(RequestedExitCode * other)2152 void RequestedExitCode::InternalSwap(RequestedExitCode* other) {
2153 using std::swap;
2154 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2155 swap(_impl_.exit_code_, other->_impl_.exit_code_);
2156 }
2157
GetTypeName() const2158 std::string RequestedExitCode::GetTypeName() const {
2159 return "tensorflow.RequestedExitCode";
2160 }
2161
2162
2163 // ===================================================================
2164
2165 class WorkerHeartbeatRequest::_Internal {
2166 public:
2167 static const ::tensorflow::WatchdogConfig& watchdog_config(const WorkerHeartbeatRequest* msg);
2168 static const ::tensorflow::RequestedExitCode& exit_code(const WorkerHeartbeatRequest* msg);
2169 };
2170
2171 const ::tensorflow::WatchdogConfig&
watchdog_config(const WorkerHeartbeatRequest * msg)2172 WorkerHeartbeatRequest::_Internal::watchdog_config(const WorkerHeartbeatRequest* msg) {
2173 return *msg->_impl_.watchdog_config_;
2174 }
2175 const ::tensorflow::RequestedExitCode&
exit_code(const WorkerHeartbeatRequest * msg)2176 WorkerHeartbeatRequest::_Internal::exit_code(const WorkerHeartbeatRequest* msg) {
2177 return *msg->_impl_.exit_code_;
2178 }
WorkerHeartbeatRequest(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2179 WorkerHeartbeatRequest::WorkerHeartbeatRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2180 bool is_message_owned)
2181 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2182 SharedCtor(arena, is_message_owned);
2183 // @@protoc_insertion_point(arena_constructor:tensorflow.WorkerHeartbeatRequest)
2184 }
WorkerHeartbeatRequest(const WorkerHeartbeatRequest & from)2185 WorkerHeartbeatRequest::WorkerHeartbeatRequest(const WorkerHeartbeatRequest& from)
2186 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2187 WorkerHeartbeatRequest* const _this = this; (void)_this;
2188 new (&_impl_) Impl_{
2189 decltype(_impl_.watchdog_config_){nullptr}
2190 , decltype(_impl_.exit_code_){nullptr}
2191 , decltype(_impl_.shutdown_mode_){}
2192 , /*decltype(_impl_._cached_size_)*/{}};
2193
2194 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2195 if (from._internal_has_watchdog_config()) {
2196 _this->_impl_.watchdog_config_ = new ::tensorflow::WatchdogConfig(*from._impl_.watchdog_config_);
2197 }
2198 if (from._internal_has_exit_code()) {
2199 _this->_impl_.exit_code_ = new ::tensorflow::RequestedExitCode(*from._impl_.exit_code_);
2200 }
2201 _this->_impl_.shutdown_mode_ = from._impl_.shutdown_mode_;
2202 // @@protoc_insertion_point(copy_constructor:tensorflow.WorkerHeartbeatRequest)
2203 }
2204
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2205 inline void WorkerHeartbeatRequest::SharedCtor(
2206 ::_pb::Arena* arena, bool is_message_owned) {
2207 (void)arena;
2208 (void)is_message_owned;
2209 new (&_impl_) Impl_{
2210 decltype(_impl_.watchdog_config_){nullptr}
2211 , decltype(_impl_.exit_code_){nullptr}
2212 , decltype(_impl_.shutdown_mode_){0}
2213 , /*decltype(_impl_._cached_size_)*/{}
2214 };
2215 }
2216
~WorkerHeartbeatRequest()2217 WorkerHeartbeatRequest::~WorkerHeartbeatRequest() {
2218 // @@protoc_insertion_point(destructor:tensorflow.WorkerHeartbeatRequest)
2219 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2220 (void)arena;
2221 return;
2222 }
2223 SharedDtor();
2224 }
2225
SharedDtor()2226 inline void WorkerHeartbeatRequest::SharedDtor() {
2227 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2228 if (this != internal_default_instance()) delete _impl_.watchdog_config_;
2229 if (this != internal_default_instance()) delete _impl_.exit_code_;
2230 }
2231
SetCachedSize(int size) const2232 void WorkerHeartbeatRequest::SetCachedSize(int size) const {
2233 _impl_._cached_size_.Set(size);
2234 }
2235
Clear()2236 void WorkerHeartbeatRequest::Clear() {
2237 // @@protoc_insertion_point(message_clear_start:tensorflow.WorkerHeartbeatRequest)
2238 ::uint32_t cached_has_bits = 0;
2239 // Prevent compiler warnings about cached_has_bits being unused
2240 (void) cached_has_bits;
2241
2242 if (GetArenaForAllocation() == nullptr && _impl_.watchdog_config_ != nullptr) {
2243 delete _impl_.watchdog_config_;
2244 }
2245 _impl_.watchdog_config_ = nullptr;
2246 if (GetArenaForAllocation() == nullptr && _impl_.exit_code_ != nullptr) {
2247 delete _impl_.exit_code_;
2248 }
2249 _impl_.exit_code_ = nullptr;
2250 _impl_.shutdown_mode_ = 0;
2251 _internal_metadata_.Clear<std::string>();
2252 }
2253
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2254 const char* WorkerHeartbeatRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2255 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2256 while (!ctx->Done(&ptr)) {
2257 ::uint32_t tag;
2258 ptr = ::_pbi::ReadTag(ptr, &tag);
2259 switch (tag >> 3) {
2260 // .tensorflow.WorkerShutdownMode shutdown_mode = 1;
2261 case 1:
2262 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2263 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2264 CHK_(ptr);
2265 _internal_set_shutdown_mode(static_cast<::tensorflow::WorkerShutdownMode>(val));
2266 } else {
2267 goto handle_unusual;
2268 }
2269 continue;
2270 // .tensorflow.WatchdogConfig watchdog_config = 2;
2271 case 2:
2272 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
2273 ptr = ctx->ParseMessage(_internal_mutable_watchdog_config(), ptr);
2274 CHK_(ptr);
2275 } else {
2276 goto handle_unusual;
2277 }
2278 continue;
2279 // .tensorflow.RequestedExitCode exit_code = 3;
2280 case 3:
2281 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
2282 ptr = ctx->ParseMessage(_internal_mutable_exit_code(), ptr);
2283 CHK_(ptr);
2284 } else {
2285 goto handle_unusual;
2286 }
2287 continue;
2288 default:
2289 goto handle_unusual;
2290 } // switch
2291 handle_unusual:
2292 if ((tag == 0) || ((tag & 7) == 4)) {
2293 CHK_(ptr);
2294 ctx->SetLastTag(tag);
2295 goto message_done;
2296 }
2297 ptr = UnknownFieldParse(
2298 tag,
2299 _internal_metadata_.mutable_unknown_fields<std::string>(),
2300 ptr, ctx);
2301 CHK_(ptr != nullptr);
2302 } // while
2303 message_done:
2304 return ptr;
2305 failure:
2306 ptr = nullptr;
2307 goto message_done;
2308 #undef CHK_
2309 }
2310
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2311 ::uint8_t* WorkerHeartbeatRequest::_InternalSerialize(
2312 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2313 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.WorkerHeartbeatRequest)
2314 ::uint32_t cached_has_bits = 0;
2315 (void) cached_has_bits;
2316
2317 // .tensorflow.WorkerShutdownMode shutdown_mode = 1;
2318 if (this->_internal_shutdown_mode() != 0) {
2319 target = stream->EnsureSpace(target);
2320 target = ::_pbi::WireFormatLite::WriteEnumToArray(
2321 1, this->_internal_shutdown_mode(), target);
2322 }
2323
2324 // .tensorflow.WatchdogConfig watchdog_config = 2;
2325 if (this->_internal_has_watchdog_config()) {
2326 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
2327 InternalWriteMessage(2, _Internal::watchdog_config(this),
2328 _Internal::watchdog_config(this).GetCachedSize(), target, stream);
2329 }
2330
2331 // .tensorflow.RequestedExitCode exit_code = 3;
2332 if (this->_internal_has_exit_code()) {
2333 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
2334 InternalWriteMessage(3, _Internal::exit_code(this),
2335 _Internal::exit_code(this).GetCachedSize(), target, stream);
2336 }
2337
2338 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2339 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2340 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2341 }
2342 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.WorkerHeartbeatRequest)
2343 return target;
2344 }
2345
ByteSizeLong() const2346 size_t WorkerHeartbeatRequest::ByteSizeLong() const {
2347 // @@protoc_insertion_point(message_byte_size_start:tensorflow.WorkerHeartbeatRequest)
2348 size_t total_size = 0;
2349
2350 ::uint32_t cached_has_bits = 0;
2351 // Prevent compiler warnings about cached_has_bits being unused
2352 (void) cached_has_bits;
2353
2354 // .tensorflow.WatchdogConfig watchdog_config = 2;
2355 if (this->_internal_has_watchdog_config()) {
2356 total_size += 1 +
2357 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
2358 *_impl_.watchdog_config_);
2359 }
2360
2361 // .tensorflow.RequestedExitCode exit_code = 3;
2362 if (this->_internal_has_exit_code()) {
2363 total_size += 1 +
2364 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
2365 *_impl_.exit_code_);
2366 }
2367
2368 // .tensorflow.WorkerShutdownMode shutdown_mode = 1;
2369 if (this->_internal_shutdown_mode() != 0) {
2370 total_size += 1 +
2371 ::_pbi::WireFormatLite::EnumSize(this->_internal_shutdown_mode());
2372 }
2373
2374 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2375 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2376 }
2377 int cached_size = ::_pbi::ToCachedSize(total_size);
2378 SetCachedSize(cached_size);
2379 return total_size;
2380 }
2381
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2382 void WorkerHeartbeatRequest::CheckTypeAndMergeFrom(
2383 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2384 MergeFrom(*::_pbi::DownCast<const WorkerHeartbeatRequest*>(
2385 &from));
2386 }
2387
MergeFrom(const WorkerHeartbeatRequest & from)2388 void WorkerHeartbeatRequest::MergeFrom(const WorkerHeartbeatRequest& from) {
2389 WorkerHeartbeatRequest* const _this = this;
2390 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.WorkerHeartbeatRequest)
2391 GOOGLE_DCHECK_NE(&from, _this);
2392 ::uint32_t cached_has_bits = 0;
2393 (void) cached_has_bits;
2394
2395 if (from._internal_has_watchdog_config()) {
2396 _this->_internal_mutable_watchdog_config()->::tensorflow::WatchdogConfig::MergeFrom(
2397 from._internal_watchdog_config());
2398 }
2399 if (from._internal_has_exit_code()) {
2400 _this->_internal_mutable_exit_code()->::tensorflow::RequestedExitCode::MergeFrom(
2401 from._internal_exit_code());
2402 }
2403 if (from._internal_shutdown_mode() != 0) {
2404 _this->_internal_set_shutdown_mode(from._internal_shutdown_mode());
2405 }
2406 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2407 }
2408
CopyFrom(const WorkerHeartbeatRequest & from)2409 void WorkerHeartbeatRequest::CopyFrom(const WorkerHeartbeatRequest& from) {
2410 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.WorkerHeartbeatRequest)
2411 if (&from == this) return;
2412 Clear();
2413 MergeFrom(from);
2414 }
2415
IsInitialized() const2416 bool WorkerHeartbeatRequest::IsInitialized() const {
2417 return true;
2418 }
2419
InternalSwap(WorkerHeartbeatRequest * other)2420 void WorkerHeartbeatRequest::InternalSwap(WorkerHeartbeatRequest* other) {
2421 using std::swap;
2422 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2423 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2424 PROTOBUF_FIELD_OFFSET(WorkerHeartbeatRequest, _impl_.shutdown_mode_)
2425 + sizeof(WorkerHeartbeatRequest::_impl_.shutdown_mode_) // NOLINT
2426 - PROTOBUF_FIELD_OFFSET(WorkerHeartbeatRequest, _impl_.watchdog_config_)>(
2427 reinterpret_cast<char*>(&_impl_.watchdog_config_),
2428 reinterpret_cast<char*>(&other->_impl_.watchdog_config_));
2429 }
2430
GetTypeName() const2431 std::string WorkerHeartbeatRequest::GetTypeName() const {
2432 return "tensorflow.WorkerHeartbeatRequest";
2433 }
2434
2435
2436 // ===================================================================
2437
2438 class WorkerHeartbeatResponse::_Internal {
2439 public:
2440 };
2441
WorkerHeartbeatResponse(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2442 WorkerHeartbeatResponse::WorkerHeartbeatResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2443 bool is_message_owned)
2444 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2445 SharedCtor(arena, is_message_owned);
2446 // @@protoc_insertion_point(arena_constructor:tensorflow.WorkerHeartbeatResponse)
2447 }
WorkerHeartbeatResponse(const WorkerHeartbeatResponse & from)2448 WorkerHeartbeatResponse::WorkerHeartbeatResponse(const WorkerHeartbeatResponse& from)
2449 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2450 WorkerHeartbeatResponse* const _this = this; (void)_this;
2451 new (&_impl_) Impl_{
2452 decltype(_impl_.worker_log_){from._impl_.worker_log_}
2453 , decltype(_impl_.hostname_){}
2454 , decltype(_impl_.health_status_){}
2455 , /*decltype(_impl_._cached_size_)*/{}};
2456
2457 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2458 _impl_.hostname_.InitDefault();
2459 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2460 _impl_.hostname_.Set("", GetArenaForAllocation());
2461 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2462 if (!from._internal_hostname().empty()) {
2463 _this->_impl_.hostname_.Set(from._internal_hostname(),
2464 _this->GetArenaForAllocation());
2465 }
2466 _this->_impl_.health_status_ = from._impl_.health_status_;
2467 // @@protoc_insertion_point(copy_constructor:tensorflow.WorkerHeartbeatResponse)
2468 }
2469
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2470 inline void WorkerHeartbeatResponse::SharedCtor(
2471 ::_pb::Arena* arena, bool is_message_owned) {
2472 (void)arena;
2473 (void)is_message_owned;
2474 new (&_impl_) Impl_{
2475 decltype(_impl_.worker_log_){arena}
2476 , decltype(_impl_.hostname_){}
2477 , decltype(_impl_.health_status_){0}
2478 , /*decltype(_impl_._cached_size_)*/{}
2479 };
2480 _impl_.hostname_.InitDefault();
2481 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2482 _impl_.hostname_.Set("", GetArenaForAllocation());
2483 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2484 }
2485
~WorkerHeartbeatResponse()2486 WorkerHeartbeatResponse::~WorkerHeartbeatResponse() {
2487 // @@protoc_insertion_point(destructor:tensorflow.WorkerHeartbeatResponse)
2488 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2489 (void)arena;
2490 return;
2491 }
2492 SharedDtor();
2493 }
2494
SharedDtor()2495 inline void WorkerHeartbeatResponse::SharedDtor() {
2496 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2497 _impl_.worker_log_.~RepeatedPtrField();
2498 _impl_.hostname_.Destroy();
2499 }
2500
SetCachedSize(int size) const2501 void WorkerHeartbeatResponse::SetCachedSize(int size) const {
2502 _impl_._cached_size_.Set(size);
2503 }
2504
Clear()2505 void WorkerHeartbeatResponse::Clear() {
2506 // @@protoc_insertion_point(message_clear_start:tensorflow.WorkerHeartbeatResponse)
2507 ::uint32_t cached_has_bits = 0;
2508 // Prevent compiler warnings about cached_has_bits being unused
2509 (void) cached_has_bits;
2510
2511 _impl_.worker_log_.Clear();
2512 _impl_.hostname_.ClearToEmpty();
2513 _impl_.health_status_ = 0;
2514 _internal_metadata_.Clear<std::string>();
2515 }
2516
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2517 const char* WorkerHeartbeatResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2518 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2519 while (!ctx->Done(&ptr)) {
2520 ::uint32_t tag;
2521 ptr = ::_pbi::ReadTag(ptr, &tag);
2522 switch (tag >> 3) {
2523 // .tensorflow.WorkerHealth health_status = 1;
2524 case 1:
2525 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2526 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2527 CHK_(ptr);
2528 _internal_set_health_status(static_cast<::tensorflow::WorkerHealth>(val));
2529 } else {
2530 goto handle_unusual;
2531 }
2532 continue;
2533 // repeated .tensorflow.Event worker_log = 2;
2534 case 2:
2535 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
2536 ptr -= 1;
2537 do {
2538 ptr += 1;
2539 ptr = ctx->ParseMessage(_internal_add_worker_log(), ptr);
2540 CHK_(ptr);
2541 if (!ctx->DataAvailable(ptr)) break;
2542 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
2543 } else {
2544 goto handle_unusual;
2545 }
2546 continue;
2547 // string hostname = 3;
2548 case 3:
2549 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
2550 auto str = _internal_mutable_hostname();
2551 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2552 CHK_(ptr);
2553 CHK_(::_pbi::VerifyUTF8(str, nullptr));
2554 } else {
2555 goto handle_unusual;
2556 }
2557 continue;
2558 default:
2559 goto handle_unusual;
2560 } // switch
2561 handle_unusual:
2562 if ((tag == 0) || ((tag & 7) == 4)) {
2563 CHK_(ptr);
2564 ctx->SetLastTag(tag);
2565 goto message_done;
2566 }
2567 ptr = UnknownFieldParse(
2568 tag,
2569 _internal_metadata_.mutable_unknown_fields<std::string>(),
2570 ptr, ctx);
2571 CHK_(ptr != nullptr);
2572 } // while
2573 message_done:
2574 return ptr;
2575 failure:
2576 ptr = nullptr;
2577 goto message_done;
2578 #undef CHK_
2579 }
2580
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2581 ::uint8_t* WorkerHeartbeatResponse::_InternalSerialize(
2582 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2583 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.WorkerHeartbeatResponse)
2584 ::uint32_t cached_has_bits = 0;
2585 (void) cached_has_bits;
2586
2587 // .tensorflow.WorkerHealth health_status = 1;
2588 if (this->_internal_health_status() != 0) {
2589 target = stream->EnsureSpace(target);
2590 target = ::_pbi::WireFormatLite::WriteEnumToArray(
2591 1, this->_internal_health_status(), target);
2592 }
2593
2594 // repeated .tensorflow.Event worker_log = 2;
2595 for (unsigned i = 0,
2596 n = static_cast<unsigned>(this->_internal_worker_log_size()); i < n; i++) {
2597 const auto& repfield = this->_internal_worker_log(i);
2598 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
2599 InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
2600 }
2601
2602 // string hostname = 3;
2603 if (!this->_internal_hostname().empty()) {
2604 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
2605 this->_internal_hostname().data(), static_cast<int>(this->_internal_hostname().length()),
2606 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
2607 "tensorflow.WorkerHeartbeatResponse.hostname");
2608 target = stream->WriteStringMaybeAliased(
2609 3, this->_internal_hostname(), target);
2610 }
2611
2612 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2613 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2614 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2615 }
2616 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.WorkerHeartbeatResponse)
2617 return target;
2618 }
2619
ByteSizeLong() const2620 size_t WorkerHeartbeatResponse::ByteSizeLong() const {
2621 // @@protoc_insertion_point(message_byte_size_start:tensorflow.WorkerHeartbeatResponse)
2622 size_t total_size = 0;
2623
2624 ::uint32_t cached_has_bits = 0;
2625 // Prevent compiler warnings about cached_has_bits being unused
2626 (void) cached_has_bits;
2627
2628 // repeated .tensorflow.Event worker_log = 2;
2629 total_size += 1UL * this->_internal_worker_log_size();
2630 for (const auto& msg : this->_impl_.worker_log_) {
2631 total_size +=
2632 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
2633 }
2634
2635 // string hostname = 3;
2636 if (!this->_internal_hostname().empty()) {
2637 total_size += 1 +
2638 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2639 this->_internal_hostname());
2640 }
2641
2642 // .tensorflow.WorkerHealth health_status = 1;
2643 if (this->_internal_health_status() != 0) {
2644 total_size += 1 +
2645 ::_pbi::WireFormatLite::EnumSize(this->_internal_health_status());
2646 }
2647
2648 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2649 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2650 }
2651 int cached_size = ::_pbi::ToCachedSize(total_size);
2652 SetCachedSize(cached_size);
2653 return total_size;
2654 }
2655
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2656 void WorkerHeartbeatResponse::CheckTypeAndMergeFrom(
2657 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2658 MergeFrom(*::_pbi::DownCast<const WorkerHeartbeatResponse*>(
2659 &from));
2660 }
2661
MergeFrom(const WorkerHeartbeatResponse & from)2662 void WorkerHeartbeatResponse::MergeFrom(const WorkerHeartbeatResponse& from) {
2663 WorkerHeartbeatResponse* const _this = this;
2664 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.WorkerHeartbeatResponse)
2665 GOOGLE_DCHECK_NE(&from, _this);
2666 ::uint32_t cached_has_bits = 0;
2667 (void) cached_has_bits;
2668
2669 _this->_impl_.worker_log_.MergeFrom(from._impl_.worker_log_);
2670 if (!from._internal_hostname().empty()) {
2671 _this->_internal_set_hostname(from._internal_hostname());
2672 }
2673 if (from._internal_health_status() != 0) {
2674 _this->_internal_set_health_status(from._internal_health_status());
2675 }
2676 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2677 }
2678
CopyFrom(const WorkerHeartbeatResponse & from)2679 void WorkerHeartbeatResponse::CopyFrom(const WorkerHeartbeatResponse& from) {
2680 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.WorkerHeartbeatResponse)
2681 if (&from == this) return;
2682 Clear();
2683 MergeFrom(from);
2684 }
2685
IsInitialized() const2686 bool WorkerHeartbeatResponse::IsInitialized() const {
2687 return true;
2688 }
2689
InternalSwap(WorkerHeartbeatResponse * other)2690 void WorkerHeartbeatResponse::InternalSwap(WorkerHeartbeatResponse* other) {
2691 using std::swap;
2692 auto* lhs_arena = GetArenaForAllocation();
2693 auto* rhs_arena = other->GetArenaForAllocation();
2694 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2695 _impl_.worker_log_.InternalSwap(&other->_impl_.worker_log_);
2696 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2697 &_impl_.hostname_, lhs_arena,
2698 &other->_impl_.hostname_, rhs_arena
2699 );
2700 swap(_impl_.health_status_, other->_impl_.health_status_);
2701 }
2702
GetTypeName() const2703 std::string WorkerHeartbeatResponse::GetTypeName() const {
2704 return "tensorflow.WorkerHeartbeatResponse";
2705 }
2706
2707
2708 // @@protoc_insertion_point(namespace_scope)
2709 } // namespace tensorflow
2710 PROTOBUF_NAMESPACE_OPEN
2711 template<> PROTOBUF_NOINLINE ::tensorflow::Event*
CreateMaybeMessage(Arena * arena)2712 Arena::CreateMaybeMessage< ::tensorflow::Event >(Arena* arena) {
2713 return Arena::CreateMessageInternal< ::tensorflow::Event >(arena);
2714 }
2715 template<> PROTOBUF_NOINLINE ::tensorflow::LogMessage*
CreateMaybeMessage(Arena * arena)2716 Arena::CreateMaybeMessage< ::tensorflow::LogMessage >(Arena* arena) {
2717 return Arena::CreateMessageInternal< ::tensorflow::LogMessage >(arena);
2718 }
2719 template<> PROTOBUF_NOINLINE ::tensorflow::SessionLog*
CreateMaybeMessage(Arena * arena)2720 Arena::CreateMaybeMessage< ::tensorflow::SessionLog >(Arena* arena) {
2721 return Arena::CreateMessageInternal< ::tensorflow::SessionLog >(arena);
2722 }
2723 template<> PROTOBUF_NOINLINE ::tensorflow::TaggedRunMetadata*
CreateMaybeMessage(Arena * arena)2724 Arena::CreateMaybeMessage< ::tensorflow::TaggedRunMetadata >(Arena* arena) {
2725 return Arena::CreateMessageInternal< ::tensorflow::TaggedRunMetadata >(arena);
2726 }
2727 template<> PROTOBUF_NOINLINE ::tensorflow::WatchdogConfig*
CreateMaybeMessage(Arena * arena)2728 Arena::CreateMaybeMessage< ::tensorflow::WatchdogConfig >(Arena* arena) {
2729 return Arena::CreateMessageInternal< ::tensorflow::WatchdogConfig >(arena);
2730 }
2731 template<> PROTOBUF_NOINLINE ::tensorflow::RequestedExitCode*
CreateMaybeMessage(Arena * arena)2732 Arena::CreateMaybeMessage< ::tensorflow::RequestedExitCode >(Arena* arena) {
2733 return Arena::CreateMessageInternal< ::tensorflow::RequestedExitCode >(arena);
2734 }
2735 template<> PROTOBUF_NOINLINE ::tensorflow::WorkerHeartbeatRequest*
CreateMaybeMessage(Arena * arena)2736 Arena::CreateMaybeMessage< ::tensorflow::WorkerHeartbeatRequest >(Arena* arena) {
2737 return Arena::CreateMessageInternal< ::tensorflow::WorkerHeartbeatRequest >(arena);
2738 }
2739 template<> PROTOBUF_NOINLINE ::tensorflow::WorkerHeartbeatResponse*
CreateMaybeMessage(Arena * arena)2740 Arena::CreateMaybeMessage< ::tensorflow::WorkerHeartbeatResponse >(Arena* arena) {
2741 return Arena::CreateMessageInternal< ::tensorflow::WorkerHeartbeatResponse >(arena);
2742 }
2743 PROTOBUF_NAMESPACE_CLOSE
2744
2745 // @@protoc_insertion_point(global_scope)
2746 #include <google/protobuf/port_undef.inc>
2747