1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: tensorflow/core/protobuf/data_service.proto
3 
4 #include "tensorflow/core/protobuf/data_service.pb.h"
5 
6 #include <algorithm>
7 #include <cstdint>
8 
9 #include <google/protobuf/io/coded_stream.h>
10 #include <google/protobuf/extension_set.h>
11 #include <google/protobuf/wire_format_lite.h>
12 #include <google/protobuf/io/zero_copy_stream_impl_lite.h>
13 // @@protoc_insertion_point(includes)
14 #include <google/protobuf/port_def.inc>
15 
16 PROTOBUF_PRAGMA_INIT_SEG
17 
18 namespace _pb = ::PROTOBUF_NAMESPACE_ID;
19 namespace _pbi = _pb::internal;
20 
21 namespace tensorflow {
22 namespace data {
ProcessingModeDef(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR ProcessingModeDef::ProcessingModeDef(
24     ::_pbi::ConstantInitialized): _impl_{
25     /*decltype(_impl_.sharding_policy_)*/0
26   , /*decltype(_impl_._cached_size_)*/{}} {}
27 struct ProcessingModeDefDefaultTypeInternal {
ProcessingModeDefDefaultTypeInternaltensorflow::data::ProcessingModeDefDefaultTypeInternal28   PROTOBUF_CONSTEXPR ProcessingModeDefDefaultTypeInternal()
29       : _instance(::_pbi::ConstantInitialized{}) {}
~ProcessingModeDefDefaultTypeInternaltensorflow::data::ProcessingModeDefDefaultTypeInternal30   ~ProcessingModeDefDefaultTypeInternal() {}
31   union {  // NOLINT(misc-non-private-member-variables-in-classes)
32     ProcessingModeDef _instance;
33   };
34 };
35 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ProcessingModeDefDefaultTypeInternal _ProcessingModeDef_default_instance_;
DataServiceMetadata(::_pbi::ConstantInitialized)36 PROTOBUF_CONSTEXPR DataServiceMetadata::DataServiceMetadata(
37     ::_pbi::ConstantInitialized): _impl_{
38     /*decltype(_impl_.cardinality_)*/::int64_t{0}
39   , /*decltype(_impl_.compression_)*/0
40   , /*decltype(_impl_.optional_element_spec_)*/{}
41   , /*decltype(_impl_._cached_size_)*/{}
42   , /*decltype(_impl_._oneof_case_)*/{}} {}
43 struct DataServiceMetadataDefaultTypeInternal {
DataServiceMetadataDefaultTypeInternaltensorflow::data::DataServiceMetadataDefaultTypeInternal44   PROTOBUF_CONSTEXPR DataServiceMetadataDefaultTypeInternal()
45       : _instance(::_pbi::ConstantInitialized{}) {}
~DataServiceMetadataDefaultTypeInternaltensorflow::data::DataServiceMetadataDefaultTypeInternal46   ~DataServiceMetadataDefaultTypeInternal() {}
47   union {  // NOLINT(misc-non-private-member-variables-in-classes)
48     DataServiceMetadata _instance;
49   };
50 };
51 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DataServiceMetadataDefaultTypeInternal _DataServiceMetadata_default_instance_;
CrossTrainerCacheOptions(::_pbi::ConstantInitialized)52 PROTOBUF_CONSTEXPR CrossTrainerCacheOptions::CrossTrainerCacheOptions(
53     ::_pbi::ConstantInitialized): _impl_{
54     /*decltype(_impl_.trainer_id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
55   , /*decltype(_impl_._cached_size_)*/{}} {}
56 struct CrossTrainerCacheOptionsDefaultTypeInternal {
CrossTrainerCacheOptionsDefaultTypeInternaltensorflow::data::CrossTrainerCacheOptionsDefaultTypeInternal57   PROTOBUF_CONSTEXPR CrossTrainerCacheOptionsDefaultTypeInternal()
58       : _instance(::_pbi::ConstantInitialized{}) {}
~CrossTrainerCacheOptionsDefaultTypeInternaltensorflow::data::CrossTrainerCacheOptionsDefaultTypeInternal59   ~CrossTrainerCacheOptionsDefaultTypeInternal() {}
60   union {  // NOLINT(misc-non-private-member-variables-in-classes)
61     CrossTrainerCacheOptions _instance;
62   };
63 };
64 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CrossTrainerCacheOptionsDefaultTypeInternal _CrossTrainerCacheOptions_default_instance_;
DataServiceConfig(::_pbi::ConstantInitialized)65 PROTOBUF_CONSTEXPR DataServiceConfig::DataServiceConfig(
66     ::_pbi::ConstantInitialized): _impl_{
67     /*decltype(_impl_.deployment_mode_)*/0
68   , /*decltype(_impl_._cached_size_)*/{}} {}
69 struct DataServiceConfigDefaultTypeInternal {
DataServiceConfigDefaultTypeInternaltensorflow::data::DataServiceConfigDefaultTypeInternal70   PROTOBUF_CONSTEXPR DataServiceConfigDefaultTypeInternal()
71       : _instance(::_pbi::ConstantInitialized{}) {}
~DataServiceConfigDefaultTypeInternaltensorflow::data::DataServiceConfigDefaultTypeInternal72   ~DataServiceConfigDefaultTypeInternal() {}
73   union {  // NOLINT(misc-non-private-member-variables-in-classes)
74     DataServiceConfig _instance;
75   };
76 };
77 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DataServiceConfigDefaultTypeInternal _DataServiceConfig_default_instance_;
78 }  // namespace data
79 }  // namespace tensorflow
80 namespace tensorflow {
81 namespace data {
ProcessingModeDef_ShardingPolicy_IsValid(int value)82 bool ProcessingModeDef_ShardingPolicy_IsValid(int value) {
83   switch (value) {
84     case 0:
85     case 1:
86     case 2:
87     case 3:
88     case 4:
89     case 5:
90       return true;
91     default:
92       return false;
93   }
94 }
95 
96 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ProcessingModeDef_ShardingPolicy_strings[6] = {};
97 
98 static const char ProcessingModeDef_ShardingPolicy_names[] =
99   "DATA"
100   "DYNAMIC"
101   "FILE"
102   "FILE_OR_DATA"
103   "HINT"
104   "OFF";
105 
106 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ProcessingModeDef_ShardingPolicy_entries[] = {
107   { {ProcessingModeDef_ShardingPolicy_names + 0, 4}, 3 },
108   { {ProcessingModeDef_ShardingPolicy_names + 4, 7}, 1 },
109   { {ProcessingModeDef_ShardingPolicy_names + 11, 4}, 2 },
110   { {ProcessingModeDef_ShardingPolicy_names + 15, 12}, 4 },
111   { {ProcessingModeDef_ShardingPolicy_names + 27, 4}, 5 },
112   { {ProcessingModeDef_ShardingPolicy_names + 31, 3}, 0 },
113 };
114 
115 static const int ProcessingModeDef_ShardingPolicy_entries_by_number[] = {
116   5, // 0 -> OFF
117   1, // 1 -> DYNAMIC
118   2, // 2 -> FILE
119   0, // 3 -> DATA
120   3, // 4 -> FILE_OR_DATA
121   4, // 5 -> HINT
122 };
123 
ProcessingModeDef_ShardingPolicy_Name(ProcessingModeDef_ShardingPolicy value)124 const std::string& ProcessingModeDef_ShardingPolicy_Name(
125     ProcessingModeDef_ShardingPolicy value) {
126   static const bool dummy =
127       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
128           ProcessingModeDef_ShardingPolicy_entries,
129           ProcessingModeDef_ShardingPolicy_entries_by_number,
130           6, ProcessingModeDef_ShardingPolicy_strings);
131   (void) dummy;
132   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
133       ProcessingModeDef_ShardingPolicy_entries,
134       ProcessingModeDef_ShardingPolicy_entries_by_number,
135       6, value);
136   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
137                      ProcessingModeDef_ShardingPolicy_strings[idx].get();
138 }
ProcessingModeDef_ShardingPolicy_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,ProcessingModeDef_ShardingPolicy * value)139 bool ProcessingModeDef_ShardingPolicy_Parse(
140     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ProcessingModeDef_ShardingPolicy* value) {
141   int int_value;
142   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
143       ProcessingModeDef_ShardingPolicy_entries, 6, name, &int_value);
144   if (success) {
145     *value = static_cast<ProcessingModeDef_ShardingPolicy>(int_value);
146   }
147   return success;
148 }
149 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
150 constexpr ProcessingModeDef_ShardingPolicy ProcessingModeDef::OFF;
151 constexpr ProcessingModeDef_ShardingPolicy ProcessingModeDef::DYNAMIC;
152 constexpr ProcessingModeDef_ShardingPolicy ProcessingModeDef::FILE;
153 constexpr ProcessingModeDef_ShardingPolicy ProcessingModeDef::DATA;
154 constexpr ProcessingModeDef_ShardingPolicy ProcessingModeDef::FILE_OR_DATA;
155 constexpr ProcessingModeDef_ShardingPolicy ProcessingModeDef::HINT;
156 constexpr ProcessingModeDef_ShardingPolicy ProcessingModeDef::ShardingPolicy_MIN;
157 constexpr ProcessingModeDef_ShardingPolicy ProcessingModeDef::ShardingPolicy_MAX;
158 constexpr int ProcessingModeDef::ShardingPolicy_ARRAYSIZE;
159 #endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
DataServiceMetadata_Compression_IsValid(int value)160 bool DataServiceMetadata_Compression_IsValid(int value) {
161   switch (value) {
162     case 0:
163     case 1:
164     case 2:
165       return true;
166     default:
167       return false;
168   }
169 }
170 
171 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> DataServiceMetadata_Compression_strings[3] = {};
172 
173 static const char DataServiceMetadata_Compression_names[] =
174   "COMPRESSION_OFF"
175   "COMPRESSION_SNAPPY"
176   "COMPRESSION_UNSPECIFIED";
177 
178 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry DataServiceMetadata_Compression_entries[] = {
179   { {DataServiceMetadata_Compression_names + 0, 15}, 1 },
180   { {DataServiceMetadata_Compression_names + 15, 18}, 2 },
181   { {DataServiceMetadata_Compression_names + 33, 23}, 0 },
182 };
183 
184 static const int DataServiceMetadata_Compression_entries_by_number[] = {
185   2, // 0 -> COMPRESSION_UNSPECIFIED
186   0, // 1 -> COMPRESSION_OFF
187   1, // 2 -> COMPRESSION_SNAPPY
188 };
189 
DataServiceMetadata_Compression_Name(DataServiceMetadata_Compression value)190 const std::string& DataServiceMetadata_Compression_Name(
191     DataServiceMetadata_Compression value) {
192   static const bool dummy =
193       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
194           DataServiceMetadata_Compression_entries,
195           DataServiceMetadata_Compression_entries_by_number,
196           3, DataServiceMetadata_Compression_strings);
197   (void) dummy;
198   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
199       DataServiceMetadata_Compression_entries,
200       DataServiceMetadata_Compression_entries_by_number,
201       3, value);
202   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
203                      DataServiceMetadata_Compression_strings[idx].get();
204 }
DataServiceMetadata_Compression_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,DataServiceMetadata_Compression * value)205 bool DataServiceMetadata_Compression_Parse(
206     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DataServiceMetadata_Compression* value) {
207   int int_value;
208   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
209       DataServiceMetadata_Compression_entries, 3, name, &int_value);
210   if (success) {
211     *value = static_cast<DataServiceMetadata_Compression>(int_value);
212   }
213   return success;
214 }
215 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
216 constexpr DataServiceMetadata_Compression DataServiceMetadata::COMPRESSION_UNSPECIFIED;
217 constexpr DataServiceMetadata_Compression DataServiceMetadata::COMPRESSION_OFF;
218 constexpr DataServiceMetadata_Compression DataServiceMetadata::COMPRESSION_SNAPPY;
219 constexpr DataServiceMetadata_Compression DataServiceMetadata::Compression_MIN;
220 constexpr DataServiceMetadata_Compression DataServiceMetadata::Compression_MAX;
221 constexpr int DataServiceMetadata::Compression_ARRAYSIZE;
222 #endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
DeploymentMode_IsValid(int value)223 bool DeploymentMode_IsValid(int value) {
224   switch (value) {
225     case 0:
226     case 1:
227     case 2:
228     case 3:
229       return true;
230     default:
231       return false;
232   }
233 }
234 
235 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> DeploymentMode_strings[4] = {};
236 
237 static const char DeploymentMode_names[] =
238   "DEPLOYMENT_MODE_COLOCATED"
239   "DEPLOYMENT_MODE_HYBRID"
240   "DEPLOYMENT_MODE_REMOTE"
241   "DEPLOYMENT_MODE_UNSPECIFIED";
242 
243 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry DeploymentMode_entries[] = {
244   { {DeploymentMode_names + 0, 25}, 1 },
245   { {DeploymentMode_names + 25, 22}, 3 },
246   { {DeploymentMode_names + 47, 22}, 2 },
247   { {DeploymentMode_names + 69, 27}, 0 },
248 };
249 
250 static const int DeploymentMode_entries_by_number[] = {
251   3, // 0 -> DEPLOYMENT_MODE_UNSPECIFIED
252   0, // 1 -> DEPLOYMENT_MODE_COLOCATED
253   2, // 2 -> DEPLOYMENT_MODE_REMOTE
254   1, // 3 -> DEPLOYMENT_MODE_HYBRID
255 };
256 
DeploymentMode_Name(DeploymentMode value)257 const std::string& DeploymentMode_Name(
258     DeploymentMode value) {
259   static const bool dummy =
260       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
261           DeploymentMode_entries,
262           DeploymentMode_entries_by_number,
263           4, DeploymentMode_strings);
264   (void) dummy;
265   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
266       DeploymentMode_entries,
267       DeploymentMode_entries_by_number,
268       4, value);
269   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
270                      DeploymentMode_strings[idx].get();
271 }
DeploymentMode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,DeploymentMode * value)272 bool DeploymentMode_Parse(
273     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeploymentMode* value) {
274   int int_value;
275   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
276       DeploymentMode_entries, 4, name, &int_value);
277   if (success) {
278     *value = static_cast<DeploymentMode>(int_value);
279   }
280   return success;
281 }
282 
283 // ===================================================================
284 
285 class ProcessingModeDef::_Internal {
286  public:
287 };
288 
ProcessingModeDef(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)289 ProcessingModeDef::ProcessingModeDef(::PROTOBUF_NAMESPACE_ID::Arena* arena,
290                          bool is_message_owned)
291   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
292   SharedCtor(arena, is_message_owned);
293   // @@protoc_insertion_point(arena_constructor:tensorflow.data.ProcessingModeDef)
294 }
ProcessingModeDef(const ProcessingModeDef & from)295 ProcessingModeDef::ProcessingModeDef(const ProcessingModeDef& from)
296   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
297   ProcessingModeDef* const _this = this; (void)_this;
298   new (&_impl_) Impl_{
299       decltype(_impl_.sharding_policy_){}
300     , /*decltype(_impl_._cached_size_)*/{}};
301 
302   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
303   _this->_impl_.sharding_policy_ = from._impl_.sharding_policy_;
304   // @@protoc_insertion_point(copy_constructor:tensorflow.data.ProcessingModeDef)
305 }
306 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)307 inline void ProcessingModeDef::SharedCtor(
308     ::_pb::Arena* arena, bool is_message_owned) {
309   (void)arena;
310   (void)is_message_owned;
311   new (&_impl_) Impl_{
312       decltype(_impl_.sharding_policy_){0}
313     , /*decltype(_impl_._cached_size_)*/{}
314   };
315 }
316 
~ProcessingModeDef()317 ProcessingModeDef::~ProcessingModeDef() {
318   // @@protoc_insertion_point(destructor:tensorflow.data.ProcessingModeDef)
319   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
320   (void)arena;
321     return;
322   }
323   SharedDtor();
324 }
325 
SharedDtor()326 inline void ProcessingModeDef::SharedDtor() {
327   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
328 }
329 
SetCachedSize(int size) const330 void ProcessingModeDef::SetCachedSize(int size) const {
331   _impl_._cached_size_.Set(size);
332 }
333 
Clear()334 void ProcessingModeDef::Clear() {
335 // @@protoc_insertion_point(message_clear_start:tensorflow.data.ProcessingModeDef)
336   ::uint32_t cached_has_bits = 0;
337   // Prevent compiler warnings about cached_has_bits being unused
338   (void) cached_has_bits;
339 
340   _impl_.sharding_policy_ = 0;
341   _internal_metadata_.Clear<std::string>();
342 }
343 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)344 const char* ProcessingModeDef::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
345 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
346   while (!ctx->Done(&ptr)) {
347     ::uint32_t tag;
348     ptr = ::_pbi::ReadTag(ptr, &tag);
349     switch (tag >> 3) {
350       // .tensorflow.data.ProcessingModeDef.ShardingPolicy sharding_policy = 1;
351       case 1:
352         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
353           ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
354           CHK_(ptr);
355           _internal_set_sharding_policy(static_cast<::tensorflow::data::ProcessingModeDef_ShardingPolicy>(val));
356         } else {
357           goto handle_unusual;
358         }
359         continue;
360       default:
361         goto handle_unusual;
362     }  // switch
363   handle_unusual:
364     if ((tag == 0) || ((tag & 7) == 4)) {
365       CHK_(ptr);
366       ctx->SetLastTag(tag);
367       goto message_done;
368     }
369     ptr = UnknownFieldParse(
370         tag,
371         _internal_metadata_.mutable_unknown_fields<std::string>(),
372         ptr, ctx);
373     CHK_(ptr != nullptr);
374   }  // while
375 message_done:
376   return ptr;
377 failure:
378   ptr = nullptr;
379   goto message_done;
380 #undef CHK_
381 }
382 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const383 ::uint8_t* ProcessingModeDef::_InternalSerialize(
384     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
385   // @@protoc_insertion_point(serialize_to_array_start:tensorflow.data.ProcessingModeDef)
386   ::uint32_t cached_has_bits = 0;
387   (void) cached_has_bits;
388 
389   // .tensorflow.data.ProcessingModeDef.ShardingPolicy sharding_policy = 1;
390   if (this->_internal_sharding_policy() != 0) {
391     target = stream->EnsureSpace(target);
392     target = ::_pbi::WireFormatLite::WriteEnumToArray(
393       1, this->_internal_sharding_policy(), target);
394   }
395 
396   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
397     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
398         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
399   }
400   // @@protoc_insertion_point(serialize_to_array_end:tensorflow.data.ProcessingModeDef)
401   return target;
402 }
403 
ByteSizeLong() const404 size_t ProcessingModeDef::ByteSizeLong() const {
405 // @@protoc_insertion_point(message_byte_size_start:tensorflow.data.ProcessingModeDef)
406   size_t total_size = 0;
407 
408   ::uint32_t cached_has_bits = 0;
409   // Prevent compiler warnings about cached_has_bits being unused
410   (void) cached_has_bits;
411 
412   // .tensorflow.data.ProcessingModeDef.ShardingPolicy sharding_policy = 1;
413   if (this->_internal_sharding_policy() != 0) {
414     total_size += 1 +
415       ::_pbi::WireFormatLite::EnumSize(this->_internal_sharding_policy());
416   }
417 
418   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
419     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
420   }
421   int cached_size = ::_pbi::ToCachedSize(total_size);
422   SetCachedSize(cached_size);
423   return total_size;
424 }
425 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)426 void ProcessingModeDef::CheckTypeAndMergeFrom(
427     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
428   MergeFrom(*::_pbi::DownCast<const ProcessingModeDef*>(
429       &from));
430 }
431 
MergeFrom(const ProcessingModeDef & from)432 void ProcessingModeDef::MergeFrom(const ProcessingModeDef& from) {
433   ProcessingModeDef* const _this = this;
434   // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.data.ProcessingModeDef)
435   GOOGLE_DCHECK_NE(&from, _this);
436   ::uint32_t cached_has_bits = 0;
437   (void) cached_has_bits;
438 
439   if (from._internal_sharding_policy() != 0) {
440     _this->_internal_set_sharding_policy(from._internal_sharding_policy());
441   }
442   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
443 }
444 
CopyFrom(const ProcessingModeDef & from)445 void ProcessingModeDef::CopyFrom(const ProcessingModeDef& from) {
446 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.data.ProcessingModeDef)
447   if (&from == this) return;
448   Clear();
449   MergeFrom(from);
450 }
451 
IsInitialized() const452 bool ProcessingModeDef::IsInitialized() const {
453   return true;
454 }
455 
InternalSwap(ProcessingModeDef * other)456 void ProcessingModeDef::InternalSwap(ProcessingModeDef* other) {
457   using std::swap;
458   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
459   swap(_impl_.sharding_policy_, other->_impl_.sharding_policy_);
460 }
461 
GetTypeName() const462 std::string ProcessingModeDef::GetTypeName() const {
463   return "tensorflow.data.ProcessingModeDef";
464 }
465 
466 
467 // ===================================================================
468 
469 class DataServiceMetadata::_Internal {
470  public:
471 };
472 
DataServiceMetadata(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)473 DataServiceMetadata::DataServiceMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
474                          bool is_message_owned)
475   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
476   SharedCtor(arena, is_message_owned);
477   // @@protoc_insertion_point(arena_constructor:tensorflow.data.DataServiceMetadata)
478 }
DataServiceMetadata(const DataServiceMetadata & from)479 DataServiceMetadata::DataServiceMetadata(const DataServiceMetadata& from)
480   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
481   DataServiceMetadata* const _this = this; (void)_this;
482   new (&_impl_) Impl_{
483       decltype(_impl_.cardinality_){}
484     , decltype(_impl_.compression_){}
485     , decltype(_impl_.optional_element_spec_){}
486     , /*decltype(_impl_._cached_size_)*/{}
487     , /*decltype(_impl_._oneof_case_)*/{}};
488 
489   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
490   ::memcpy(&_impl_.cardinality_, &from._impl_.cardinality_,
491     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.compression_) -
492     reinterpret_cast<char*>(&_impl_.cardinality_)) + sizeof(_impl_.compression_));
493   clear_has_optional_element_spec();
494   switch (from.optional_element_spec_case()) {
495     case kElementSpec: {
496       _this->_internal_set_element_spec(from._internal_element_spec());
497       break;
498     }
499     case OPTIONAL_ELEMENT_SPEC_NOT_SET: {
500       break;
501     }
502   }
503   // @@protoc_insertion_point(copy_constructor:tensorflow.data.DataServiceMetadata)
504 }
505 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)506 inline void DataServiceMetadata::SharedCtor(
507     ::_pb::Arena* arena, bool is_message_owned) {
508   (void)arena;
509   (void)is_message_owned;
510   new (&_impl_) Impl_{
511       decltype(_impl_.cardinality_){::int64_t{0}}
512     , decltype(_impl_.compression_){0}
513     , decltype(_impl_.optional_element_spec_){}
514     , /*decltype(_impl_._cached_size_)*/{}
515     , /*decltype(_impl_._oneof_case_)*/{}
516   };
517   clear_has_optional_element_spec();
518 }
519 
~DataServiceMetadata()520 DataServiceMetadata::~DataServiceMetadata() {
521   // @@protoc_insertion_point(destructor:tensorflow.data.DataServiceMetadata)
522   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
523   (void)arena;
524     return;
525   }
526   SharedDtor();
527 }
528 
SharedDtor()529 inline void DataServiceMetadata::SharedDtor() {
530   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
531   if (has_optional_element_spec()) {
532     clear_optional_element_spec();
533   }
534 }
535 
SetCachedSize(int size) const536 void DataServiceMetadata::SetCachedSize(int size) const {
537   _impl_._cached_size_.Set(size);
538 }
539 
clear_optional_element_spec()540 void DataServiceMetadata::clear_optional_element_spec() {
541 // @@protoc_insertion_point(one_of_clear_start:tensorflow.data.DataServiceMetadata)
542   switch (optional_element_spec_case()) {
543     case kElementSpec: {
544       _impl_.optional_element_spec_.element_spec_.Destroy();
545       break;
546     }
547     case OPTIONAL_ELEMENT_SPEC_NOT_SET: {
548       break;
549     }
550   }
551   _impl_._oneof_case_[0] = OPTIONAL_ELEMENT_SPEC_NOT_SET;
552 }
553 
554 
Clear()555 void DataServiceMetadata::Clear() {
556 // @@protoc_insertion_point(message_clear_start:tensorflow.data.DataServiceMetadata)
557   ::uint32_t cached_has_bits = 0;
558   // Prevent compiler warnings about cached_has_bits being unused
559   (void) cached_has_bits;
560 
561   ::memset(&_impl_.cardinality_, 0, static_cast<size_t>(
562       reinterpret_cast<char*>(&_impl_.compression_) -
563       reinterpret_cast<char*>(&_impl_.cardinality_)) + sizeof(_impl_.compression_));
564   clear_optional_element_spec();
565   _internal_metadata_.Clear<std::string>();
566 }
567 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)568 const char* DataServiceMetadata::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
569 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
570   while (!ctx->Done(&ptr)) {
571     ::uint32_t tag;
572     ptr = ::_pbi::ReadTag(ptr, &tag);
573     switch (tag >> 3) {
574       // bytes element_spec = 1;
575       case 1:
576         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
577           auto str = _internal_mutable_element_spec();
578           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
579           CHK_(ptr);
580         } else {
581           goto handle_unusual;
582         }
583         continue;
584       // .tensorflow.data.DataServiceMetadata.Compression compression = 2;
585       case 2:
586         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
587           ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
588           CHK_(ptr);
589           _internal_set_compression(static_cast<::tensorflow::data::DataServiceMetadata_Compression>(val));
590         } else {
591           goto handle_unusual;
592         }
593         continue;
594       // int64 cardinality = 3;
595       case 3:
596         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
597           _impl_.cardinality_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
598           CHK_(ptr);
599         } else {
600           goto handle_unusual;
601         }
602         continue;
603       default:
604         goto handle_unusual;
605     }  // switch
606   handle_unusual:
607     if ((tag == 0) || ((tag & 7) == 4)) {
608       CHK_(ptr);
609       ctx->SetLastTag(tag);
610       goto message_done;
611     }
612     ptr = UnknownFieldParse(
613         tag,
614         _internal_metadata_.mutable_unknown_fields<std::string>(),
615         ptr, ctx);
616     CHK_(ptr != nullptr);
617   }  // while
618 message_done:
619   return ptr;
620 failure:
621   ptr = nullptr;
622   goto message_done;
623 #undef CHK_
624 }
625 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const626 ::uint8_t* DataServiceMetadata::_InternalSerialize(
627     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
628   // @@protoc_insertion_point(serialize_to_array_start:tensorflow.data.DataServiceMetadata)
629   ::uint32_t cached_has_bits = 0;
630   (void) cached_has_bits;
631 
632   // bytes element_spec = 1;
633   if (_internal_has_element_spec()) {
634     target = stream->WriteBytesMaybeAliased(
635         1, this->_internal_element_spec(), target);
636   }
637 
638   // .tensorflow.data.DataServiceMetadata.Compression compression = 2;
639   if (this->_internal_compression() != 0) {
640     target = stream->EnsureSpace(target);
641     target = ::_pbi::WireFormatLite::WriteEnumToArray(
642       2, this->_internal_compression(), target);
643   }
644 
645   // int64 cardinality = 3;
646   if (this->_internal_cardinality() != 0) {
647     target = stream->EnsureSpace(target);
648     target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_cardinality(), target);
649   }
650 
651   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
652     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
653         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
654   }
655   // @@protoc_insertion_point(serialize_to_array_end:tensorflow.data.DataServiceMetadata)
656   return target;
657 }
658 
ByteSizeLong() const659 size_t DataServiceMetadata::ByteSizeLong() const {
660 // @@protoc_insertion_point(message_byte_size_start:tensorflow.data.DataServiceMetadata)
661   size_t total_size = 0;
662 
663   ::uint32_t cached_has_bits = 0;
664   // Prevent compiler warnings about cached_has_bits being unused
665   (void) cached_has_bits;
666 
667   // int64 cardinality = 3;
668   if (this->_internal_cardinality() != 0) {
669     total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_cardinality());
670   }
671 
672   // .tensorflow.data.DataServiceMetadata.Compression compression = 2;
673   if (this->_internal_compression() != 0) {
674     total_size += 1 +
675       ::_pbi::WireFormatLite::EnumSize(this->_internal_compression());
676   }
677 
678   switch (optional_element_spec_case()) {
679     // bytes element_spec = 1;
680     case kElementSpec: {
681       total_size += 1 +
682         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
683           this->_internal_element_spec());
684       break;
685     }
686     case OPTIONAL_ELEMENT_SPEC_NOT_SET: {
687       break;
688     }
689   }
690   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
691     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
692   }
693   int cached_size = ::_pbi::ToCachedSize(total_size);
694   SetCachedSize(cached_size);
695   return total_size;
696 }
697 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)698 void DataServiceMetadata::CheckTypeAndMergeFrom(
699     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
700   MergeFrom(*::_pbi::DownCast<const DataServiceMetadata*>(
701       &from));
702 }
703 
MergeFrom(const DataServiceMetadata & from)704 void DataServiceMetadata::MergeFrom(const DataServiceMetadata& from) {
705   DataServiceMetadata* const _this = this;
706   // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.data.DataServiceMetadata)
707   GOOGLE_DCHECK_NE(&from, _this);
708   ::uint32_t cached_has_bits = 0;
709   (void) cached_has_bits;
710 
711   if (from._internal_cardinality() != 0) {
712     _this->_internal_set_cardinality(from._internal_cardinality());
713   }
714   if (from._internal_compression() != 0) {
715     _this->_internal_set_compression(from._internal_compression());
716   }
717   switch (from.optional_element_spec_case()) {
718     case kElementSpec: {
719       _this->_internal_set_element_spec(from._internal_element_spec());
720       break;
721     }
722     case OPTIONAL_ELEMENT_SPEC_NOT_SET: {
723       break;
724     }
725   }
726   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
727 }
728 
CopyFrom(const DataServiceMetadata & from)729 void DataServiceMetadata::CopyFrom(const DataServiceMetadata& from) {
730 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.data.DataServiceMetadata)
731   if (&from == this) return;
732   Clear();
733   MergeFrom(from);
734 }
735 
IsInitialized() const736 bool DataServiceMetadata::IsInitialized() const {
737   return true;
738 }
739 
InternalSwap(DataServiceMetadata * other)740 void DataServiceMetadata::InternalSwap(DataServiceMetadata* other) {
741   using std::swap;
742   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
743   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
744       PROTOBUF_FIELD_OFFSET(DataServiceMetadata, _impl_.compression_)
745       + sizeof(DataServiceMetadata::_impl_.compression_)  // NOLINT
746       - PROTOBUF_FIELD_OFFSET(DataServiceMetadata, _impl_.cardinality_)>(
747           reinterpret_cast<char*>(&_impl_.cardinality_),
748           reinterpret_cast<char*>(&other->_impl_.cardinality_));
749   swap(_impl_.optional_element_spec_, other->_impl_.optional_element_spec_);
750   swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
751 }
752 
GetTypeName() const753 std::string DataServiceMetadata::GetTypeName() const {
754   return "tensorflow.data.DataServiceMetadata";
755 }
756 
757 
758 // ===================================================================
759 
760 class CrossTrainerCacheOptions::_Internal {
761  public:
762 };
763 
CrossTrainerCacheOptions(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)764 CrossTrainerCacheOptions::CrossTrainerCacheOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
765                          bool is_message_owned)
766   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
767   SharedCtor(arena, is_message_owned);
768   // @@protoc_insertion_point(arena_constructor:tensorflow.data.CrossTrainerCacheOptions)
769 }
CrossTrainerCacheOptions(const CrossTrainerCacheOptions & from)770 CrossTrainerCacheOptions::CrossTrainerCacheOptions(const CrossTrainerCacheOptions& from)
771   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
772   CrossTrainerCacheOptions* const _this = this; (void)_this;
773   new (&_impl_) Impl_{
774       decltype(_impl_.trainer_id_){}
775     , /*decltype(_impl_._cached_size_)*/{}};
776 
777   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
778   _impl_.trainer_id_.InitDefault();
779   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
780     _impl_.trainer_id_.Set("", GetArenaForAllocation());
781   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
782   if (!from._internal_trainer_id().empty()) {
783     _this->_impl_.trainer_id_.Set(from._internal_trainer_id(),
784       _this->GetArenaForAllocation());
785   }
786   // @@protoc_insertion_point(copy_constructor:tensorflow.data.CrossTrainerCacheOptions)
787 }
788 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)789 inline void CrossTrainerCacheOptions::SharedCtor(
790     ::_pb::Arena* arena, bool is_message_owned) {
791   (void)arena;
792   (void)is_message_owned;
793   new (&_impl_) Impl_{
794       decltype(_impl_.trainer_id_){}
795     , /*decltype(_impl_._cached_size_)*/{}
796   };
797   _impl_.trainer_id_.InitDefault();
798   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
799     _impl_.trainer_id_.Set("", GetArenaForAllocation());
800   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
801 }
802 
~CrossTrainerCacheOptions()803 CrossTrainerCacheOptions::~CrossTrainerCacheOptions() {
804   // @@protoc_insertion_point(destructor:tensorflow.data.CrossTrainerCacheOptions)
805   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
806   (void)arena;
807     return;
808   }
809   SharedDtor();
810 }
811 
SharedDtor()812 inline void CrossTrainerCacheOptions::SharedDtor() {
813   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
814   _impl_.trainer_id_.Destroy();
815 }
816 
SetCachedSize(int size) const817 void CrossTrainerCacheOptions::SetCachedSize(int size) const {
818   _impl_._cached_size_.Set(size);
819 }
820 
Clear()821 void CrossTrainerCacheOptions::Clear() {
822 // @@protoc_insertion_point(message_clear_start:tensorflow.data.CrossTrainerCacheOptions)
823   ::uint32_t cached_has_bits = 0;
824   // Prevent compiler warnings about cached_has_bits being unused
825   (void) cached_has_bits;
826 
827   _impl_.trainer_id_.ClearToEmpty();
828   _internal_metadata_.Clear<std::string>();
829 }
830 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)831 const char* CrossTrainerCacheOptions::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
832 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
833   while (!ctx->Done(&ptr)) {
834     ::uint32_t tag;
835     ptr = ::_pbi::ReadTag(ptr, &tag);
836     switch (tag >> 3) {
837       // string trainer_id = 1;
838       case 1:
839         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
840           auto str = _internal_mutable_trainer_id();
841           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
842           CHK_(ptr);
843           CHK_(::_pbi::VerifyUTF8(str, nullptr));
844         } else {
845           goto handle_unusual;
846         }
847         continue;
848       default:
849         goto handle_unusual;
850     }  // switch
851   handle_unusual:
852     if ((tag == 0) || ((tag & 7) == 4)) {
853       CHK_(ptr);
854       ctx->SetLastTag(tag);
855       goto message_done;
856     }
857     ptr = UnknownFieldParse(
858         tag,
859         _internal_metadata_.mutable_unknown_fields<std::string>(),
860         ptr, ctx);
861     CHK_(ptr != nullptr);
862   }  // while
863 message_done:
864   return ptr;
865 failure:
866   ptr = nullptr;
867   goto message_done;
868 #undef CHK_
869 }
870 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const871 ::uint8_t* CrossTrainerCacheOptions::_InternalSerialize(
872     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
873   // @@protoc_insertion_point(serialize_to_array_start:tensorflow.data.CrossTrainerCacheOptions)
874   ::uint32_t cached_has_bits = 0;
875   (void) cached_has_bits;
876 
877   // string trainer_id = 1;
878   if (!this->_internal_trainer_id().empty()) {
879     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
880       this->_internal_trainer_id().data(), static_cast<int>(this->_internal_trainer_id().length()),
881       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
882       "tensorflow.data.CrossTrainerCacheOptions.trainer_id");
883     target = stream->WriteStringMaybeAliased(
884         1, this->_internal_trainer_id(), target);
885   }
886 
887   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
888     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
889         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
890   }
891   // @@protoc_insertion_point(serialize_to_array_end:tensorflow.data.CrossTrainerCacheOptions)
892   return target;
893 }
894 
ByteSizeLong() const895 size_t CrossTrainerCacheOptions::ByteSizeLong() const {
896 // @@protoc_insertion_point(message_byte_size_start:tensorflow.data.CrossTrainerCacheOptions)
897   size_t total_size = 0;
898 
899   ::uint32_t cached_has_bits = 0;
900   // Prevent compiler warnings about cached_has_bits being unused
901   (void) cached_has_bits;
902 
903   // string trainer_id = 1;
904   if (!this->_internal_trainer_id().empty()) {
905     total_size += 1 +
906       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
907         this->_internal_trainer_id());
908   }
909 
910   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
911     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
912   }
913   int cached_size = ::_pbi::ToCachedSize(total_size);
914   SetCachedSize(cached_size);
915   return total_size;
916 }
917 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)918 void CrossTrainerCacheOptions::CheckTypeAndMergeFrom(
919     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
920   MergeFrom(*::_pbi::DownCast<const CrossTrainerCacheOptions*>(
921       &from));
922 }
923 
MergeFrom(const CrossTrainerCacheOptions & from)924 void CrossTrainerCacheOptions::MergeFrom(const CrossTrainerCacheOptions& from) {
925   CrossTrainerCacheOptions* const _this = this;
926   // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.data.CrossTrainerCacheOptions)
927   GOOGLE_DCHECK_NE(&from, _this);
928   ::uint32_t cached_has_bits = 0;
929   (void) cached_has_bits;
930 
931   if (!from._internal_trainer_id().empty()) {
932     _this->_internal_set_trainer_id(from._internal_trainer_id());
933   }
934   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
935 }
936 
CopyFrom(const CrossTrainerCacheOptions & from)937 void CrossTrainerCacheOptions::CopyFrom(const CrossTrainerCacheOptions& from) {
938 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.data.CrossTrainerCacheOptions)
939   if (&from == this) return;
940   Clear();
941   MergeFrom(from);
942 }
943 
IsInitialized() const944 bool CrossTrainerCacheOptions::IsInitialized() const {
945   return true;
946 }
947 
InternalSwap(CrossTrainerCacheOptions * other)948 void CrossTrainerCacheOptions::InternalSwap(CrossTrainerCacheOptions* other) {
949   using std::swap;
950   auto* lhs_arena = GetArenaForAllocation();
951   auto* rhs_arena = other->GetArenaForAllocation();
952   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
953   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
954       &_impl_.trainer_id_, lhs_arena,
955       &other->_impl_.trainer_id_, rhs_arena
956   );
957 }
958 
GetTypeName() const959 std::string CrossTrainerCacheOptions::GetTypeName() const {
960   return "tensorflow.data.CrossTrainerCacheOptions";
961 }
962 
963 
964 // ===================================================================
965 
966 class DataServiceConfig::_Internal {
967  public:
968 };
969 
DataServiceConfig(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)970 DataServiceConfig::DataServiceConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
971                          bool is_message_owned)
972   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
973   SharedCtor(arena, is_message_owned);
974   // @@protoc_insertion_point(arena_constructor:tensorflow.data.DataServiceConfig)
975 }
DataServiceConfig(const DataServiceConfig & from)976 DataServiceConfig::DataServiceConfig(const DataServiceConfig& from)
977   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
978   DataServiceConfig* const _this = this; (void)_this;
979   new (&_impl_) Impl_{
980       decltype(_impl_.deployment_mode_){}
981     , /*decltype(_impl_._cached_size_)*/{}};
982 
983   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
984   _this->_impl_.deployment_mode_ = from._impl_.deployment_mode_;
985   // @@protoc_insertion_point(copy_constructor:tensorflow.data.DataServiceConfig)
986 }
987 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)988 inline void DataServiceConfig::SharedCtor(
989     ::_pb::Arena* arena, bool is_message_owned) {
990   (void)arena;
991   (void)is_message_owned;
992   new (&_impl_) Impl_{
993       decltype(_impl_.deployment_mode_){0}
994     , /*decltype(_impl_._cached_size_)*/{}
995   };
996 }
997 
~DataServiceConfig()998 DataServiceConfig::~DataServiceConfig() {
999   // @@protoc_insertion_point(destructor:tensorflow.data.DataServiceConfig)
1000   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1001   (void)arena;
1002     return;
1003   }
1004   SharedDtor();
1005 }
1006 
SharedDtor()1007 inline void DataServiceConfig::SharedDtor() {
1008   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1009 }
1010 
SetCachedSize(int size) const1011 void DataServiceConfig::SetCachedSize(int size) const {
1012   _impl_._cached_size_.Set(size);
1013 }
1014 
Clear()1015 void DataServiceConfig::Clear() {
1016 // @@protoc_insertion_point(message_clear_start:tensorflow.data.DataServiceConfig)
1017   ::uint32_t cached_has_bits = 0;
1018   // Prevent compiler warnings about cached_has_bits being unused
1019   (void) cached_has_bits;
1020 
1021   _impl_.deployment_mode_ = 0;
1022   _internal_metadata_.Clear<std::string>();
1023 }
1024 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1025 const char* DataServiceConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1026 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1027   while (!ctx->Done(&ptr)) {
1028     ::uint32_t tag;
1029     ptr = ::_pbi::ReadTag(ptr, &tag);
1030     switch (tag >> 3) {
1031       // .tensorflow.data.DeploymentMode deployment_mode = 1;
1032       case 1:
1033         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1034           ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1035           CHK_(ptr);
1036           _internal_set_deployment_mode(static_cast<::tensorflow::data::DeploymentMode>(val));
1037         } else {
1038           goto handle_unusual;
1039         }
1040         continue;
1041       default:
1042         goto handle_unusual;
1043     }  // switch
1044   handle_unusual:
1045     if ((tag == 0) || ((tag & 7) == 4)) {
1046       CHK_(ptr);
1047       ctx->SetLastTag(tag);
1048       goto message_done;
1049     }
1050     ptr = UnknownFieldParse(
1051         tag,
1052         _internal_metadata_.mutable_unknown_fields<std::string>(),
1053         ptr, ctx);
1054     CHK_(ptr != nullptr);
1055   }  // while
1056 message_done:
1057   return ptr;
1058 failure:
1059   ptr = nullptr;
1060   goto message_done;
1061 #undef CHK_
1062 }
1063 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1064 ::uint8_t* DataServiceConfig::_InternalSerialize(
1065     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1066   // @@protoc_insertion_point(serialize_to_array_start:tensorflow.data.DataServiceConfig)
1067   ::uint32_t cached_has_bits = 0;
1068   (void) cached_has_bits;
1069 
1070   // .tensorflow.data.DeploymentMode deployment_mode = 1;
1071   if (this->_internal_deployment_mode() != 0) {
1072     target = stream->EnsureSpace(target);
1073     target = ::_pbi::WireFormatLite::WriteEnumToArray(
1074       1, this->_internal_deployment_mode(), target);
1075   }
1076 
1077   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1078     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1079         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1080   }
1081   // @@protoc_insertion_point(serialize_to_array_end:tensorflow.data.DataServiceConfig)
1082   return target;
1083 }
1084 
ByteSizeLong() const1085 size_t DataServiceConfig::ByteSizeLong() const {
1086 // @@protoc_insertion_point(message_byte_size_start:tensorflow.data.DataServiceConfig)
1087   size_t total_size = 0;
1088 
1089   ::uint32_t cached_has_bits = 0;
1090   // Prevent compiler warnings about cached_has_bits being unused
1091   (void) cached_has_bits;
1092 
1093   // .tensorflow.data.DeploymentMode deployment_mode = 1;
1094   if (this->_internal_deployment_mode() != 0) {
1095     total_size += 1 +
1096       ::_pbi::WireFormatLite::EnumSize(this->_internal_deployment_mode());
1097   }
1098 
1099   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1100     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1101   }
1102   int cached_size = ::_pbi::ToCachedSize(total_size);
1103   SetCachedSize(cached_size);
1104   return total_size;
1105 }
1106 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1107 void DataServiceConfig::CheckTypeAndMergeFrom(
1108     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1109   MergeFrom(*::_pbi::DownCast<const DataServiceConfig*>(
1110       &from));
1111 }
1112 
MergeFrom(const DataServiceConfig & from)1113 void DataServiceConfig::MergeFrom(const DataServiceConfig& from) {
1114   DataServiceConfig* const _this = this;
1115   // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.data.DataServiceConfig)
1116   GOOGLE_DCHECK_NE(&from, _this);
1117   ::uint32_t cached_has_bits = 0;
1118   (void) cached_has_bits;
1119 
1120   if (from._internal_deployment_mode() != 0) {
1121     _this->_internal_set_deployment_mode(from._internal_deployment_mode());
1122   }
1123   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1124 }
1125 
CopyFrom(const DataServiceConfig & from)1126 void DataServiceConfig::CopyFrom(const DataServiceConfig& from) {
1127 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.data.DataServiceConfig)
1128   if (&from == this) return;
1129   Clear();
1130   MergeFrom(from);
1131 }
1132 
IsInitialized() const1133 bool DataServiceConfig::IsInitialized() const {
1134   return true;
1135 }
1136 
InternalSwap(DataServiceConfig * other)1137 void DataServiceConfig::InternalSwap(DataServiceConfig* other) {
1138   using std::swap;
1139   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1140   swap(_impl_.deployment_mode_, other->_impl_.deployment_mode_);
1141 }
1142 
GetTypeName() const1143 std::string DataServiceConfig::GetTypeName() const {
1144   return "tensorflow.data.DataServiceConfig";
1145 }
1146 
1147 
1148 // @@protoc_insertion_point(namespace_scope)
1149 }  // namespace data
1150 }  // namespace tensorflow
1151 PROTOBUF_NAMESPACE_OPEN
1152 template<> PROTOBUF_NOINLINE ::tensorflow::data::ProcessingModeDef*
CreateMaybeMessage(Arena * arena)1153 Arena::CreateMaybeMessage< ::tensorflow::data::ProcessingModeDef >(Arena* arena) {
1154   return Arena::CreateMessageInternal< ::tensorflow::data::ProcessingModeDef >(arena);
1155 }
1156 template<> PROTOBUF_NOINLINE ::tensorflow::data::DataServiceMetadata*
CreateMaybeMessage(Arena * arena)1157 Arena::CreateMaybeMessage< ::tensorflow::data::DataServiceMetadata >(Arena* arena) {
1158   return Arena::CreateMessageInternal< ::tensorflow::data::DataServiceMetadata >(arena);
1159 }
1160 template<> PROTOBUF_NOINLINE ::tensorflow::data::CrossTrainerCacheOptions*
CreateMaybeMessage(Arena * arena)1161 Arena::CreateMaybeMessage< ::tensorflow::data::CrossTrainerCacheOptions >(Arena* arena) {
1162   return Arena::CreateMessageInternal< ::tensorflow::data::CrossTrainerCacheOptions >(arena);
1163 }
1164 template<> PROTOBUF_NOINLINE ::tensorflow::data::DataServiceConfig*
CreateMaybeMessage(Arena * arena)1165 Arena::CreateMaybeMessage< ::tensorflow::data::DataServiceConfig >(Arena* arena) {
1166   return Arena::CreateMessageInternal< ::tensorflow::data::DataServiceConfig >(arena);
1167 }
1168 PROTOBUF_NAMESPACE_CLOSE
1169 
1170 // @@protoc_insertion_point(global_scope)
1171 #include <google/protobuf/port_undef.inc>
1172