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