1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: tensorflow/core/protobuf/coordination_config.proto
3 
4 #include "tensorflow/core/protobuf/coordination_config.pb.h"
5 
6 #include <algorithm>
7 #include <cstdint>
8 
9 #include <google/protobuf/io/coded_stream.h>
10 #include <google/protobuf/extension_set.h>
11 #include <google/protobuf/wire_format_lite.h>
12 #include <google/protobuf/io/zero_copy_stream_impl_lite.h>
13 // @@protoc_insertion_point(includes)
14 #include <google/protobuf/port_def.inc>
15 
16 PROTOBUF_PRAGMA_INIT_SEG
17 
18 namespace _pb = ::PROTOBUF_NAMESPACE_ID;
19 namespace _pbi = _pb::internal;
20 
21 namespace tensorflow {
CoordinationServiceConfig(::_pbi::ConstantInitialized)22 PROTOBUF_CONSTEXPR CoordinationServiceConfig::CoordinationServiceConfig(
23     ::_pbi::ConstantInitialized): _impl_{
24     /*decltype(_impl_.coordinated_jobs_)*/{}
25   , /*decltype(_impl_.recoverable_jobs_)*/{}
26   , /*decltype(_impl_.service_type_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
27   , /*decltype(_impl_.service_leader_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
28   , /*decltype(_impl_.cluster_register_timeout_in_ms_)*/::int64_t{0}
29   , /*decltype(_impl_.heartbeat_timeout_in_ms_)*/::int64_t{0}
30   , /*decltype(_impl_.shutdown_barrier_timeout_in_ms_)*/::int64_t{0}
31   , /*decltype(_impl_.enable_health_check_)*/false
32   , /*decltype(_impl_.agent_destruction_without_shutdown_)*/false
33   , /*decltype(_impl_._cached_size_)*/{}} {}
34 struct CoordinationServiceConfigDefaultTypeInternal {
CoordinationServiceConfigDefaultTypeInternaltensorflow::CoordinationServiceConfigDefaultTypeInternal35   PROTOBUF_CONSTEXPR CoordinationServiceConfigDefaultTypeInternal()
36       : _instance(::_pbi::ConstantInitialized{}) {}
~CoordinationServiceConfigDefaultTypeInternaltensorflow::CoordinationServiceConfigDefaultTypeInternal37   ~CoordinationServiceConfigDefaultTypeInternal() {}
38   union {  // NOLINT(misc-non-private-member-variables-in-classes)
39     CoordinationServiceConfig _instance;
40   };
41 };
42 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CoordinationServiceConfigDefaultTypeInternal _CoordinationServiceConfig_default_instance_;
43 }  // namespace tensorflow
44 namespace tensorflow {
45 
46 // ===================================================================
47 
48 class CoordinationServiceConfig::_Internal {
49  public:
50 };
51 
CoordinationServiceConfig(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)52 CoordinationServiceConfig::CoordinationServiceConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
53                          bool is_message_owned)
54   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
55   SharedCtor(arena, is_message_owned);
56   // @@protoc_insertion_point(arena_constructor:tensorflow.CoordinationServiceConfig)
57 }
CoordinationServiceConfig(const CoordinationServiceConfig & from)58 CoordinationServiceConfig::CoordinationServiceConfig(const CoordinationServiceConfig& from)
59   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
60   CoordinationServiceConfig* const _this = this; (void)_this;
61   new (&_impl_) Impl_{
62       decltype(_impl_.coordinated_jobs_){from._impl_.coordinated_jobs_}
63     , decltype(_impl_.recoverable_jobs_){from._impl_.recoverable_jobs_}
64     , decltype(_impl_.service_type_){}
65     , decltype(_impl_.service_leader_){}
66     , decltype(_impl_.cluster_register_timeout_in_ms_){}
67     , decltype(_impl_.heartbeat_timeout_in_ms_){}
68     , decltype(_impl_.shutdown_barrier_timeout_in_ms_){}
69     , decltype(_impl_.enable_health_check_){}
70     , decltype(_impl_.agent_destruction_without_shutdown_){}
71     , /*decltype(_impl_._cached_size_)*/{}};
72 
73   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
74   _impl_.service_type_.InitDefault();
75   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
76     _impl_.service_type_.Set("", GetArenaForAllocation());
77   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
78   if (!from._internal_service_type().empty()) {
79     _this->_impl_.service_type_.Set(from._internal_service_type(),
80       _this->GetArenaForAllocation());
81   }
82   _impl_.service_leader_.InitDefault();
83   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
84     _impl_.service_leader_.Set("", GetArenaForAllocation());
85   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
86   if (!from._internal_service_leader().empty()) {
87     _this->_impl_.service_leader_.Set(from._internal_service_leader(),
88       _this->GetArenaForAllocation());
89   }
90   ::memcpy(&_impl_.cluster_register_timeout_in_ms_, &from._impl_.cluster_register_timeout_in_ms_,
91     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.agent_destruction_without_shutdown_) -
92     reinterpret_cast<char*>(&_impl_.cluster_register_timeout_in_ms_)) + sizeof(_impl_.agent_destruction_without_shutdown_));
93   // @@protoc_insertion_point(copy_constructor:tensorflow.CoordinationServiceConfig)
94 }
95 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)96 inline void CoordinationServiceConfig::SharedCtor(
97     ::_pb::Arena* arena, bool is_message_owned) {
98   (void)arena;
99   (void)is_message_owned;
100   new (&_impl_) Impl_{
101       decltype(_impl_.coordinated_jobs_){arena}
102     , decltype(_impl_.recoverable_jobs_){arena}
103     , decltype(_impl_.service_type_){}
104     , decltype(_impl_.service_leader_){}
105     , decltype(_impl_.cluster_register_timeout_in_ms_){::int64_t{0}}
106     , decltype(_impl_.heartbeat_timeout_in_ms_){::int64_t{0}}
107     , decltype(_impl_.shutdown_barrier_timeout_in_ms_){::int64_t{0}}
108     , decltype(_impl_.enable_health_check_){false}
109     , decltype(_impl_.agent_destruction_without_shutdown_){false}
110     , /*decltype(_impl_._cached_size_)*/{}
111   };
112   _impl_.service_type_.InitDefault();
113   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
114     _impl_.service_type_.Set("", GetArenaForAllocation());
115   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
116   _impl_.service_leader_.InitDefault();
117   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
118     _impl_.service_leader_.Set("", GetArenaForAllocation());
119   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
120 }
121 
~CoordinationServiceConfig()122 CoordinationServiceConfig::~CoordinationServiceConfig() {
123   // @@protoc_insertion_point(destructor:tensorflow.CoordinationServiceConfig)
124   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
125   (void)arena;
126     return;
127   }
128   SharedDtor();
129 }
130 
SharedDtor()131 inline void CoordinationServiceConfig::SharedDtor() {
132   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
133   _impl_.coordinated_jobs_.~RepeatedPtrField();
134   _impl_.recoverable_jobs_.~RepeatedPtrField();
135   _impl_.service_type_.Destroy();
136   _impl_.service_leader_.Destroy();
137 }
138 
SetCachedSize(int size) const139 void CoordinationServiceConfig::SetCachedSize(int size) const {
140   _impl_._cached_size_.Set(size);
141 }
142 
Clear()143 void CoordinationServiceConfig::Clear() {
144 // @@protoc_insertion_point(message_clear_start:tensorflow.CoordinationServiceConfig)
145   ::uint32_t cached_has_bits = 0;
146   // Prevent compiler warnings about cached_has_bits being unused
147   (void) cached_has_bits;
148 
149   _impl_.coordinated_jobs_.Clear();
150   _impl_.recoverable_jobs_.Clear();
151   _impl_.service_type_.ClearToEmpty();
152   _impl_.service_leader_.ClearToEmpty();
153   ::memset(&_impl_.cluster_register_timeout_in_ms_, 0, static_cast<size_t>(
154       reinterpret_cast<char*>(&_impl_.agent_destruction_without_shutdown_) -
155       reinterpret_cast<char*>(&_impl_.cluster_register_timeout_in_ms_)) + sizeof(_impl_.agent_destruction_without_shutdown_));
156   _internal_metadata_.Clear<std::string>();
157 }
158 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)159 const char* CoordinationServiceConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
160 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
161   while (!ctx->Done(&ptr)) {
162     ::uint32_t tag;
163     ptr = ::_pbi::ReadTag(ptr, &tag);
164     switch (tag >> 3) {
165       // string service_type = 1;
166       case 1:
167         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
168           auto str = _internal_mutable_service_type();
169           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
170           CHK_(ptr);
171           CHK_(::_pbi::VerifyUTF8(str, nullptr));
172         } else {
173           goto handle_unusual;
174         }
175         continue;
176       // string service_leader = 2;
177       case 2:
178         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
179           auto str = _internal_mutable_service_leader();
180           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
181           CHK_(ptr);
182           CHK_(::_pbi::VerifyUTF8(str, nullptr));
183         } else {
184           goto handle_unusual;
185         }
186         continue;
187       // bool enable_health_check = 3;
188       case 3:
189         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
190           _impl_.enable_health_check_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
191           CHK_(ptr);
192         } else {
193           goto handle_unusual;
194         }
195         continue;
196       // int64 cluster_register_timeout_in_ms = 4;
197       case 4:
198         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
199           _impl_.cluster_register_timeout_in_ms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
200           CHK_(ptr);
201         } else {
202           goto handle_unusual;
203         }
204         continue;
205       // int64 heartbeat_timeout_in_ms = 5;
206       case 5:
207         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
208           _impl_.heartbeat_timeout_in_ms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
209           CHK_(ptr);
210         } else {
211           goto handle_unusual;
212         }
213         continue;
214       // repeated string coordinated_jobs = 6;
215       case 6:
216         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
217           ptr -= 1;
218           do {
219             ptr += 1;
220             auto str = _internal_add_coordinated_jobs();
221             ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
222             CHK_(ptr);
223             CHK_(::_pbi::VerifyUTF8(str, nullptr));
224             if (!ctx->DataAvailable(ptr)) break;
225           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr));
226         } else {
227           goto handle_unusual;
228         }
229         continue;
230       // int64 shutdown_barrier_timeout_in_ms = 7;
231       case 7:
232         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
233           _impl_.shutdown_barrier_timeout_in_ms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
234           CHK_(ptr);
235         } else {
236           goto handle_unusual;
237         }
238         continue;
239       // bool agent_destruction_without_shutdown = 8;
240       case 8:
241         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 64)) {
242           _impl_.agent_destruction_without_shutdown_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
243           CHK_(ptr);
244         } else {
245           goto handle_unusual;
246         }
247         continue;
248       // repeated string recoverable_jobs = 9;
249       case 9:
250         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 74)) {
251           ptr -= 1;
252           do {
253             ptr += 1;
254             auto str = _internal_add_recoverable_jobs();
255             ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
256             CHK_(ptr);
257             CHK_(::_pbi::VerifyUTF8(str, nullptr));
258             if (!ctx->DataAvailable(ptr)) break;
259           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<74>(ptr));
260         } else {
261           goto handle_unusual;
262         }
263         continue;
264       default:
265         goto handle_unusual;
266     }  // switch
267   handle_unusual:
268     if ((tag == 0) || ((tag & 7) == 4)) {
269       CHK_(ptr);
270       ctx->SetLastTag(tag);
271       goto message_done;
272     }
273     ptr = UnknownFieldParse(
274         tag,
275         _internal_metadata_.mutable_unknown_fields<std::string>(),
276         ptr, ctx);
277     CHK_(ptr != nullptr);
278   }  // while
279 message_done:
280   return ptr;
281 failure:
282   ptr = nullptr;
283   goto message_done;
284 #undef CHK_
285 }
286 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const287 ::uint8_t* CoordinationServiceConfig::_InternalSerialize(
288     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
289   // @@protoc_insertion_point(serialize_to_array_start:tensorflow.CoordinationServiceConfig)
290   ::uint32_t cached_has_bits = 0;
291   (void) cached_has_bits;
292 
293   // string service_type = 1;
294   if (!this->_internal_service_type().empty()) {
295     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
296       this->_internal_service_type().data(), static_cast<int>(this->_internal_service_type().length()),
297       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
298       "tensorflow.CoordinationServiceConfig.service_type");
299     target = stream->WriteStringMaybeAliased(
300         1, this->_internal_service_type(), target);
301   }
302 
303   // string service_leader = 2;
304   if (!this->_internal_service_leader().empty()) {
305     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
306       this->_internal_service_leader().data(), static_cast<int>(this->_internal_service_leader().length()),
307       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
308       "tensorflow.CoordinationServiceConfig.service_leader");
309     target = stream->WriteStringMaybeAliased(
310         2, this->_internal_service_leader(), target);
311   }
312 
313   // bool enable_health_check = 3;
314   if (this->_internal_enable_health_check() != 0) {
315     target = stream->EnsureSpace(target);
316     target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_enable_health_check(), target);
317   }
318 
319   // int64 cluster_register_timeout_in_ms = 4;
320   if (this->_internal_cluster_register_timeout_in_ms() != 0) {
321     target = stream->EnsureSpace(target);
322     target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_cluster_register_timeout_in_ms(), target);
323   }
324 
325   // int64 heartbeat_timeout_in_ms = 5;
326   if (this->_internal_heartbeat_timeout_in_ms() != 0) {
327     target = stream->EnsureSpace(target);
328     target = ::_pbi::WireFormatLite::WriteInt64ToArray(5, this->_internal_heartbeat_timeout_in_ms(), target);
329   }
330 
331   // repeated string coordinated_jobs = 6;
332   for (int i = 0, n = this->_internal_coordinated_jobs_size(); i < n; i++) {
333     const auto& s = this->_internal_coordinated_jobs(i);
334     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
335       s.data(), static_cast<int>(s.length()),
336       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
337       "tensorflow.CoordinationServiceConfig.coordinated_jobs");
338     target = stream->WriteString(6, s, target);
339   }
340 
341   // int64 shutdown_barrier_timeout_in_ms = 7;
342   if (this->_internal_shutdown_barrier_timeout_in_ms() != 0) {
343     target = stream->EnsureSpace(target);
344     target = ::_pbi::WireFormatLite::WriteInt64ToArray(7, this->_internal_shutdown_barrier_timeout_in_ms(), target);
345   }
346 
347   // bool agent_destruction_without_shutdown = 8;
348   if (this->_internal_agent_destruction_without_shutdown() != 0) {
349     target = stream->EnsureSpace(target);
350     target = ::_pbi::WireFormatLite::WriteBoolToArray(8, this->_internal_agent_destruction_without_shutdown(), target);
351   }
352 
353   // repeated string recoverable_jobs = 9;
354   for (int i = 0, n = this->_internal_recoverable_jobs_size(); i < n; i++) {
355     const auto& s = this->_internal_recoverable_jobs(i);
356     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
357       s.data(), static_cast<int>(s.length()),
358       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
359       "tensorflow.CoordinationServiceConfig.recoverable_jobs");
360     target = stream->WriteString(9, s, target);
361   }
362 
363   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
364     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
365         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
366   }
367   // @@protoc_insertion_point(serialize_to_array_end:tensorflow.CoordinationServiceConfig)
368   return target;
369 }
370 
ByteSizeLong() const371 size_t CoordinationServiceConfig::ByteSizeLong() const {
372 // @@protoc_insertion_point(message_byte_size_start:tensorflow.CoordinationServiceConfig)
373   size_t total_size = 0;
374 
375   ::uint32_t cached_has_bits = 0;
376   // Prevent compiler warnings about cached_has_bits being unused
377   (void) cached_has_bits;
378 
379   // repeated string coordinated_jobs = 6;
380   total_size += 1 *
381       ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.coordinated_jobs_.size());
382   for (int i = 0, n = _impl_.coordinated_jobs_.size(); i < n; i++) {
383     total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
384       _impl_.coordinated_jobs_.Get(i));
385   }
386 
387   // repeated string recoverable_jobs = 9;
388   total_size += 1 *
389       ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.recoverable_jobs_.size());
390   for (int i = 0, n = _impl_.recoverable_jobs_.size(); i < n; i++) {
391     total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
392       _impl_.recoverable_jobs_.Get(i));
393   }
394 
395   // string service_type = 1;
396   if (!this->_internal_service_type().empty()) {
397     total_size += 1 +
398       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
399         this->_internal_service_type());
400   }
401 
402   // string service_leader = 2;
403   if (!this->_internal_service_leader().empty()) {
404     total_size += 1 +
405       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
406         this->_internal_service_leader());
407   }
408 
409   // int64 cluster_register_timeout_in_ms = 4;
410   if (this->_internal_cluster_register_timeout_in_ms() != 0) {
411     total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_cluster_register_timeout_in_ms());
412   }
413 
414   // int64 heartbeat_timeout_in_ms = 5;
415   if (this->_internal_heartbeat_timeout_in_ms() != 0) {
416     total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_heartbeat_timeout_in_ms());
417   }
418 
419   // int64 shutdown_barrier_timeout_in_ms = 7;
420   if (this->_internal_shutdown_barrier_timeout_in_ms() != 0) {
421     total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_shutdown_barrier_timeout_in_ms());
422   }
423 
424   // bool enable_health_check = 3;
425   if (this->_internal_enable_health_check() != 0) {
426     total_size += 1 + 1;
427   }
428 
429   // bool agent_destruction_without_shutdown = 8;
430   if (this->_internal_agent_destruction_without_shutdown() != 0) {
431     total_size += 1 + 1;
432   }
433 
434   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
435     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
436   }
437   int cached_size = ::_pbi::ToCachedSize(total_size);
438   SetCachedSize(cached_size);
439   return total_size;
440 }
441 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)442 void CoordinationServiceConfig::CheckTypeAndMergeFrom(
443     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
444   MergeFrom(*::_pbi::DownCast<const CoordinationServiceConfig*>(
445       &from));
446 }
447 
MergeFrom(const CoordinationServiceConfig & from)448 void CoordinationServiceConfig::MergeFrom(const CoordinationServiceConfig& from) {
449   CoordinationServiceConfig* const _this = this;
450   // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.CoordinationServiceConfig)
451   GOOGLE_DCHECK_NE(&from, _this);
452   ::uint32_t cached_has_bits = 0;
453   (void) cached_has_bits;
454 
455   _this->_impl_.coordinated_jobs_.MergeFrom(from._impl_.coordinated_jobs_);
456   _this->_impl_.recoverable_jobs_.MergeFrom(from._impl_.recoverable_jobs_);
457   if (!from._internal_service_type().empty()) {
458     _this->_internal_set_service_type(from._internal_service_type());
459   }
460   if (!from._internal_service_leader().empty()) {
461     _this->_internal_set_service_leader(from._internal_service_leader());
462   }
463   if (from._internal_cluster_register_timeout_in_ms() != 0) {
464     _this->_internal_set_cluster_register_timeout_in_ms(from._internal_cluster_register_timeout_in_ms());
465   }
466   if (from._internal_heartbeat_timeout_in_ms() != 0) {
467     _this->_internal_set_heartbeat_timeout_in_ms(from._internal_heartbeat_timeout_in_ms());
468   }
469   if (from._internal_shutdown_barrier_timeout_in_ms() != 0) {
470     _this->_internal_set_shutdown_barrier_timeout_in_ms(from._internal_shutdown_barrier_timeout_in_ms());
471   }
472   if (from._internal_enable_health_check() != 0) {
473     _this->_internal_set_enable_health_check(from._internal_enable_health_check());
474   }
475   if (from._internal_agent_destruction_without_shutdown() != 0) {
476     _this->_internal_set_agent_destruction_without_shutdown(from._internal_agent_destruction_without_shutdown());
477   }
478   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
479 }
480 
CopyFrom(const CoordinationServiceConfig & from)481 void CoordinationServiceConfig::CopyFrom(const CoordinationServiceConfig& from) {
482 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.CoordinationServiceConfig)
483   if (&from == this) return;
484   Clear();
485   MergeFrom(from);
486 }
487 
IsInitialized() const488 bool CoordinationServiceConfig::IsInitialized() const {
489   return true;
490 }
491 
InternalSwap(CoordinationServiceConfig * other)492 void CoordinationServiceConfig::InternalSwap(CoordinationServiceConfig* other) {
493   using std::swap;
494   auto* lhs_arena = GetArenaForAllocation();
495   auto* rhs_arena = other->GetArenaForAllocation();
496   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
497   _impl_.coordinated_jobs_.InternalSwap(&other->_impl_.coordinated_jobs_);
498   _impl_.recoverable_jobs_.InternalSwap(&other->_impl_.recoverable_jobs_);
499   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
500       &_impl_.service_type_, lhs_arena,
501       &other->_impl_.service_type_, rhs_arena
502   );
503   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
504       &_impl_.service_leader_, lhs_arena,
505       &other->_impl_.service_leader_, rhs_arena
506   );
507   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
508       PROTOBUF_FIELD_OFFSET(CoordinationServiceConfig, _impl_.agent_destruction_without_shutdown_)
509       + sizeof(CoordinationServiceConfig::_impl_.agent_destruction_without_shutdown_)  // NOLINT
510       - PROTOBUF_FIELD_OFFSET(CoordinationServiceConfig, _impl_.cluster_register_timeout_in_ms_)>(
511           reinterpret_cast<char*>(&_impl_.cluster_register_timeout_in_ms_),
512           reinterpret_cast<char*>(&other->_impl_.cluster_register_timeout_in_ms_));
513 }
514 
GetTypeName() const515 std::string CoordinationServiceConfig::GetTypeName() const {
516   return "tensorflow.CoordinationServiceConfig";
517 }
518 
519 
520 // @@protoc_insertion_point(namespace_scope)
521 }  // namespace tensorflow
522 PROTOBUF_NAMESPACE_OPEN
523 template<> PROTOBUF_NOINLINE ::tensorflow::CoordinationServiceConfig*
CreateMaybeMessage(Arena * arena)524 Arena::CreateMaybeMessage< ::tensorflow::CoordinationServiceConfig >(Arena* arena) {
525   return Arena::CreateMessageInternal< ::tensorflow::CoordinationServiceConfig >(arena);
526 }
527 PROTOBUF_NAMESPACE_CLOSE
528 
529 // @@protoc_insertion_point(global_scope)
530 #include <google/protobuf/port_undef.inc>
531