1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: fcp/client/fl_runner.proto
3 
4 #include "fcp/client/fl_runner.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 fcp {
22 namespace client {
FLRunnerResult_ExampleStats(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR FLRunnerResult_ExampleStats::FLRunnerResult_ExampleStats(
24     ::_pbi::ConstantInitialized): _impl_{
25     /*decltype(_impl_.example_size_bytes_)*/::int64_t{0}
26   , /*decltype(_impl_.example_count_)*/0
27   , /*decltype(_impl_._cached_size_)*/{}} {}
28 struct FLRunnerResult_ExampleStatsDefaultTypeInternal {
FLRunnerResult_ExampleStatsDefaultTypeInternalfcp::client::FLRunnerResult_ExampleStatsDefaultTypeInternal29   PROTOBUF_CONSTEXPR FLRunnerResult_ExampleStatsDefaultTypeInternal()
30       : _instance(::_pbi::ConstantInitialized{}) {}
~FLRunnerResult_ExampleStatsDefaultTypeInternalfcp::client::FLRunnerResult_ExampleStatsDefaultTypeInternal31   ~FLRunnerResult_ExampleStatsDefaultTypeInternal() {}
32   union {  // NOLINT(misc-non-private-member-variables-in-classes)
33     FLRunnerResult_ExampleStats _instance;
34   };
35 };
36 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FLRunnerResult_ExampleStatsDefaultTypeInternal _FLRunnerResult_ExampleStats_default_instance_;
FLRunnerResult(::_pbi::ConstantInitialized)37 PROTOBUF_CONSTEXPR FLRunnerResult::FLRunnerResult(
38     ::_pbi::ConstantInitialized): _impl_{
39     /*decltype(_impl_.error_message_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
40   , /*decltype(_impl_.retry_info_)*/nullptr
41   , /*decltype(_impl_.example_stats_)*/nullptr
42   , /*decltype(_impl_.contribution_result_)*/0
43   , /*decltype(_impl_.error_status_)*/0
44   , /*decltype(_impl_._cached_size_)*/{}} {}
45 struct FLRunnerResultDefaultTypeInternal {
FLRunnerResultDefaultTypeInternalfcp::client::FLRunnerResultDefaultTypeInternal46   PROTOBUF_CONSTEXPR FLRunnerResultDefaultTypeInternal()
47       : _instance(::_pbi::ConstantInitialized{}) {}
~FLRunnerResultDefaultTypeInternalfcp::client::FLRunnerResultDefaultTypeInternal48   ~FLRunnerResultDefaultTypeInternal() {}
49   union {  // NOLINT(misc-non-private-member-variables-in-classes)
50     FLRunnerResult _instance;
51   };
52 };
53 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FLRunnerResultDefaultTypeInternal _FLRunnerResult_default_instance_;
RetryInfo(::_pbi::ConstantInitialized)54 PROTOBUF_CONSTEXPR RetryInfo::RetryInfo(
55     ::_pbi::ConstantInitialized): _impl_{
56     /*decltype(_impl_.retry_token_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
57   , /*decltype(_impl_.minimum_delay_)*/nullptr
58   , /*decltype(_impl_._cached_size_)*/{}} {}
59 struct RetryInfoDefaultTypeInternal {
RetryInfoDefaultTypeInternalfcp::client::RetryInfoDefaultTypeInternal60   PROTOBUF_CONSTEXPR RetryInfoDefaultTypeInternal()
61       : _instance(::_pbi::ConstantInitialized{}) {}
~RetryInfoDefaultTypeInternalfcp::client::RetryInfoDefaultTypeInternal62   ~RetryInfoDefaultTypeInternal() {}
63   union {  // NOLINT(misc-non-private-member-variables-in-classes)
64     RetryInfo _instance;
65   };
66 };
67 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RetryInfoDefaultTypeInternal _RetryInfo_default_instance_;
FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse(::_pbi::ConstantInitialized)68 PROTOBUF_CONSTEXPR FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse::FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse(
69     ::_pbi::ConstantInitialized) {}
70 struct FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUseDefaultTypeInternal {
FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUseDefaultTypeInternalfcp::client::FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUseDefaultTypeInternal71   PROTOBUF_CONSTEXPR FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUseDefaultTypeInternal()
72       : _instance(::_pbi::ConstantInitialized{}) {}
~FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUseDefaultTypeInternalfcp::client::FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUseDefaultTypeInternal73   ~FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUseDefaultTypeInternal() {}
74   union {  // NOLINT(misc-non-private-member-variables-in-classes)
75     FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse _instance;
76   };
77 };
78 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUseDefaultTypeInternal _FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse_default_instance_;
FLRunnerTensorflowSpecResult(::_pbi::ConstantInitialized)79 PROTOBUF_CONSTEXPR FLRunnerTensorflowSpecResult::FLRunnerTensorflowSpecResult(
80     ::_pbi::ConstantInitialized): _impl_{
81     /*decltype(_impl_.output_tensors_)*/{}
82   , /*decltype(_impl_.checkpoint_output_filename_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
83   , /*decltype(_impl_.outcome_)*/0
84   , /*decltype(_impl_._cached_size_)*/{}} {}
85 struct FLRunnerTensorflowSpecResultDefaultTypeInternal {
FLRunnerTensorflowSpecResultDefaultTypeInternalfcp::client::FLRunnerTensorflowSpecResultDefaultTypeInternal86   PROTOBUF_CONSTEXPR FLRunnerTensorflowSpecResultDefaultTypeInternal()
87       : _instance(::_pbi::ConstantInitialized{}) {}
~FLRunnerTensorflowSpecResultDefaultTypeInternalfcp::client::FLRunnerTensorflowSpecResultDefaultTypeInternal88   ~FLRunnerTensorflowSpecResultDefaultTypeInternal() {}
89   union {  // NOLINT(misc-non-private-member-variables-in-classes)
90     FLRunnerTensorflowSpecResult _instance;
91   };
92 };
93 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FLRunnerTensorflowSpecResultDefaultTypeInternal _FLRunnerTensorflowSpecResult_default_instance_;
94 }  // namespace client
95 }  // namespace fcp
96 namespace fcp {
97 namespace client {
FLRunnerResult_ContributionResult_IsValid(int value)98 bool FLRunnerResult_ContributionResult_IsValid(int value) {
99   switch (value) {
100     case 0:
101     case 1:
102     case 2:
103       return true;
104     default:
105       return false;
106   }
107 }
108 
109 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> FLRunnerResult_ContributionResult_strings[3] = {};
110 
111 static const char FLRunnerResult_ContributionResult_names[] =
112   "FAIL"
113   "SUCCESS"
114   "UNSPECIFIED";
115 
116 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry FLRunnerResult_ContributionResult_entries[] = {
117   { {FLRunnerResult_ContributionResult_names + 0, 4}, 2 },
118   { {FLRunnerResult_ContributionResult_names + 4, 7}, 1 },
119   { {FLRunnerResult_ContributionResult_names + 11, 11}, 0 },
120 };
121 
122 static const int FLRunnerResult_ContributionResult_entries_by_number[] = {
123   2, // 0 -> UNSPECIFIED
124   1, // 1 -> SUCCESS
125   0, // 2 -> FAIL
126 };
127 
FLRunnerResult_ContributionResult_Name(FLRunnerResult_ContributionResult value)128 const std::string& FLRunnerResult_ContributionResult_Name(
129     FLRunnerResult_ContributionResult value) {
130   static const bool dummy =
131       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
132           FLRunnerResult_ContributionResult_entries,
133           FLRunnerResult_ContributionResult_entries_by_number,
134           3, FLRunnerResult_ContributionResult_strings);
135   (void) dummy;
136   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
137       FLRunnerResult_ContributionResult_entries,
138       FLRunnerResult_ContributionResult_entries_by_number,
139       3, value);
140   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
141                      FLRunnerResult_ContributionResult_strings[idx].get();
142 }
FLRunnerResult_ContributionResult_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,FLRunnerResult_ContributionResult * value)143 bool FLRunnerResult_ContributionResult_Parse(
144     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FLRunnerResult_ContributionResult* value) {
145   int int_value;
146   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
147       FLRunnerResult_ContributionResult_entries, 3, name, &int_value);
148   if (success) {
149     *value = static_cast<FLRunnerResult_ContributionResult>(int_value);
150   }
151   return success;
152 }
153 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
154 constexpr FLRunnerResult_ContributionResult FLRunnerResult::UNSPECIFIED;
155 constexpr FLRunnerResult_ContributionResult FLRunnerResult::SUCCESS;
156 constexpr FLRunnerResult_ContributionResult FLRunnerResult::FAIL;
157 constexpr FLRunnerResult_ContributionResult FLRunnerResult::ContributionResult_MIN;
158 constexpr FLRunnerResult_ContributionResult FLRunnerResult::ContributionResult_MAX;
159 constexpr int FLRunnerResult::ContributionResult_ARRAYSIZE;
160 #endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
FLRunnerResult_ErrorStatus_IsValid(int value)161 bool FLRunnerResult_ErrorStatus_IsValid(int value) {
162   switch (value) {
163     case 0:
164     case 1:
165     case 2:
166     case 3:
167     case 4:
168       return true;
169     default:
170       return false;
171   }
172 }
173 
174 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> FLRunnerResult_ErrorStatus_strings[5] = {};
175 
176 static const char FLRunnerResult_ErrorStatus_names[] =
177   "ERROR_STATUS_UNSPECIFIED"
178   "EXAMPLE_ITERATOR_ERROR"
179   "INVALID_ARGUMENT"
180   "NOT_ELIGIBLE"
181   "TENSORFLOW_ERROR";
182 
183 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry FLRunnerResult_ErrorStatus_entries[] = {
184   { {FLRunnerResult_ErrorStatus_names + 0, 24}, 0 },
185   { {FLRunnerResult_ErrorStatus_names + 24, 22}, 3 },
186   { {FLRunnerResult_ErrorStatus_names + 46, 16}, 2 },
187   { {FLRunnerResult_ErrorStatus_names + 62, 12}, 4 },
188   { {FLRunnerResult_ErrorStatus_names + 74, 16}, 1 },
189 };
190 
191 static const int FLRunnerResult_ErrorStatus_entries_by_number[] = {
192   0, // 0 -> ERROR_STATUS_UNSPECIFIED
193   4, // 1 -> TENSORFLOW_ERROR
194   2, // 2 -> INVALID_ARGUMENT
195   1, // 3 -> EXAMPLE_ITERATOR_ERROR
196   3, // 4 -> NOT_ELIGIBLE
197 };
198 
FLRunnerResult_ErrorStatus_Name(FLRunnerResult_ErrorStatus value)199 const std::string& FLRunnerResult_ErrorStatus_Name(
200     FLRunnerResult_ErrorStatus value) {
201   static const bool dummy =
202       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
203           FLRunnerResult_ErrorStatus_entries,
204           FLRunnerResult_ErrorStatus_entries_by_number,
205           5, FLRunnerResult_ErrorStatus_strings);
206   (void) dummy;
207   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
208       FLRunnerResult_ErrorStatus_entries,
209       FLRunnerResult_ErrorStatus_entries_by_number,
210       5, value);
211   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
212                      FLRunnerResult_ErrorStatus_strings[idx].get();
213 }
FLRunnerResult_ErrorStatus_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,FLRunnerResult_ErrorStatus * value)214 bool FLRunnerResult_ErrorStatus_Parse(
215     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FLRunnerResult_ErrorStatus* value) {
216   int int_value;
217   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
218       FLRunnerResult_ErrorStatus_entries, 5, name, &int_value);
219   if (success) {
220     *value = static_cast<FLRunnerResult_ErrorStatus>(int_value);
221   }
222   return success;
223 }
224 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
225 constexpr FLRunnerResult_ErrorStatus FLRunnerResult::ERROR_STATUS_UNSPECIFIED;
226 constexpr FLRunnerResult_ErrorStatus FLRunnerResult::TENSORFLOW_ERROR;
227 constexpr FLRunnerResult_ErrorStatus FLRunnerResult::INVALID_ARGUMENT;
228 constexpr FLRunnerResult_ErrorStatus FLRunnerResult::EXAMPLE_ITERATOR_ERROR;
229 constexpr FLRunnerResult_ErrorStatus FLRunnerResult::NOT_ELIGIBLE;
230 constexpr FLRunnerResult_ErrorStatus FLRunnerResult::ErrorStatus_MIN;
231 constexpr FLRunnerResult_ErrorStatus FLRunnerResult::ErrorStatus_MAX;
232 constexpr int FLRunnerResult::ErrorStatus_ARRAYSIZE;
233 #endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
234 
235 // ===================================================================
236 
237 class FLRunnerResult_ExampleStats::_Internal {
238  public:
239 };
240 
FLRunnerResult_ExampleStats(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)241 FLRunnerResult_ExampleStats::FLRunnerResult_ExampleStats(::PROTOBUF_NAMESPACE_ID::Arena* arena,
242                          bool is_message_owned)
243   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
244   SharedCtor(arena, is_message_owned);
245   // @@protoc_insertion_point(arena_constructor:fcp.client.FLRunnerResult.ExampleStats)
246 }
FLRunnerResult_ExampleStats(const FLRunnerResult_ExampleStats & from)247 FLRunnerResult_ExampleStats::FLRunnerResult_ExampleStats(const FLRunnerResult_ExampleStats& from)
248   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
249   FLRunnerResult_ExampleStats* const _this = this; (void)_this;
250   new (&_impl_) Impl_{
251       decltype(_impl_.example_size_bytes_){}
252     , decltype(_impl_.example_count_){}
253     , /*decltype(_impl_._cached_size_)*/{}};
254 
255   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
256   ::memcpy(&_impl_.example_size_bytes_, &from._impl_.example_size_bytes_,
257     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.example_count_) -
258     reinterpret_cast<char*>(&_impl_.example_size_bytes_)) + sizeof(_impl_.example_count_));
259   // @@protoc_insertion_point(copy_constructor:fcp.client.FLRunnerResult.ExampleStats)
260 }
261 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)262 inline void FLRunnerResult_ExampleStats::SharedCtor(
263     ::_pb::Arena* arena, bool is_message_owned) {
264   (void)arena;
265   (void)is_message_owned;
266   new (&_impl_) Impl_{
267       decltype(_impl_.example_size_bytes_){::int64_t{0}}
268     , decltype(_impl_.example_count_){0}
269     , /*decltype(_impl_._cached_size_)*/{}
270   };
271 }
272 
~FLRunnerResult_ExampleStats()273 FLRunnerResult_ExampleStats::~FLRunnerResult_ExampleStats() {
274   // @@protoc_insertion_point(destructor:fcp.client.FLRunnerResult.ExampleStats)
275   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
276   (void)arena;
277     return;
278   }
279   SharedDtor();
280 }
281 
SharedDtor()282 inline void FLRunnerResult_ExampleStats::SharedDtor() {
283   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
284 }
285 
SetCachedSize(int size) const286 void FLRunnerResult_ExampleStats::SetCachedSize(int size) const {
287   _impl_._cached_size_.Set(size);
288 }
289 
Clear()290 void FLRunnerResult_ExampleStats::Clear() {
291 // @@protoc_insertion_point(message_clear_start:fcp.client.FLRunnerResult.ExampleStats)
292   ::uint32_t cached_has_bits = 0;
293   // Prevent compiler warnings about cached_has_bits being unused
294   (void) cached_has_bits;
295 
296   ::memset(&_impl_.example_size_bytes_, 0, static_cast<size_t>(
297       reinterpret_cast<char*>(&_impl_.example_count_) -
298       reinterpret_cast<char*>(&_impl_.example_size_bytes_)) + sizeof(_impl_.example_count_));
299   _internal_metadata_.Clear<std::string>();
300 }
301 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)302 const char* FLRunnerResult_ExampleStats::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
303 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
304   while (!ctx->Done(&ptr)) {
305     ::uint32_t tag;
306     ptr = ::_pbi::ReadTag(ptr, &tag);
307     switch (tag >> 3) {
308       // int32 example_count = 1;
309       case 1:
310         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
311           _impl_.example_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
312           CHK_(ptr);
313         } else {
314           goto handle_unusual;
315         }
316         continue;
317       // int64 example_size_bytes = 2;
318       case 2:
319         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
320           _impl_.example_size_bytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
321           CHK_(ptr);
322         } else {
323           goto handle_unusual;
324         }
325         continue;
326       default:
327         goto handle_unusual;
328     }  // switch
329   handle_unusual:
330     if ((tag == 0) || ((tag & 7) == 4)) {
331       CHK_(ptr);
332       ctx->SetLastTag(tag);
333       goto message_done;
334     }
335     ptr = UnknownFieldParse(
336         tag,
337         _internal_metadata_.mutable_unknown_fields<std::string>(),
338         ptr, ctx);
339     CHK_(ptr != nullptr);
340   }  // while
341 message_done:
342   return ptr;
343 failure:
344   ptr = nullptr;
345   goto message_done;
346 #undef CHK_
347 }
348 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const349 ::uint8_t* FLRunnerResult_ExampleStats::_InternalSerialize(
350     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
351   // @@protoc_insertion_point(serialize_to_array_start:fcp.client.FLRunnerResult.ExampleStats)
352   ::uint32_t cached_has_bits = 0;
353   (void) cached_has_bits;
354 
355   // int32 example_count = 1;
356   if (this->_internal_example_count() != 0) {
357     target = stream->EnsureSpace(target);
358     target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_example_count(), target);
359   }
360 
361   // int64 example_size_bytes = 2;
362   if (this->_internal_example_size_bytes() != 0) {
363     target = stream->EnsureSpace(target);
364     target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_example_size_bytes(), target);
365   }
366 
367   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
368     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
369         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
370   }
371   // @@protoc_insertion_point(serialize_to_array_end:fcp.client.FLRunnerResult.ExampleStats)
372   return target;
373 }
374 
ByteSizeLong() const375 size_t FLRunnerResult_ExampleStats::ByteSizeLong() const {
376 // @@protoc_insertion_point(message_byte_size_start:fcp.client.FLRunnerResult.ExampleStats)
377   size_t total_size = 0;
378 
379   ::uint32_t cached_has_bits = 0;
380   // Prevent compiler warnings about cached_has_bits being unused
381   (void) cached_has_bits;
382 
383   // int64 example_size_bytes = 2;
384   if (this->_internal_example_size_bytes() != 0) {
385     total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_example_size_bytes());
386   }
387 
388   // int32 example_count = 1;
389   if (this->_internal_example_count() != 0) {
390     total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_example_count());
391   }
392 
393   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
394     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
395   }
396   int cached_size = ::_pbi::ToCachedSize(total_size);
397   SetCachedSize(cached_size);
398   return total_size;
399 }
400 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)401 void FLRunnerResult_ExampleStats::CheckTypeAndMergeFrom(
402     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
403   MergeFrom(*::_pbi::DownCast<const FLRunnerResult_ExampleStats*>(
404       &from));
405 }
406 
MergeFrom(const FLRunnerResult_ExampleStats & from)407 void FLRunnerResult_ExampleStats::MergeFrom(const FLRunnerResult_ExampleStats& from) {
408   FLRunnerResult_ExampleStats* const _this = this;
409   // @@protoc_insertion_point(class_specific_merge_from_start:fcp.client.FLRunnerResult.ExampleStats)
410   GOOGLE_DCHECK_NE(&from, _this);
411   ::uint32_t cached_has_bits = 0;
412   (void) cached_has_bits;
413 
414   if (from._internal_example_size_bytes() != 0) {
415     _this->_internal_set_example_size_bytes(from._internal_example_size_bytes());
416   }
417   if (from._internal_example_count() != 0) {
418     _this->_internal_set_example_count(from._internal_example_count());
419   }
420   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
421 }
422 
CopyFrom(const FLRunnerResult_ExampleStats & from)423 void FLRunnerResult_ExampleStats::CopyFrom(const FLRunnerResult_ExampleStats& from) {
424 // @@protoc_insertion_point(class_specific_copy_from_start:fcp.client.FLRunnerResult.ExampleStats)
425   if (&from == this) return;
426   Clear();
427   MergeFrom(from);
428 }
429 
IsInitialized() const430 bool FLRunnerResult_ExampleStats::IsInitialized() const {
431   return true;
432 }
433 
InternalSwap(FLRunnerResult_ExampleStats * other)434 void FLRunnerResult_ExampleStats::InternalSwap(FLRunnerResult_ExampleStats* other) {
435   using std::swap;
436   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
437   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
438       PROTOBUF_FIELD_OFFSET(FLRunnerResult_ExampleStats, _impl_.example_count_)
439       + sizeof(FLRunnerResult_ExampleStats::_impl_.example_count_)  // NOLINT
440       - PROTOBUF_FIELD_OFFSET(FLRunnerResult_ExampleStats, _impl_.example_size_bytes_)>(
441           reinterpret_cast<char*>(&_impl_.example_size_bytes_),
442           reinterpret_cast<char*>(&other->_impl_.example_size_bytes_));
443 }
444 
GetTypeName() const445 std::string FLRunnerResult_ExampleStats::GetTypeName() const {
446   return "fcp.client.FLRunnerResult.ExampleStats";
447 }
448 
449 
450 // ===================================================================
451 
452 class FLRunnerResult::_Internal {
453  public:
454   static const ::fcp::client::RetryInfo& retry_info(const FLRunnerResult* msg);
455   static const ::fcp::client::FLRunnerResult_ExampleStats& example_stats(const FLRunnerResult* msg);
456 };
457 
458 const ::fcp::client::RetryInfo&
retry_info(const FLRunnerResult * msg)459 FLRunnerResult::_Internal::retry_info(const FLRunnerResult* msg) {
460   return *msg->_impl_.retry_info_;
461 }
462 const ::fcp::client::FLRunnerResult_ExampleStats&
example_stats(const FLRunnerResult * msg)463 FLRunnerResult::_Internal::example_stats(const FLRunnerResult* msg) {
464   return *msg->_impl_.example_stats_;
465 }
FLRunnerResult(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)466 FLRunnerResult::FLRunnerResult(::PROTOBUF_NAMESPACE_ID::Arena* arena,
467                          bool is_message_owned)
468   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
469   SharedCtor(arena, is_message_owned);
470   // @@protoc_insertion_point(arena_constructor:fcp.client.FLRunnerResult)
471 }
FLRunnerResult(const FLRunnerResult & from)472 FLRunnerResult::FLRunnerResult(const FLRunnerResult& from)
473   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
474   FLRunnerResult* const _this = this; (void)_this;
475   new (&_impl_) Impl_{
476       decltype(_impl_.error_message_){}
477     , decltype(_impl_.retry_info_){nullptr}
478     , decltype(_impl_.example_stats_){nullptr}
479     , decltype(_impl_.contribution_result_){}
480     , decltype(_impl_.error_status_){}
481     , /*decltype(_impl_._cached_size_)*/{}};
482 
483   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
484   _impl_.error_message_.InitDefault();
485   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
486     _impl_.error_message_.Set("", GetArenaForAllocation());
487   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
488   if (!from._internal_error_message().empty()) {
489     _this->_impl_.error_message_.Set(from._internal_error_message(),
490       _this->GetArenaForAllocation());
491   }
492   if (from._internal_has_retry_info()) {
493     _this->_impl_.retry_info_ = new ::fcp::client::RetryInfo(*from._impl_.retry_info_);
494   }
495   if (from._internal_has_example_stats()) {
496     _this->_impl_.example_stats_ = new ::fcp::client::FLRunnerResult_ExampleStats(*from._impl_.example_stats_);
497   }
498   ::memcpy(&_impl_.contribution_result_, &from._impl_.contribution_result_,
499     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.error_status_) -
500     reinterpret_cast<char*>(&_impl_.contribution_result_)) + sizeof(_impl_.error_status_));
501   // @@protoc_insertion_point(copy_constructor:fcp.client.FLRunnerResult)
502 }
503 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)504 inline void FLRunnerResult::SharedCtor(
505     ::_pb::Arena* arena, bool is_message_owned) {
506   (void)arena;
507   (void)is_message_owned;
508   new (&_impl_) Impl_{
509       decltype(_impl_.error_message_){}
510     , decltype(_impl_.retry_info_){nullptr}
511     , decltype(_impl_.example_stats_){nullptr}
512     , decltype(_impl_.contribution_result_){0}
513     , decltype(_impl_.error_status_){0}
514     , /*decltype(_impl_._cached_size_)*/{}
515   };
516   _impl_.error_message_.InitDefault();
517   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
518     _impl_.error_message_.Set("", GetArenaForAllocation());
519   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
520 }
521 
~FLRunnerResult()522 FLRunnerResult::~FLRunnerResult() {
523   // @@protoc_insertion_point(destructor:fcp.client.FLRunnerResult)
524   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
525   (void)arena;
526     return;
527   }
528   SharedDtor();
529 }
530 
SharedDtor()531 inline void FLRunnerResult::SharedDtor() {
532   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
533   _impl_.error_message_.Destroy();
534   if (this != internal_default_instance()) delete _impl_.retry_info_;
535   if (this != internal_default_instance()) delete _impl_.example_stats_;
536 }
537 
SetCachedSize(int size) const538 void FLRunnerResult::SetCachedSize(int size) const {
539   _impl_._cached_size_.Set(size);
540 }
541 
Clear()542 void FLRunnerResult::Clear() {
543 // @@protoc_insertion_point(message_clear_start:fcp.client.FLRunnerResult)
544   ::uint32_t cached_has_bits = 0;
545   // Prevent compiler warnings about cached_has_bits being unused
546   (void) cached_has_bits;
547 
548   _impl_.error_message_.ClearToEmpty();
549   if (GetArenaForAllocation() == nullptr && _impl_.retry_info_ != nullptr) {
550     delete _impl_.retry_info_;
551   }
552   _impl_.retry_info_ = nullptr;
553   if (GetArenaForAllocation() == nullptr && _impl_.example_stats_ != nullptr) {
554     delete _impl_.example_stats_;
555   }
556   _impl_.example_stats_ = nullptr;
557   ::memset(&_impl_.contribution_result_, 0, static_cast<size_t>(
558       reinterpret_cast<char*>(&_impl_.error_status_) -
559       reinterpret_cast<char*>(&_impl_.contribution_result_)) + sizeof(_impl_.error_status_));
560   _internal_metadata_.Clear<std::string>();
561 }
562 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)563 const char* FLRunnerResult::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
564 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
565   while (!ctx->Done(&ptr)) {
566     ::uint32_t tag;
567     ptr = ::_pbi::ReadTag(ptr, &tag);
568     switch (tag >> 3) {
569       // .fcp.client.RetryInfo retry_info = 4;
570       case 4:
571         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
572           ptr = ctx->ParseMessage(_internal_mutable_retry_info(), ptr);
573           CHK_(ptr);
574         } else {
575           goto handle_unusual;
576         }
577         continue;
578       // .fcp.client.FLRunnerResult.ContributionResult contribution_result = 5;
579       case 5:
580         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
581           ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
582           CHK_(ptr);
583           _internal_set_contribution_result(static_cast<::fcp::client::FLRunnerResult_ContributionResult>(val));
584         } else {
585           goto handle_unusual;
586         }
587         continue;
588       // string error_message = 200;
589       case 200:
590         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 66)) {
591           auto str = _internal_mutable_error_message();
592           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
593           CHK_(ptr);
594           CHK_(::_pbi::VerifyUTF8(str, nullptr));
595         } else {
596           goto handle_unusual;
597         }
598         continue;
599       // .fcp.client.FLRunnerResult.ErrorStatus error_status = 201;
600       case 201:
601         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 72)) {
602           ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
603           CHK_(ptr);
604           _internal_set_error_status(static_cast<::fcp::client::FLRunnerResult_ErrorStatus>(val));
605         } else {
606           goto handle_unusual;
607         }
608         continue;
609       // .fcp.client.FLRunnerResult.ExampleStats example_stats = 202;
610       case 202:
611         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 82)) {
612           ptr = ctx->ParseMessage(_internal_mutable_example_stats(), ptr);
613           CHK_(ptr);
614         } else {
615           goto handle_unusual;
616         }
617         continue;
618       default:
619         goto handle_unusual;
620     }  // switch
621   handle_unusual:
622     if ((tag == 0) || ((tag & 7) == 4)) {
623       CHK_(ptr);
624       ctx->SetLastTag(tag);
625       goto message_done;
626     }
627     ptr = UnknownFieldParse(
628         tag,
629         _internal_metadata_.mutable_unknown_fields<std::string>(),
630         ptr, ctx);
631     CHK_(ptr != nullptr);
632   }  // while
633 message_done:
634   return ptr;
635 failure:
636   ptr = nullptr;
637   goto message_done;
638 #undef CHK_
639 }
640 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const641 ::uint8_t* FLRunnerResult::_InternalSerialize(
642     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
643   // @@protoc_insertion_point(serialize_to_array_start:fcp.client.FLRunnerResult)
644   ::uint32_t cached_has_bits = 0;
645   (void) cached_has_bits;
646 
647   // .fcp.client.RetryInfo retry_info = 4;
648   if (this->_internal_has_retry_info()) {
649     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
650       InternalWriteMessage(4, _Internal::retry_info(this),
651         _Internal::retry_info(this).GetCachedSize(), target, stream);
652   }
653 
654   // .fcp.client.FLRunnerResult.ContributionResult contribution_result = 5;
655   if (this->_internal_contribution_result() != 0) {
656     target = stream->EnsureSpace(target);
657     target = ::_pbi::WireFormatLite::WriteEnumToArray(
658       5, this->_internal_contribution_result(), target);
659   }
660 
661   // string error_message = 200;
662   if (!this->_internal_error_message().empty()) {
663     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
664       this->_internal_error_message().data(), static_cast<int>(this->_internal_error_message().length()),
665       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
666       "fcp.client.FLRunnerResult.error_message");
667     target = stream->WriteStringMaybeAliased(
668         200, this->_internal_error_message(), target);
669   }
670 
671   // .fcp.client.FLRunnerResult.ErrorStatus error_status = 201;
672   if (this->_internal_error_status() != 0) {
673     target = stream->EnsureSpace(target);
674     target = ::_pbi::WireFormatLite::WriteEnumToArray(
675       201, this->_internal_error_status(), target);
676   }
677 
678   // .fcp.client.FLRunnerResult.ExampleStats example_stats = 202;
679   if (this->_internal_has_example_stats()) {
680     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
681       InternalWriteMessage(202, _Internal::example_stats(this),
682         _Internal::example_stats(this).GetCachedSize(), target, stream);
683   }
684 
685   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
686     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
687         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
688   }
689   // @@protoc_insertion_point(serialize_to_array_end:fcp.client.FLRunnerResult)
690   return target;
691 }
692 
ByteSizeLong() const693 size_t FLRunnerResult::ByteSizeLong() const {
694 // @@protoc_insertion_point(message_byte_size_start:fcp.client.FLRunnerResult)
695   size_t total_size = 0;
696 
697   ::uint32_t cached_has_bits = 0;
698   // Prevent compiler warnings about cached_has_bits being unused
699   (void) cached_has_bits;
700 
701   // string error_message = 200;
702   if (!this->_internal_error_message().empty()) {
703     total_size += 2 +
704       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
705         this->_internal_error_message());
706   }
707 
708   // .fcp.client.RetryInfo retry_info = 4;
709   if (this->_internal_has_retry_info()) {
710     total_size += 1 +
711       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
712         *_impl_.retry_info_);
713   }
714 
715   // .fcp.client.FLRunnerResult.ExampleStats example_stats = 202;
716   if (this->_internal_has_example_stats()) {
717     total_size += 2 +
718       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
719         *_impl_.example_stats_);
720   }
721 
722   // .fcp.client.FLRunnerResult.ContributionResult contribution_result = 5;
723   if (this->_internal_contribution_result() != 0) {
724     total_size += 1 +
725       ::_pbi::WireFormatLite::EnumSize(this->_internal_contribution_result());
726   }
727 
728   // .fcp.client.FLRunnerResult.ErrorStatus error_status = 201;
729   if (this->_internal_error_status() != 0) {
730     total_size += 2 +
731       ::_pbi::WireFormatLite::EnumSize(this->_internal_error_status());
732   }
733 
734   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
735     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
736   }
737   int cached_size = ::_pbi::ToCachedSize(total_size);
738   SetCachedSize(cached_size);
739   return total_size;
740 }
741 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)742 void FLRunnerResult::CheckTypeAndMergeFrom(
743     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
744   MergeFrom(*::_pbi::DownCast<const FLRunnerResult*>(
745       &from));
746 }
747 
MergeFrom(const FLRunnerResult & from)748 void FLRunnerResult::MergeFrom(const FLRunnerResult& from) {
749   FLRunnerResult* const _this = this;
750   // @@protoc_insertion_point(class_specific_merge_from_start:fcp.client.FLRunnerResult)
751   GOOGLE_DCHECK_NE(&from, _this);
752   ::uint32_t cached_has_bits = 0;
753   (void) cached_has_bits;
754 
755   if (!from._internal_error_message().empty()) {
756     _this->_internal_set_error_message(from._internal_error_message());
757   }
758   if (from._internal_has_retry_info()) {
759     _this->_internal_mutable_retry_info()->::fcp::client::RetryInfo::MergeFrom(
760         from._internal_retry_info());
761   }
762   if (from._internal_has_example_stats()) {
763     _this->_internal_mutable_example_stats()->::fcp::client::FLRunnerResult_ExampleStats::MergeFrom(
764         from._internal_example_stats());
765   }
766   if (from._internal_contribution_result() != 0) {
767     _this->_internal_set_contribution_result(from._internal_contribution_result());
768   }
769   if (from._internal_error_status() != 0) {
770     _this->_internal_set_error_status(from._internal_error_status());
771   }
772   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
773 }
774 
CopyFrom(const FLRunnerResult & from)775 void FLRunnerResult::CopyFrom(const FLRunnerResult& from) {
776 // @@protoc_insertion_point(class_specific_copy_from_start:fcp.client.FLRunnerResult)
777   if (&from == this) return;
778   Clear();
779   MergeFrom(from);
780 }
781 
IsInitialized() const782 bool FLRunnerResult::IsInitialized() const {
783   return true;
784 }
785 
InternalSwap(FLRunnerResult * other)786 void FLRunnerResult::InternalSwap(FLRunnerResult* other) {
787   using std::swap;
788   auto* lhs_arena = GetArenaForAllocation();
789   auto* rhs_arena = other->GetArenaForAllocation();
790   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
791   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
792       &_impl_.error_message_, lhs_arena,
793       &other->_impl_.error_message_, rhs_arena
794   );
795   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
796       PROTOBUF_FIELD_OFFSET(FLRunnerResult, _impl_.error_status_)
797       + sizeof(FLRunnerResult::_impl_.error_status_)  // NOLINT
798       - PROTOBUF_FIELD_OFFSET(FLRunnerResult, _impl_.retry_info_)>(
799           reinterpret_cast<char*>(&_impl_.retry_info_),
800           reinterpret_cast<char*>(&other->_impl_.retry_info_));
801 }
802 
GetTypeName() const803 std::string FLRunnerResult::GetTypeName() const {
804   return "fcp.client.FLRunnerResult";
805 }
806 
807 
808 // ===================================================================
809 
810 class RetryInfo::_Internal {
811  public:
812   static const ::PROTOBUF_NAMESPACE_ID::Duration& minimum_delay(const RetryInfo* msg);
813 };
814 
815 const ::PROTOBUF_NAMESPACE_ID::Duration&
minimum_delay(const RetryInfo * msg)816 RetryInfo::_Internal::minimum_delay(const RetryInfo* msg) {
817   return *msg->_impl_.minimum_delay_;
818 }
clear_minimum_delay()819 void RetryInfo::clear_minimum_delay() {
820   if (GetArenaForAllocation() == nullptr && _impl_.minimum_delay_ != nullptr) {
821     delete _impl_.minimum_delay_;
822   }
823   _impl_.minimum_delay_ = nullptr;
824 }
RetryInfo(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)825 RetryInfo::RetryInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
826                          bool is_message_owned)
827   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
828   SharedCtor(arena, is_message_owned);
829   // @@protoc_insertion_point(arena_constructor:fcp.client.RetryInfo)
830 }
RetryInfo(const RetryInfo & from)831 RetryInfo::RetryInfo(const RetryInfo& from)
832   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
833   RetryInfo* const _this = this; (void)_this;
834   new (&_impl_) Impl_{
835       decltype(_impl_.retry_token_){}
836     , decltype(_impl_.minimum_delay_){nullptr}
837     , /*decltype(_impl_._cached_size_)*/{}};
838 
839   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
840   _impl_.retry_token_.InitDefault();
841   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
842     _impl_.retry_token_.Set("", GetArenaForAllocation());
843   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
844   if (!from._internal_retry_token().empty()) {
845     _this->_impl_.retry_token_.Set(from._internal_retry_token(),
846       _this->GetArenaForAllocation());
847   }
848   if (from._internal_has_minimum_delay()) {
849     _this->_impl_.minimum_delay_ = new ::PROTOBUF_NAMESPACE_ID::Duration(*from._impl_.minimum_delay_);
850   }
851   // @@protoc_insertion_point(copy_constructor:fcp.client.RetryInfo)
852 }
853 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)854 inline void RetryInfo::SharedCtor(
855     ::_pb::Arena* arena, bool is_message_owned) {
856   (void)arena;
857   (void)is_message_owned;
858   new (&_impl_) Impl_{
859       decltype(_impl_.retry_token_){}
860     , decltype(_impl_.minimum_delay_){nullptr}
861     , /*decltype(_impl_._cached_size_)*/{}
862   };
863   _impl_.retry_token_.InitDefault();
864   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
865     _impl_.retry_token_.Set("", GetArenaForAllocation());
866   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
867 }
868 
~RetryInfo()869 RetryInfo::~RetryInfo() {
870   // @@protoc_insertion_point(destructor:fcp.client.RetryInfo)
871   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
872   (void)arena;
873     return;
874   }
875   SharedDtor();
876 }
877 
SharedDtor()878 inline void RetryInfo::SharedDtor() {
879   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
880   _impl_.retry_token_.Destroy();
881   if (this != internal_default_instance()) delete _impl_.minimum_delay_;
882 }
883 
SetCachedSize(int size) const884 void RetryInfo::SetCachedSize(int size) const {
885   _impl_._cached_size_.Set(size);
886 }
887 
Clear()888 void RetryInfo::Clear() {
889 // @@protoc_insertion_point(message_clear_start:fcp.client.RetryInfo)
890   ::uint32_t cached_has_bits = 0;
891   // Prevent compiler warnings about cached_has_bits being unused
892   (void) cached_has_bits;
893 
894   _impl_.retry_token_.ClearToEmpty();
895   if (GetArenaForAllocation() == nullptr && _impl_.minimum_delay_ != nullptr) {
896     delete _impl_.minimum_delay_;
897   }
898   _impl_.minimum_delay_ = nullptr;
899   _internal_metadata_.Clear<std::string>();
900 }
901 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)902 const char* RetryInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
903 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
904   while (!ctx->Done(&ptr)) {
905     ::uint32_t tag;
906     ptr = ::_pbi::ReadTag(ptr, &tag);
907     switch (tag >> 3) {
908       // string retry_token = 1;
909       case 1:
910         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
911           auto str = _internal_mutable_retry_token();
912           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
913           CHK_(ptr);
914           CHK_(::_pbi::VerifyUTF8(str, nullptr));
915         } else {
916           goto handle_unusual;
917         }
918         continue;
919       // .google.protobuf.Duration minimum_delay = 2;
920       case 2:
921         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
922           ptr = ctx->ParseMessage(_internal_mutable_minimum_delay(), ptr);
923           CHK_(ptr);
924         } else {
925           goto handle_unusual;
926         }
927         continue;
928       default:
929         goto handle_unusual;
930     }  // switch
931   handle_unusual:
932     if ((tag == 0) || ((tag & 7) == 4)) {
933       CHK_(ptr);
934       ctx->SetLastTag(tag);
935       goto message_done;
936     }
937     ptr = UnknownFieldParse(
938         tag,
939         _internal_metadata_.mutable_unknown_fields<std::string>(),
940         ptr, ctx);
941     CHK_(ptr != nullptr);
942   }  // while
943 message_done:
944   return ptr;
945 failure:
946   ptr = nullptr;
947   goto message_done;
948 #undef CHK_
949 }
950 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const951 ::uint8_t* RetryInfo::_InternalSerialize(
952     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
953   // @@protoc_insertion_point(serialize_to_array_start:fcp.client.RetryInfo)
954   ::uint32_t cached_has_bits = 0;
955   (void) cached_has_bits;
956 
957   // string retry_token = 1;
958   if (!this->_internal_retry_token().empty()) {
959     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
960       this->_internal_retry_token().data(), static_cast<int>(this->_internal_retry_token().length()),
961       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
962       "fcp.client.RetryInfo.retry_token");
963     target = stream->WriteStringMaybeAliased(
964         1, this->_internal_retry_token(), target);
965   }
966 
967   // .google.protobuf.Duration minimum_delay = 2;
968   if (this->_internal_has_minimum_delay()) {
969     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
970       InternalWriteMessage(2, _Internal::minimum_delay(this),
971         _Internal::minimum_delay(this).GetCachedSize(), target, stream);
972   }
973 
974   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
975     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
976         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
977   }
978   // @@protoc_insertion_point(serialize_to_array_end:fcp.client.RetryInfo)
979   return target;
980 }
981 
ByteSizeLong() const982 size_t RetryInfo::ByteSizeLong() const {
983 // @@protoc_insertion_point(message_byte_size_start:fcp.client.RetryInfo)
984   size_t total_size = 0;
985 
986   ::uint32_t cached_has_bits = 0;
987   // Prevent compiler warnings about cached_has_bits being unused
988   (void) cached_has_bits;
989 
990   // string retry_token = 1;
991   if (!this->_internal_retry_token().empty()) {
992     total_size += 1 +
993       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
994         this->_internal_retry_token());
995   }
996 
997   // .google.protobuf.Duration minimum_delay = 2;
998   if (this->_internal_has_minimum_delay()) {
999     total_size += 1 +
1000       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1001         *_impl_.minimum_delay_);
1002   }
1003 
1004   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1005     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1006   }
1007   int cached_size = ::_pbi::ToCachedSize(total_size);
1008   SetCachedSize(cached_size);
1009   return total_size;
1010 }
1011 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1012 void RetryInfo::CheckTypeAndMergeFrom(
1013     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1014   MergeFrom(*::_pbi::DownCast<const RetryInfo*>(
1015       &from));
1016 }
1017 
MergeFrom(const RetryInfo & from)1018 void RetryInfo::MergeFrom(const RetryInfo& from) {
1019   RetryInfo* const _this = this;
1020   // @@protoc_insertion_point(class_specific_merge_from_start:fcp.client.RetryInfo)
1021   GOOGLE_DCHECK_NE(&from, _this);
1022   ::uint32_t cached_has_bits = 0;
1023   (void) cached_has_bits;
1024 
1025   if (!from._internal_retry_token().empty()) {
1026     _this->_internal_set_retry_token(from._internal_retry_token());
1027   }
1028   if (from._internal_has_minimum_delay()) {
1029     _this->_internal_mutable_minimum_delay()->::PROTOBUF_NAMESPACE_ID::Duration::MergeFrom(
1030         from._internal_minimum_delay());
1031   }
1032   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1033 }
1034 
CopyFrom(const RetryInfo & from)1035 void RetryInfo::CopyFrom(const RetryInfo& from) {
1036 // @@protoc_insertion_point(class_specific_copy_from_start:fcp.client.RetryInfo)
1037   if (&from == this) return;
1038   Clear();
1039   MergeFrom(from);
1040 }
1041 
IsInitialized() const1042 bool RetryInfo::IsInitialized() const {
1043   return true;
1044 }
1045 
InternalSwap(RetryInfo * other)1046 void RetryInfo::InternalSwap(RetryInfo* other) {
1047   using std::swap;
1048   auto* lhs_arena = GetArenaForAllocation();
1049   auto* rhs_arena = other->GetArenaForAllocation();
1050   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1051   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1052       &_impl_.retry_token_, lhs_arena,
1053       &other->_impl_.retry_token_, rhs_arena
1054   );
1055   swap(_impl_.minimum_delay_, other->_impl_.minimum_delay_);
1056 }
1057 
GetTypeName() const1058 std::string RetryInfo::GetTypeName() const {
1059   return "fcp.client.RetryInfo";
1060 }
1061 
1062 
1063 // ===================================================================
1064 
FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse()1065 FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse::FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse() {}
FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena * arena)1066 FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse::FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
1067     : SuperType(arena) {}
MergeFrom(const FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse & other)1068 void FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse::MergeFrom(const FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse& other) {
1069   MergeFromInternal(other);
1070 }
1071 
1072 // ===================================================================
1073 
1074 class FLRunnerTensorflowSpecResult::_Internal {
1075  public:
1076 };
1077 
clear_output_tensors()1078 void FLRunnerTensorflowSpecResult::clear_output_tensors() {
1079   _impl_.output_tensors_.Clear();
1080 }
FLRunnerTensorflowSpecResult(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1081 FLRunnerTensorflowSpecResult::FLRunnerTensorflowSpecResult(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1082                          bool is_message_owned)
1083   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1084   SharedCtor(arena, is_message_owned);
1085   // @@protoc_insertion_point(arena_constructor:fcp.client.FLRunnerTensorflowSpecResult)
1086 }
FLRunnerTensorflowSpecResult(const FLRunnerTensorflowSpecResult & from)1087 FLRunnerTensorflowSpecResult::FLRunnerTensorflowSpecResult(const FLRunnerTensorflowSpecResult& from)
1088   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1089   FLRunnerTensorflowSpecResult* const _this = this; (void)_this;
1090   new (&_impl_) Impl_{
1091       /*decltype(_impl_.output_tensors_)*/{}
1092     , decltype(_impl_.checkpoint_output_filename_){}
1093     , decltype(_impl_.outcome_){}
1094     , /*decltype(_impl_._cached_size_)*/{}};
1095 
1096   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1097   _this->_impl_.output_tensors_.MergeFrom(from._impl_.output_tensors_);
1098   _impl_.checkpoint_output_filename_.InitDefault();
1099   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1100     _impl_.checkpoint_output_filename_.Set("", GetArenaForAllocation());
1101   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1102   if (!from._internal_checkpoint_output_filename().empty()) {
1103     _this->_impl_.checkpoint_output_filename_.Set(from._internal_checkpoint_output_filename(),
1104       _this->GetArenaForAllocation());
1105   }
1106   _this->_impl_.outcome_ = from._impl_.outcome_;
1107   // @@protoc_insertion_point(copy_constructor:fcp.client.FLRunnerTensorflowSpecResult)
1108 }
1109 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1110 inline void FLRunnerTensorflowSpecResult::SharedCtor(
1111     ::_pb::Arena* arena, bool is_message_owned) {
1112   (void)arena;
1113   (void)is_message_owned;
1114   new (&_impl_) Impl_{
1115       /*decltype(_impl_.output_tensors_)*/{::_pbi::ArenaInitialized(), arena}
1116     , decltype(_impl_.checkpoint_output_filename_){}
1117     , decltype(_impl_.outcome_){0}
1118     , /*decltype(_impl_._cached_size_)*/{}
1119   };
1120   _impl_.checkpoint_output_filename_.InitDefault();
1121   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1122     _impl_.checkpoint_output_filename_.Set("", GetArenaForAllocation());
1123   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1124 }
1125 
~FLRunnerTensorflowSpecResult()1126 FLRunnerTensorflowSpecResult::~FLRunnerTensorflowSpecResult() {
1127   // @@protoc_insertion_point(destructor:fcp.client.FLRunnerTensorflowSpecResult)
1128   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1129   (void)arena;
1130     return;
1131   }
1132   SharedDtor();
1133 }
1134 
SharedDtor()1135 inline void FLRunnerTensorflowSpecResult::SharedDtor() {
1136   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1137   _impl_.output_tensors_.Destruct();
1138   _impl_.output_tensors_.~MapFieldLite();
1139   _impl_.checkpoint_output_filename_.Destroy();
1140 }
1141 
SetCachedSize(int size) const1142 void FLRunnerTensorflowSpecResult::SetCachedSize(int size) const {
1143   _impl_._cached_size_.Set(size);
1144 }
1145 
Clear()1146 void FLRunnerTensorflowSpecResult::Clear() {
1147 // @@protoc_insertion_point(message_clear_start:fcp.client.FLRunnerTensorflowSpecResult)
1148   ::uint32_t cached_has_bits = 0;
1149   // Prevent compiler warnings about cached_has_bits being unused
1150   (void) cached_has_bits;
1151 
1152   _impl_.output_tensors_.Clear();
1153   _impl_.checkpoint_output_filename_.ClearToEmpty();
1154   _impl_.outcome_ = 0;
1155   _internal_metadata_.Clear<std::string>();
1156 }
1157 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1158 const char* FLRunnerTensorflowSpecResult::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1159 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1160   while (!ctx->Done(&ptr)) {
1161     ::uint32_t tag;
1162     ptr = ::_pbi::ReadTag(ptr, &tag);
1163     switch (tag >> 3) {
1164       // .fcp.client.engine.PhaseOutcome outcome = 1;
1165       case 1:
1166         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1167           ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1168           CHK_(ptr);
1169           _internal_set_outcome(static_cast<::fcp::client::engine::PhaseOutcome>(val));
1170         } else {
1171           goto handle_unusual;
1172         }
1173         continue;
1174       // string checkpoint_output_filename = 2;
1175       case 2:
1176         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1177           auto str = _internal_mutable_checkpoint_output_filename();
1178           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1179           CHK_(ptr);
1180           CHK_(::_pbi::VerifyUTF8(str, nullptr));
1181         } else {
1182           goto handle_unusual;
1183         }
1184         continue;
1185       // map<string, .tensorflow.TensorProto> output_tensors = 3;
1186       case 3:
1187         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
1188           ptr -= 1;
1189           do {
1190             ptr += 1;
1191             ptr = ctx->ParseMessage(&_impl_.output_tensors_, ptr);
1192             CHK_(ptr);
1193             if (!ctx->DataAvailable(ptr)) break;
1194           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
1195         } else {
1196           goto handle_unusual;
1197         }
1198         continue;
1199       default:
1200         goto handle_unusual;
1201     }  // switch
1202   handle_unusual:
1203     if ((tag == 0) || ((tag & 7) == 4)) {
1204       CHK_(ptr);
1205       ctx->SetLastTag(tag);
1206       goto message_done;
1207     }
1208     ptr = UnknownFieldParse(
1209         tag,
1210         _internal_metadata_.mutable_unknown_fields<std::string>(),
1211         ptr, ctx);
1212     CHK_(ptr != nullptr);
1213   }  // while
1214 message_done:
1215   return ptr;
1216 failure:
1217   ptr = nullptr;
1218   goto message_done;
1219 #undef CHK_
1220 }
1221 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1222 ::uint8_t* FLRunnerTensorflowSpecResult::_InternalSerialize(
1223     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1224   // @@protoc_insertion_point(serialize_to_array_start:fcp.client.FLRunnerTensorflowSpecResult)
1225   ::uint32_t cached_has_bits = 0;
1226   (void) cached_has_bits;
1227 
1228   // .fcp.client.engine.PhaseOutcome outcome = 1;
1229   if (this->_internal_outcome() != 0) {
1230     target = stream->EnsureSpace(target);
1231     target = ::_pbi::WireFormatLite::WriteEnumToArray(
1232       1, this->_internal_outcome(), target);
1233   }
1234 
1235   // string checkpoint_output_filename = 2;
1236   if (!this->_internal_checkpoint_output_filename().empty()) {
1237     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1238       this->_internal_checkpoint_output_filename().data(), static_cast<int>(this->_internal_checkpoint_output_filename().length()),
1239       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1240       "fcp.client.FLRunnerTensorflowSpecResult.checkpoint_output_filename");
1241     target = stream->WriteStringMaybeAliased(
1242         2, this->_internal_checkpoint_output_filename(), target);
1243   }
1244 
1245   // map<string, .tensorflow.TensorProto> output_tensors = 3;
1246   if (!this->_internal_output_tensors().empty()) {
1247     using MapType = ::_pb::Map<std::string, ::tensorflow::TensorProto>;
1248     using WireHelper = FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse::Funcs;
1249     const auto& map_field = this->_internal_output_tensors();
1250     auto check_utf8 = [](const MapType::value_type& entry) {
1251       (void)entry;
1252       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1253         entry.first.data(), static_cast<int>(entry.first.length()),
1254         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1255         "fcp.client.FLRunnerTensorflowSpecResult.OutputTensorsEntry.key");
1256     };
1257 
1258     if (stream->IsSerializationDeterministic() && map_field.size() > 1) {
1259       for (const auto& entry : ::_pbi::MapSorterPtr<MapType>(map_field)) {
1260         target = WireHelper::InternalSerialize(3, entry.first, entry.second, target, stream);
1261         check_utf8(entry);
1262       }
1263     } else {
1264       for (const auto& entry : map_field) {
1265         target = WireHelper::InternalSerialize(3, entry.first, entry.second, target, stream);
1266         check_utf8(entry);
1267       }
1268     }
1269   }
1270 
1271   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1272     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1273         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1274   }
1275   // @@protoc_insertion_point(serialize_to_array_end:fcp.client.FLRunnerTensorflowSpecResult)
1276   return target;
1277 }
1278 
ByteSizeLong() const1279 size_t FLRunnerTensorflowSpecResult::ByteSizeLong() const {
1280 // @@protoc_insertion_point(message_byte_size_start:fcp.client.FLRunnerTensorflowSpecResult)
1281   size_t total_size = 0;
1282 
1283   ::uint32_t cached_has_bits = 0;
1284   // Prevent compiler warnings about cached_has_bits being unused
1285   (void) cached_has_bits;
1286 
1287   // map<string, .tensorflow.TensorProto> output_tensors = 3;
1288   total_size += 1 *
1289       ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_output_tensors_size());
1290   for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::TensorProto >::const_iterator
1291       it = this->_internal_output_tensors().begin();
1292       it != this->_internal_output_tensors().end(); ++it) {
1293     total_size += FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
1294   }
1295 
1296   // string checkpoint_output_filename = 2;
1297   if (!this->_internal_checkpoint_output_filename().empty()) {
1298     total_size += 1 +
1299       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1300         this->_internal_checkpoint_output_filename());
1301   }
1302 
1303   // .fcp.client.engine.PhaseOutcome outcome = 1;
1304   if (this->_internal_outcome() != 0) {
1305     total_size += 1 +
1306       ::_pbi::WireFormatLite::EnumSize(this->_internal_outcome());
1307   }
1308 
1309   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1310     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1311   }
1312   int cached_size = ::_pbi::ToCachedSize(total_size);
1313   SetCachedSize(cached_size);
1314   return total_size;
1315 }
1316 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1317 void FLRunnerTensorflowSpecResult::CheckTypeAndMergeFrom(
1318     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1319   MergeFrom(*::_pbi::DownCast<const FLRunnerTensorflowSpecResult*>(
1320       &from));
1321 }
1322 
MergeFrom(const FLRunnerTensorflowSpecResult & from)1323 void FLRunnerTensorflowSpecResult::MergeFrom(const FLRunnerTensorflowSpecResult& from) {
1324   FLRunnerTensorflowSpecResult* const _this = this;
1325   // @@protoc_insertion_point(class_specific_merge_from_start:fcp.client.FLRunnerTensorflowSpecResult)
1326   GOOGLE_DCHECK_NE(&from, _this);
1327   ::uint32_t cached_has_bits = 0;
1328   (void) cached_has_bits;
1329 
1330   _this->_impl_.output_tensors_.MergeFrom(from._impl_.output_tensors_);
1331   if (!from._internal_checkpoint_output_filename().empty()) {
1332     _this->_internal_set_checkpoint_output_filename(from._internal_checkpoint_output_filename());
1333   }
1334   if (from._internal_outcome() != 0) {
1335     _this->_internal_set_outcome(from._internal_outcome());
1336   }
1337   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1338 }
1339 
CopyFrom(const FLRunnerTensorflowSpecResult & from)1340 void FLRunnerTensorflowSpecResult::CopyFrom(const FLRunnerTensorflowSpecResult& from) {
1341 // @@protoc_insertion_point(class_specific_copy_from_start:fcp.client.FLRunnerTensorflowSpecResult)
1342   if (&from == this) return;
1343   Clear();
1344   MergeFrom(from);
1345 }
1346 
IsInitialized() const1347 bool FLRunnerTensorflowSpecResult::IsInitialized() const {
1348   return true;
1349 }
1350 
InternalSwap(FLRunnerTensorflowSpecResult * other)1351 void FLRunnerTensorflowSpecResult::InternalSwap(FLRunnerTensorflowSpecResult* other) {
1352   using std::swap;
1353   auto* lhs_arena = GetArenaForAllocation();
1354   auto* rhs_arena = other->GetArenaForAllocation();
1355   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1356   _impl_.output_tensors_.InternalSwap(&other->_impl_.output_tensors_);
1357   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1358       &_impl_.checkpoint_output_filename_, lhs_arena,
1359       &other->_impl_.checkpoint_output_filename_, rhs_arena
1360   );
1361   swap(_impl_.outcome_, other->_impl_.outcome_);
1362 }
1363 
GetTypeName() const1364 std::string FLRunnerTensorflowSpecResult::GetTypeName() const {
1365   return "fcp.client.FLRunnerTensorflowSpecResult";
1366 }
1367 
1368 
1369 // @@protoc_insertion_point(namespace_scope)
1370 }  // namespace client
1371 }  // namespace fcp
1372 PROTOBUF_NAMESPACE_OPEN
1373 template<> PROTOBUF_NOINLINE ::fcp::client::FLRunnerResult_ExampleStats*
CreateMaybeMessage(Arena * arena)1374 Arena::CreateMaybeMessage< ::fcp::client::FLRunnerResult_ExampleStats >(Arena* arena) {
1375   return Arena::CreateMessageInternal< ::fcp::client::FLRunnerResult_ExampleStats >(arena);
1376 }
1377 template<> PROTOBUF_NOINLINE ::fcp::client::FLRunnerResult*
CreateMaybeMessage(Arena * arena)1378 Arena::CreateMaybeMessage< ::fcp::client::FLRunnerResult >(Arena* arena) {
1379   return Arena::CreateMessageInternal< ::fcp::client::FLRunnerResult >(arena);
1380 }
1381 template<> PROTOBUF_NOINLINE ::fcp::client::RetryInfo*
CreateMaybeMessage(Arena * arena)1382 Arena::CreateMaybeMessage< ::fcp::client::RetryInfo >(Arena* arena) {
1383   return Arena::CreateMessageInternal< ::fcp::client::RetryInfo >(arena);
1384 }
1385 template<> PROTOBUF_NOINLINE ::fcp::client::FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse*
CreateMaybeMessage(Arena * arena)1386 Arena::CreateMaybeMessage< ::fcp::client::FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse >(Arena* arena) {
1387   return Arena::CreateMessageInternal< ::fcp::client::FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse >(arena);
1388 }
1389 template<> PROTOBUF_NOINLINE ::fcp::client::FLRunnerTensorflowSpecResult*
CreateMaybeMessage(Arena * arena)1390 Arena::CreateMaybeMessage< ::fcp::client::FLRunnerTensorflowSpecResult >(Arena* arena) {
1391   return Arena::CreateMessageInternal< ::fcp::client::FLRunnerTensorflowSpecResult >(arena);
1392 }
1393 PROTOBUF_NAMESPACE_CLOSE
1394 
1395 // @@protoc_insertion_point(global_scope)
1396 #include <google/protobuf/port_undef.inc>
1397