1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: fcp/client/fl_runner.proto
3
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_fcp_2fclient_2ffl_5frunner_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_fcp_2fclient_2ffl_5frunner_2eproto
6
7 #include <cstdint>
8 #include <limits>
9 #include <string>
10
11 #include <google/protobuf/port_def.inc>
12 #if PROTOBUF_VERSION < 3021000
13 #error This file was generated by a newer version of protoc which is
14 #error incompatible with your Protocol Buffer headers. Please update
15 #error your headers.
16 #endif
17 #if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
18 #error This file was generated by an older version of protoc which is
19 #error incompatible with your Protocol Buffer headers. Please
20 #error regenerate this file with a newer version of protoc.
21 #endif
22
23 #include <google/protobuf/port_undef.inc>
24 #include <google/protobuf/io/coded_stream.h>
25 #include <google/protobuf/arena.h>
26 #include <google/protobuf/arenastring.h>
27 #include <google/protobuf/generated_message_util.h>
28 #include <google/protobuf/metadata_lite.h>
29 #include <google/protobuf/message_lite.h>
30 #include <google/protobuf/repeated_field.h> // IWYU pragma: export
31 #include <google/protobuf/extension_set.h> // IWYU pragma: export
32 #include <google/protobuf/map.h> // IWYU pragma: export
33 #include <google/protobuf/map_entry_lite.h>
34 #include <google/protobuf/map_field_lite.h>
35 #include <google/protobuf/generated_enum_util.h>
36 #include <google/protobuf/duration.pb.h>
37 #include "fcp/client/engine/engine.pb.h"
38 #include "tensorflow/core/framework/tensor.pb.h"
39 // @@protoc_insertion_point(includes)
40 #include <google/protobuf/port_def.inc>
41 #define PROTOBUF_INTERNAL_EXPORT_fcp_2fclient_2ffl_5frunner_2eproto
42 PROTOBUF_NAMESPACE_OPEN
43 namespace internal {
44 class AnyMetadata;
45 } // namespace internal
46 PROTOBUF_NAMESPACE_CLOSE
47
48 // Internal implementation detail -- do not use these members.
49 struct TableStruct_fcp_2fclient_2ffl_5frunner_2eproto {
50 static const ::uint32_t offsets[];
51 };
52 namespace fcp {
53 namespace client {
54 class FLRunnerResult;
55 struct FLRunnerResultDefaultTypeInternal;
56 extern FLRunnerResultDefaultTypeInternal _FLRunnerResult_default_instance_;
57 class FLRunnerResult_ExampleStats;
58 struct FLRunnerResult_ExampleStatsDefaultTypeInternal;
59 extern FLRunnerResult_ExampleStatsDefaultTypeInternal _FLRunnerResult_ExampleStats_default_instance_;
60 class FLRunnerTensorflowSpecResult;
61 struct FLRunnerTensorflowSpecResultDefaultTypeInternal;
62 extern FLRunnerTensorflowSpecResultDefaultTypeInternal _FLRunnerTensorflowSpecResult_default_instance_;
63 class FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse;
64 struct FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUseDefaultTypeInternal;
65 extern FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUseDefaultTypeInternal _FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse_default_instance_;
66 class RetryInfo;
67 struct RetryInfoDefaultTypeInternal;
68 extern RetryInfoDefaultTypeInternal _RetryInfo_default_instance_;
69 } // namespace client
70 } // namespace fcp
71 PROTOBUF_NAMESPACE_OPEN
72 template<> ::fcp::client::FLRunnerResult* Arena::CreateMaybeMessage<::fcp::client::FLRunnerResult>(Arena*);
73 template<> ::fcp::client::FLRunnerResult_ExampleStats* Arena::CreateMaybeMessage<::fcp::client::FLRunnerResult_ExampleStats>(Arena*);
74 template<> ::fcp::client::FLRunnerTensorflowSpecResult* Arena::CreateMaybeMessage<::fcp::client::FLRunnerTensorflowSpecResult>(Arena*);
75 template<> ::fcp::client::FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse* Arena::CreateMaybeMessage<::fcp::client::FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse>(Arena*);
76 template<> ::fcp::client::RetryInfo* Arena::CreateMaybeMessage<::fcp::client::RetryInfo>(Arena*);
77 PROTOBUF_NAMESPACE_CLOSE
78 namespace fcp {
79 namespace client {
80
81 enum FLRunnerResult_ContributionResult : int {
82 FLRunnerResult_ContributionResult_UNSPECIFIED = 0,
83 FLRunnerResult_ContributionResult_SUCCESS = 1,
84 FLRunnerResult_ContributionResult_FAIL = 2,
85 FLRunnerResult_ContributionResult_FLRunnerResult_ContributionResult_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::min(),
86 FLRunnerResult_ContributionResult_FLRunnerResult_ContributionResult_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::max()
87 };
88 bool FLRunnerResult_ContributionResult_IsValid(int value);
89 constexpr FLRunnerResult_ContributionResult FLRunnerResult_ContributionResult_ContributionResult_MIN = FLRunnerResult_ContributionResult_UNSPECIFIED;
90 constexpr FLRunnerResult_ContributionResult FLRunnerResult_ContributionResult_ContributionResult_MAX = FLRunnerResult_ContributionResult_FAIL;
91 constexpr int FLRunnerResult_ContributionResult_ContributionResult_ARRAYSIZE = FLRunnerResult_ContributionResult_ContributionResult_MAX + 1;
92
93 const std::string& FLRunnerResult_ContributionResult_Name(FLRunnerResult_ContributionResult value);
94 template<typename T>
FLRunnerResult_ContributionResult_Name(T enum_t_value)95 inline const std::string& FLRunnerResult_ContributionResult_Name(T enum_t_value) {
96 static_assert(::std::is_same<T, FLRunnerResult_ContributionResult>::value ||
97 ::std::is_integral<T>::value,
98 "Incorrect type passed to function FLRunnerResult_ContributionResult_Name.");
99 return FLRunnerResult_ContributionResult_Name(static_cast<FLRunnerResult_ContributionResult>(enum_t_value));
100 }
101 bool FLRunnerResult_ContributionResult_Parse(
102 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FLRunnerResult_ContributionResult* value);
103 enum FLRunnerResult_ErrorStatus : int {
104 FLRunnerResult_ErrorStatus_ERROR_STATUS_UNSPECIFIED = 0,
105 FLRunnerResult_ErrorStatus_TENSORFLOW_ERROR = 1,
106 FLRunnerResult_ErrorStatus_INVALID_ARGUMENT = 2,
107 FLRunnerResult_ErrorStatus_EXAMPLE_ITERATOR_ERROR = 3,
108 FLRunnerResult_ErrorStatus_NOT_ELIGIBLE = 4,
109 FLRunnerResult_ErrorStatus_FLRunnerResult_ErrorStatus_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::min(),
110 FLRunnerResult_ErrorStatus_FLRunnerResult_ErrorStatus_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::max()
111 };
112 bool FLRunnerResult_ErrorStatus_IsValid(int value);
113 constexpr FLRunnerResult_ErrorStatus FLRunnerResult_ErrorStatus_ErrorStatus_MIN = FLRunnerResult_ErrorStatus_ERROR_STATUS_UNSPECIFIED;
114 constexpr FLRunnerResult_ErrorStatus FLRunnerResult_ErrorStatus_ErrorStatus_MAX = FLRunnerResult_ErrorStatus_NOT_ELIGIBLE;
115 constexpr int FLRunnerResult_ErrorStatus_ErrorStatus_ARRAYSIZE = FLRunnerResult_ErrorStatus_ErrorStatus_MAX + 1;
116
117 const std::string& FLRunnerResult_ErrorStatus_Name(FLRunnerResult_ErrorStatus value);
118 template<typename T>
FLRunnerResult_ErrorStatus_Name(T enum_t_value)119 inline const std::string& FLRunnerResult_ErrorStatus_Name(T enum_t_value) {
120 static_assert(::std::is_same<T, FLRunnerResult_ErrorStatus>::value ||
121 ::std::is_integral<T>::value,
122 "Incorrect type passed to function FLRunnerResult_ErrorStatus_Name.");
123 return FLRunnerResult_ErrorStatus_Name(static_cast<FLRunnerResult_ErrorStatus>(enum_t_value));
124 }
125 bool FLRunnerResult_ErrorStatus_Parse(
126 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FLRunnerResult_ErrorStatus* value);
127 // ===================================================================
128
129 class FLRunnerResult_ExampleStats final :
130 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:fcp.client.FLRunnerResult.ExampleStats) */ {
131 public:
FLRunnerResult_ExampleStats()132 inline FLRunnerResult_ExampleStats() : FLRunnerResult_ExampleStats(nullptr) {}
133 ~FLRunnerResult_ExampleStats() override;
134 explicit PROTOBUF_CONSTEXPR FLRunnerResult_ExampleStats(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
135
136 FLRunnerResult_ExampleStats(const FLRunnerResult_ExampleStats& from);
FLRunnerResult_ExampleStats(FLRunnerResult_ExampleStats && from)137 FLRunnerResult_ExampleStats(FLRunnerResult_ExampleStats&& from) noexcept
138 : FLRunnerResult_ExampleStats() {
139 *this = ::std::move(from);
140 }
141
142 inline FLRunnerResult_ExampleStats& operator=(const FLRunnerResult_ExampleStats& from) {
143 if (this == &from) return *this;
144 CopyFrom(from);
145 return *this;
146 }
147 inline FLRunnerResult_ExampleStats& operator=(FLRunnerResult_ExampleStats&& from) noexcept {
148 if (this == &from) return *this;
149 if (GetOwningArena() == from.GetOwningArena()
150 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
151 && GetOwningArena() != nullptr
152 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
153 ) {
154 InternalSwap(&from);
155 } else {
156 CopyFrom(from);
157 }
158 return *this;
159 }
160
default_instance()161 static const FLRunnerResult_ExampleStats& default_instance() {
162 return *internal_default_instance();
163 }
internal_default_instance()164 static inline const FLRunnerResult_ExampleStats* internal_default_instance() {
165 return reinterpret_cast<const FLRunnerResult_ExampleStats*>(
166 &_FLRunnerResult_ExampleStats_default_instance_);
167 }
168 static constexpr int kIndexInFileMessages =
169 0;
170
swap(FLRunnerResult_ExampleStats & a,FLRunnerResult_ExampleStats & b)171 friend void swap(FLRunnerResult_ExampleStats& a, FLRunnerResult_ExampleStats& b) {
172 a.Swap(&b);
173 }
Swap(FLRunnerResult_ExampleStats * other)174 inline void Swap(FLRunnerResult_ExampleStats* other) {
175 if (other == this) return;
176 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
177 if (GetOwningArena() != nullptr &&
178 GetOwningArena() == other->GetOwningArena()) {
179 #else // PROTOBUF_FORCE_COPY_IN_SWAP
180 if (GetOwningArena() == other->GetOwningArena()) {
181 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
182 InternalSwap(other);
183 } else {
184 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
185 }
186 }
187 void UnsafeArenaSwap(FLRunnerResult_ExampleStats* other) {
188 if (other == this) return;
189 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
190 InternalSwap(other);
191 }
192
193 // implements Message ----------------------------------------------
194
195 FLRunnerResult_ExampleStats* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
196 return CreateMaybeMessage<FLRunnerResult_ExampleStats>(arena);
197 }
198 FLRunnerResult_ExampleStats* New() const {
199 return New(nullptr);
200 }
201 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
202 void CopyFrom(const FLRunnerResult_ExampleStats& from);
203 void MergeFrom(const FLRunnerResult_ExampleStats& from);
204 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
205 bool IsInitialized() const final;
206
207 size_t ByteSizeLong() const final;
208 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
209 ::uint8_t* _InternalSerialize(
210 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
211 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
212
213 private:
214 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
215 void SharedDtor();
216 void SetCachedSize(int size) const;
217 void InternalSwap(FLRunnerResult_ExampleStats* other);
218
219 private:
220 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
221 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
222 return "fcp.client.FLRunnerResult.ExampleStats";
223 }
224 protected:
225 explicit FLRunnerResult_ExampleStats(::PROTOBUF_NAMESPACE_ID::Arena* arena,
226 bool is_message_owned = false);
227 public:
228
229 std::string GetTypeName() const final;
230
231 // nested types ----------------------------------------------------
232
233 // accessors -------------------------------------------------------
234
235 enum : int {
236 kExampleSizeBytesFieldNumber = 2,
237 kExampleCountFieldNumber = 1,
238 };
239 // int64 example_size_bytes = 2;
240 void clear_example_size_bytes();
241 ::int64_t example_size_bytes() const;
242 void set_example_size_bytes(::int64_t value);
243 private:
244 ::int64_t _internal_example_size_bytes() const;
245 void _internal_set_example_size_bytes(::int64_t value);
246 public:
247
248 // int32 example_count = 1;
249 void clear_example_count();
250 ::int32_t example_count() const;
251 void set_example_count(::int32_t value);
252 private:
253 ::int32_t _internal_example_count() const;
254 void _internal_set_example_count(::int32_t value);
255 public:
256
257 // @@protoc_insertion_point(class_scope:fcp.client.FLRunnerResult.ExampleStats)
258 private:
259 class _Internal;
260
261 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
262 typedef void InternalArenaConstructable_;
263 typedef void DestructorSkippable_;
264 struct Impl_ {
265 ::int64_t example_size_bytes_;
266 ::int32_t example_count_;
267 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
268 };
269 union { Impl_ _impl_; };
270 friend struct ::TableStruct_fcp_2fclient_2ffl_5frunner_2eproto;
271 };
272 // -------------------------------------------------------------------
273
274 class FLRunnerResult final :
275 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:fcp.client.FLRunnerResult) */ {
276 public:
FLRunnerResult()277 inline FLRunnerResult() : FLRunnerResult(nullptr) {}
278 ~FLRunnerResult() override;
279 explicit PROTOBUF_CONSTEXPR FLRunnerResult(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
280
281 FLRunnerResult(const FLRunnerResult& from);
FLRunnerResult(FLRunnerResult && from)282 FLRunnerResult(FLRunnerResult&& from) noexcept
283 : FLRunnerResult() {
284 *this = ::std::move(from);
285 }
286
287 inline FLRunnerResult& operator=(const FLRunnerResult& from) {
288 if (this == &from) return *this;
289 CopyFrom(from);
290 return *this;
291 }
292 inline FLRunnerResult& operator=(FLRunnerResult&& from) noexcept {
293 if (this == &from) return *this;
294 if (GetOwningArena() == from.GetOwningArena()
295 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
296 && GetOwningArena() != nullptr
297 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
298 ) {
299 InternalSwap(&from);
300 } else {
301 CopyFrom(from);
302 }
303 return *this;
304 }
305
default_instance()306 static const FLRunnerResult& default_instance() {
307 return *internal_default_instance();
308 }
internal_default_instance()309 static inline const FLRunnerResult* internal_default_instance() {
310 return reinterpret_cast<const FLRunnerResult*>(
311 &_FLRunnerResult_default_instance_);
312 }
313 static constexpr int kIndexInFileMessages =
314 1;
315
swap(FLRunnerResult & a,FLRunnerResult & b)316 friend void swap(FLRunnerResult& a, FLRunnerResult& b) {
317 a.Swap(&b);
318 }
Swap(FLRunnerResult * other)319 inline void Swap(FLRunnerResult* other) {
320 if (other == this) return;
321 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
322 if (GetOwningArena() != nullptr &&
323 GetOwningArena() == other->GetOwningArena()) {
324 #else // PROTOBUF_FORCE_COPY_IN_SWAP
325 if (GetOwningArena() == other->GetOwningArena()) {
326 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
327 InternalSwap(other);
328 } else {
329 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
330 }
331 }
332 void UnsafeArenaSwap(FLRunnerResult* other) {
333 if (other == this) return;
334 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
335 InternalSwap(other);
336 }
337
338 // implements Message ----------------------------------------------
339
340 FLRunnerResult* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
341 return CreateMaybeMessage<FLRunnerResult>(arena);
342 }
343 FLRunnerResult* New() const {
344 return New(nullptr);
345 }
346 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
347 void CopyFrom(const FLRunnerResult& from);
348 void MergeFrom(const FLRunnerResult& from);
349 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
350 bool IsInitialized() const final;
351
352 size_t ByteSizeLong() const final;
353 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
354 ::uint8_t* _InternalSerialize(
355 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
356 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
357
358 private:
359 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
360 void SharedDtor();
361 void SetCachedSize(int size) const;
362 void InternalSwap(FLRunnerResult* other);
363
364 private:
365 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
366 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
367 return "fcp.client.FLRunnerResult";
368 }
369 protected:
370 explicit FLRunnerResult(::PROTOBUF_NAMESPACE_ID::Arena* arena,
371 bool is_message_owned = false);
372 public:
373
374 std::string GetTypeName() const final;
375
376 // nested types ----------------------------------------------------
377
378 typedef FLRunnerResult_ExampleStats ExampleStats;
379
380 typedef FLRunnerResult_ContributionResult ContributionResult;
381 static constexpr ContributionResult UNSPECIFIED =
382 FLRunnerResult_ContributionResult_UNSPECIFIED;
383 static constexpr ContributionResult SUCCESS =
384 FLRunnerResult_ContributionResult_SUCCESS;
385 static constexpr ContributionResult FAIL =
386 FLRunnerResult_ContributionResult_FAIL;
387 static inline bool ContributionResult_IsValid(int value) {
388 return FLRunnerResult_ContributionResult_IsValid(value);
389 }
390 static constexpr ContributionResult ContributionResult_MIN =
391 FLRunnerResult_ContributionResult_ContributionResult_MIN;
392 static constexpr ContributionResult ContributionResult_MAX =
393 FLRunnerResult_ContributionResult_ContributionResult_MAX;
394 static constexpr int ContributionResult_ARRAYSIZE =
395 FLRunnerResult_ContributionResult_ContributionResult_ARRAYSIZE;
396 template<typename T>
397 static inline const std::string& ContributionResult_Name(T enum_t_value) {
398 static_assert(::std::is_same<T, ContributionResult>::value ||
399 ::std::is_integral<T>::value,
400 "Incorrect type passed to function ContributionResult_Name.");
401 return FLRunnerResult_ContributionResult_Name(enum_t_value);
402 }
403 static inline bool ContributionResult_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
404 ContributionResult* value) {
405 return FLRunnerResult_ContributionResult_Parse(name, value);
406 }
407
408 typedef FLRunnerResult_ErrorStatus ErrorStatus;
409 static constexpr ErrorStatus ERROR_STATUS_UNSPECIFIED =
410 FLRunnerResult_ErrorStatus_ERROR_STATUS_UNSPECIFIED;
411 static constexpr ErrorStatus TENSORFLOW_ERROR =
412 FLRunnerResult_ErrorStatus_TENSORFLOW_ERROR;
413 static constexpr ErrorStatus INVALID_ARGUMENT =
414 FLRunnerResult_ErrorStatus_INVALID_ARGUMENT;
415 static constexpr ErrorStatus EXAMPLE_ITERATOR_ERROR =
416 FLRunnerResult_ErrorStatus_EXAMPLE_ITERATOR_ERROR;
417 static constexpr ErrorStatus NOT_ELIGIBLE =
418 FLRunnerResult_ErrorStatus_NOT_ELIGIBLE;
419 static inline bool ErrorStatus_IsValid(int value) {
420 return FLRunnerResult_ErrorStatus_IsValid(value);
421 }
422 static constexpr ErrorStatus ErrorStatus_MIN =
423 FLRunnerResult_ErrorStatus_ErrorStatus_MIN;
424 static constexpr ErrorStatus ErrorStatus_MAX =
425 FLRunnerResult_ErrorStatus_ErrorStatus_MAX;
426 static constexpr int ErrorStatus_ARRAYSIZE =
427 FLRunnerResult_ErrorStatus_ErrorStatus_ARRAYSIZE;
428 template<typename T>
429 static inline const std::string& ErrorStatus_Name(T enum_t_value) {
430 static_assert(::std::is_same<T, ErrorStatus>::value ||
431 ::std::is_integral<T>::value,
432 "Incorrect type passed to function ErrorStatus_Name.");
433 return FLRunnerResult_ErrorStatus_Name(enum_t_value);
434 }
435 static inline bool ErrorStatus_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
436 ErrorStatus* value) {
437 return FLRunnerResult_ErrorStatus_Parse(name, value);
438 }
439
440 // accessors -------------------------------------------------------
441
442 enum : int {
443 kErrorMessageFieldNumber = 200,
444 kRetryInfoFieldNumber = 4,
445 kExampleStatsFieldNumber = 202,
446 kContributionResultFieldNumber = 5,
447 kErrorStatusFieldNumber = 201,
448 };
449 // string error_message = 200;
450 void clear_error_message();
451 const std::string& error_message() const;
452 template <typename ArgT0 = const std::string&, typename... ArgT>
453 void set_error_message(ArgT0&& arg0, ArgT... args);
454 std::string* mutable_error_message();
455 PROTOBUF_NODISCARD std::string* release_error_message();
456 void set_allocated_error_message(std::string* error_message);
457 private:
458 const std::string& _internal_error_message() const;
459 inline PROTOBUF_ALWAYS_INLINE void _internal_set_error_message(const std::string& value);
460 std::string* _internal_mutable_error_message();
461 public:
462
463 // .fcp.client.RetryInfo retry_info = 4;
464 bool has_retry_info() const;
465 private:
466 bool _internal_has_retry_info() const;
467 public:
468 void clear_retry_info();
469 const ::fcp::client::RetryInfo& retry_info() const;
470 PROTOBUF_NODISCARD ::fcp::client::RetryInfo* release_retry_info();
471 ::fcp::client::RetryInfo* mutable_retry_info();
472 void set_allocated_retry_info(::fcp::client::RetryInfo* retry_info);
473 private:
474 const ::fcp::client::RetryInfo& _internal_retry_info() const;
475 ::fcp::client::RetryInfo* _internal_mutable_retry_info();
476 public:
477 void unsafe_arena_set_allocated_retry_info(
478 ::fcp::client::RetryInfo* retry_info);
479 ::fcp::client::RetryInfo* unsafe_arena_release_retry_info();
480
481 // .fcp.client.FLRunnerResult.ExampleStats example_stats = 202;
482 bool has_example_stats() const;
483 private:
484 bool _internal_has_example_stats() const;
485 public:
486 void clear_example_stats();
487 const ::fcp::client::FLRunnerResult_ExampleStats& example_stats() const;
488 PROTOBUF_NODISCARD ::fcp::client::FLRunnerResult_ExampleStats* release_example_stats();
489 ::fcp::client::FLRunnerResult_ExampleStats* mutable_example_stats();
490 void set_allocated_example_stats(::fcp::client::FLRunnerResult_ExampleStats* example_stats);
491 private:
492 const ::fcp::client::FLRunnerResult_ExampleStats& _internal_example_stats() const;
493 ::fcp::client::FLRunnerResult_ExampleStats* _internal_mutable_example_stats();
494 public:
495 void unsafe_arena_set_allocated_example_stats(
496 ::fcp::client::FLRunnerResult_ExampleStats* example_stats);
497 ::fcp::client::FLRunnerResult_ExampleStats* unsafe_arena_release_example_stats();
498
499 // .fcp.client.FLRunnerResult.ContributionResult contribution_result = 5;
500 void clear_contribution_result();
501 ::fcp::client::FLRunnerResult_ContributionResult contribution_result() const;
502 void set_contribution_result(::fcp::client::FLRunnerResult_ContributionResult value);
503 private:
504 ::fcp::client::FLRunnerResult_ContributionResult _internal_contribution_result() const;
505 void _internal_set_contribution_result(::fcp::client::FLRunnerResult_ContributionResult value);
506 public:
507
508 // .fcp.client.FLRunnerResult.ErrorStatus error_status = 201;
509 void clear_error_status();
510 ::fcp::client::FLRunnerResult_ErrorStatus error_status() const;
511 void set_error_status(::fcp::client::FLRunnerResult_ErrorStatus value);
512 private:
513 ::fcp::client::FLRunnerResult_ErrorStatus _internal_error_status() const;
514 void _internal_set_error_status(::fcp::client::FLRunnerResult_ErrorStatus value);
515 public:
516
517 // @@protoc_insertion_point(class_scope:fcp.client.FLRunnerResult)
518 private:
519 class _Internal;
520
521 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
522 typedef void InternalArenaConstructable_;
523 typedef void DestructorSkippable_;
524 struct Impl_ {
525 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr error_message_;
526 ::fcp::client::RetryInfo* retry_info_;
527 ::fcp::client::FLRunnerResult_ExampleStats* example_stats_;
528 int contribution_result_;
529 int error_status_;
530 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
531 };
532 union { Impl_ _impl_; };
533 friend struct ::TableStruct_fcp_2fclient_2ffl_5frunner_2eproto;
534 };
535 // -------------------------------------------------------------------
536
537 class RetryInfo final :
538 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:fcp.client.RetryInfo) */ {
539 public:
RetryInfo()540 inline RetryInfo() : RetryInfo(nullptr) {}
541 ~RetryInfo() override;
542 explicit PROTOBUF_CONSTEXPR RetryInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
543
544 RetryInfo(const RetryInfo& from);
RetryInfo(RetryInfo && from)545 RetryInfo(RetryInfo&& from) noexcept
546 : RetryInfo() {
547 *this = ::std::move(from);
548 }
549
550 inline RetryInfo& operator=(const RetryInfo& from) {
551 if (this == &from) return *this;
552 CopyFrom(from);
553 return *this;
554 }
555 inline RetryInfo& operator=(RetryInfo&& from) noexcept {
556 if (this == &from) return *this;
557 if (GetOwningArena() == from.GetOwningArena()
558 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
559 && GetOwningArena() != nullptr
560 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
561 ) {
562 InternalSwap(&from);
563 } else {
564 CopyFrom(from);
565 }
566 return *this;
567 }
568
default_instance()569 static const RetryInfo& default_instance() {
570 return *internal_default_instance();
571 }
internal_default_instance()572 static inline const RetryInfo* internal_default_instance() {
573 return reinterpret_cast<const RetryInfo*>(
574 &_RetryInfo_default_instance_);
575 }
576 static constexpr int kIndexInFileMessages =
577 2;
578
swap(RetryInfo & a,RetryInfo & b)579 friend void swap(RetryInfo& a, RetryInfo& b) {
580 a.Swap(&b);
581 }
Swap(RetryInfo * other)582 inline void Swap(RetryInfo* other) {
583 if (other == this) return;
584 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
585 if (GetOwningArena() != nullptr &&
586 GetOwningArena() == other->GetOwningArena()) {
587 #else // PROTOBUF_FORCE_COPY_IN_SWAP
588 if (GetOwningArena() == other->GetOwningArena()) {
589 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
590 InternalSwap(other);
591 } else {
592 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
593 }
594 }
595 void UnsafeArenaSwap(RetryInfo* other) {
596 if (other == this) return;
597 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
598 InternalSwap(other);
599 }
600
601 // implements Message ----------------------------------------------
602
603 RetryInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
604 return CreateMaybeMessage<RetryInfo>(arena);
605 }
606 RetryInfo* New() const {
607 return New(nullptr);
608 }
609 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
610 void CopyFrom(const RetryInfo& from);
611 void MergeFrom(const RetryInfo& from);
612 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
613 bool IsInitialized() const final;
614
615 size_t ByteSizeLong() const final;
616 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
617 ::uint8_t* _InternalSerialize(
618 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
619 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
620
621 private:
622 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
623 void SharedDtor();
624 void SetCachedSize(int size) const;
625 void InternalSwap(RetryInfo* other);
626
627 private:
628 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
629 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
630 return "fcp.client.RetryInfo";
631 }
632 protected:
633 explicit RetryInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
634 bool is_message_owned = false);
635 public:
636
637 std::string GetTypeName() const final;
638
639 // nested types ----------------------------------------------------
640
641 // accessors -------------------------------------------------------
642
643 enum : int {
644 kRetryTokenFieldNumber = 1,
645 kMinimumDelayFieldNumber = 2,
646 };
647 // string retry_token = 1;
648 void clear_retry_token();
649 const std::string& retry_token() const;
650 template <typename ArgT0 = const std::string&, typename... ArgT>
651 void set_retry_token(ArgT0&& arg0, ArgT... args);
652 std::string* mutable_retry_token();
653 PROTOBUF_NODISCARD std::string* release_retry_token();
654 void set_allocated_retry_token(std::string* retry_token);
655 private:
656 const std::string& _internal_retry_token() const;
657 inline PROTOBUF_ALWAYS_INLINE void _internal_set_retry_token(const std::string& value);
658 std::string* _internal_mutable_retry_token();
659 public:
660
661 // .google.protobuf.Duration minimum_delay = 2;
662 bool has_minimum_delay() const;
663 private:
664 bool _internal_has_minimum_delay() const;
665 public:
666 void clear_minimum_delay();
667 const ::PROTOBUF_NAMESPACE_ID::Duration& minimum_delay() const;
668 PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Duration* release_minimum_delay();
669 ::PROTOBUF_NAMESPACE_ID::Duration* mutable_minimum_delay();
670 void set_allocated_minimum_delay(::PROTOBUF_NAMESPACE_ID::Duration* minimum_delay);
671 private:
672 const ::PROTOBUF_NAMESPACE_ID::Duration& _internal_minimum_delay() const;
673 ::PROTOBUF_NAMESPACE_ID::Duration* _internal_mutable_minimum_delay();
674 public:
675 void unsafe_arena_set_allocated_minimum_delay(
676 ::PROTOBUF_NAMESPACE_ID::Duration* minimum_delay);
677 ::PROTOBUF_NAMESPACE_ID::Duration* unsafe_arena_release_minimum_delay();
678
679 // @@protoc_insertion_point(class_scope:fcp.client.RetryInfo)
680 private:
681 class _Internal;
682
683 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
684 typedef void InternalArenaConstructable_;
685 typedef void DestructorSkippable_;
686 struct Impl_ {
687 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr retry_token_;
688 ::PROTOBUF_NAMESPACE_ID::Duration* minimum_delay_;
689 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
690 };
691 union { Impl_ _impl_; };
692 friend struct ::TableStruct_fcp_2fclient_2ffl_5frunner_2eproto;
693 };
694 // -------------------------------------------------------------------
695
696 class FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse,
697 std::string, ::tensorflow::TensorProto,
698 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
699 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
700 public:
701 typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse,
702 std::string, ::tensorflow::TensorProto,
703 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
704 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
705 FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse();
706 explicit PROTOBUF_CONSTEXPR FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse(
707 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
708 explicit FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
709 void MergeFrom(const FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse& other);
internal_default_instance()710 static const FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse*>(&_FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse_default_instance_); }
ValidateKey(std::string * s)711 static bool ValidateKey(std::string* s) {
712 return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "fcp.client.FLRunnerTensorflowSpecResult.OutputTensorsEntry.key");
713 }
ValidateValue(void *)714 static bool ValidateValue(void*) { return true; }
715 friend struct ::TableStruct_fcp_2fclient_2ffl_5frunner_2eproto;
716 };
717
718 // -------------------------------------------------------------------
719
720 class FLRunnerTensorflowSpecResult final :
721 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:fcp.client.FLRunnerTensorflowSpecResult) */ {
722 public:
FLRunnerTensorflowSpecResult()723 inline FLRunnerTensorflowSpecResult() : FLRunnerTensorflowSpecResult(nullptr) {}
724 ~FLRunnerTensorflowSpecResult() override;
725 explicit PROTOBUF_CONSTEXPR FLRunnerTensorflowSpecResult(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
726
727 FLRunnerTensorflowSpecResult(const FLRunnerTensorflowSpecResult& from);
FLRunnerTensorflowSpecResult(FLRunnerTensorflowSpecResult && from)728 FLRunnerTensorflowSpecResult(FLRunnerTensorflowSpecResult&& from) noexcept
729 : FLRunnerTensorflowSpecResult() {
730 *this = ::std::move(from);
731 }
732
733 inline FLRunnerTensorflowSpecResult& operator=(const FLRunnerTensorflowSpecResult& from) {
734 if (this == &from) return *this;
735 CopyFrom(from);
736 return *this;
737 }
738 inline FLRunnerTensorflowSpecResult& operator=(FLRunnerTensorflowSpecResult&& from) noexcept {
739 if (this == &from) return *this;
740 if (GetOwningArena() == from.GetOwningArena()
741 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
742 && GetOwningArena() != nullptr
743 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
744 ) {
745 InternalSwap(&from);
746 } else {
747 CopyFrom(from);
748 }
749 return *this;
750 }
751
default_instance()752 static const FLRunnerTensorflowSpecResult& default_instance() {
753 return *internal_default_instance();
754 }
internal_default_instance()755 static inline const FLRunnerTensorflowSpecResult* internal_default_instance() {
756 return reinterpret_cast<const FLRunnerTensorflowSpecResult*>(
757 &_FLRunnerTensorflowSpecResult_default_instance_);
758 }
759 static constexpr int kIndexInFileMessages =
760 4;
761
swap(FLRunnerTensorflowSpecResult & a,FLRunnerTensorflowSpecResult & b)762 friend void swap(FLRunnerTensorflowSpecResult& a, FLRunnerTensorflowSpecResult& b) {
763 a.Swap(&b);
764 }
Swap(FLRunnerTensorflowSpecResult * other)765 inline void Swap(FLRunnerTensorflowSpecResult* other) {
766 if (other == this) return;
767 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
768 if (GetOwningArena() != nullptr &&
769 GetOwningArena() == other->GetOwningArena()) {
770 #else // PROTOBUF_FORCE_COPY_IN_SWAP
771 if (GetOwningArena() == other->GetOwningArena()) {
772 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
773 InternalSwap(other);
774 } else {
775 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
776 }
777 }
778 void UnsafeArenaSwap(FLRunnerTensorflowSpecResult* other) {
779 if (other == this) return;
780 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
781 InternalSwap(other);
782 }
783
784 // implements Message ----------------------------------------------
785
786 FLRunnerTensorflowSpecResult* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
787 return CreateMaybeMessage<FLRunnerTensorflowSpecResult>(arena);
788 }
789 FLRunnerTensorflowSpecResult* New() const {
790 return New(nullptr);
791 }
792 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
793 void CopyFrom(const FLRunnerTensorflowSpecResult& from);
794 void MergeFrom(const FLRunnerTensorflowSpecResult& from);
795 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
796 bool IsInitialized() const final;
797
798 size_t ByteSizeLong() const final;
799 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
800 ::uint8_t* _InternalSerialize(
801 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
802 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
803
804 private:
805 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
806 void SharedDtor();
807 void SetCachedSize(int size) const;
808 void InternalSwap(FLRunnerTensorflowSpecResult* other);
809
810 private:
811 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
812 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
813 return "fcp.client.FLRunnerTensorflowSpecResult";
814 }
815 protected:
816 explicit FLRunnerTensorflowSpecResult(::PROTOBUF_NAMESPACE_ID::Arena* arena,
817 bool is_message_owned = false);
818 public:
819
820 std::string GetTypeName() const final;
821
822 // nested types ----------------------------------------------------
823
824
825 // accessors -------------------------------------------------------
826
827 enum : int {
828 kOutputTensorsFieldNumber = 3,
829 kCheckpointOutputFilenameFieldNumber = 2,
830 kOutcomeFieldNumber = 1,
831 };
832 // map<string, .tensorflow.TensorProto> output_tensors = 3;
833 int output_tensors_size() const;
834 private:
835 int _internal_output_tensors_size() const;
836 public:
837 void clear_output_tensors();
838 private:
839 const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::TensorProto >&
840 _internal_output_tensors() const;
841 ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::TensorProto >*
842 _internal_mutable_output_tensors();
843 public:
844 const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::TensorProto >&
845 output_tensors() const;
846 ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::TensorProto >*
847 mutable_output_tensors();
848
849 // string checkpoint_output_filename = 2;
850 void clear_checkpoint_output_filename();
851 const std::string& checkpoint_output_filename() const;
852 template <typename ArgT0 = const std::string&, typename... ArgT>
853 void set_checkpoint_output_filename(ArgT0&& arg0, ArgT... args);
854 std::string* mutable_checkpoint_output_filename();
855 PROTOBUF_NODISCARD std::string* release_checkpoint_output_filename();
856 void set_allocated_checkpoint_output_filename(std::string* checkpoint_output_filename);
857 private:
858 const std::string& _internal_checkpoint_output_filename() const;
859 inline PROTOBUF_ALWAYS_INLINE void _internal_set_checkpoint_output_filename(const std::string& value);
860 std::string* _internal_mutable_checkpoint_output_filename();
861 public:
862
863 // .fcp.client.engine.PhaseOutcome outcome = 1;
864 void clear_outcome();
865 ::fcp::client::engine::PhaseOutcome outcome() const;
866 void set_outcome(::fcp::client::engine::PhaseOutcome value);
867 private:
868 ::fcp::client::engine::PhaseOutcome _internal_outcome() const;
869 void _internal_set_outcome(::fcp::client::engine::PhaseOutcome value);
870 public:
871
872 // @@protoc_insertion_point(class_scope:fcp.client.FLRunnerTensorflowSpecResult)
873 private:
874 class _Internal;
875
876 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
877 typedef void InternalArenaConstructable_;
878 typedef void DestructorSkippable_;
879 struct Impl_ {
880 ::PROTOBUF_NAMESPACE_ID::internal::MapFieldLite<
881 FLRunnerTensorflowSpecResult_OutputTensorsEntry_DoNotUse,
882 std::string, ::tensorflow::TensorProto,
883 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
884 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> output_tensors_;
885 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr checkpoint_output_filename_;
886 int outcome_;
887 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
888 };
889 union { Impl_ _impl_; };
890 friend struct ::TableStruct_fcp_2fclient_2ffl_5frunner_2eproto;
891 };
892 // ===================================================================
893
894
895 // ===================================================================
896
897 #ifdef __GNUC__
898 #pragma GCC diagnostic push
899 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
900 #endif // __GNUC__
901 // FLRunnerResult_ExampleStats
902
903 // int32 example_count = 1;
clear_example_count()904 inline void FLRunnerResult_ExampleStats::clear_example_count() {
905 _impl_.example_count_ = 0;
906 }
_internal_example_count()907 inline ::int32_t FLRunnerResult_ExampleStats::_internal_example_count() const {
908 return _impl_.example_count_;
909 }
example_count()910 inline ::int32_t FLRunnerResult_ExampleStats::example_count() const {
911 // @@protoc_insertion_point(field_get:fcp.client.FLRunnerResult.ExampleStats.example_count)
912 return _internal_example_count();
913 }
_internal_set_example_count(::int32_t value)914 inline void FLRunnerResult_ExampleStats::_internal_set_example_count(::int32_t value) {
915
916 _impl_.example_count_ = value;
917 }
set_example_count(::int32_t value)918 inline void FLRunnerResult_ExampleStats::set_example_count(::int32_t value) {
919 _internal_set_example_count(value);
920 // @@protoc_insertion_point(field_set:fcp.client.FLRunnerResult.ExampleStats.example_count)
921 }
922
923 // int64 example_size_bytes = 2;
clear_example_size_bytes()924 inline void FLRunnerResult_ExampleStats::clear_example_size_bytes() {
925 _impl_.example_size_bytes_ = ::int64_t{0};
926 }
_internal_example_size_bytes()927 inline ::int64_t FLRunnerResult_ExampleStats::_internal_example_size_bytes() const {
928 return _impl_.example_size_bytes_;
929 }
example_size_bytes()930 inline ::int64_t FLRunnerResult_ExampleStats::example_size_bytes() const {
931 // @@protoc_insertion_point(field_get:fcp.client.FLRunnerResult.ExampleStats.example_size_bytes)
932 return _internal_example_size_bytes();
933 }
_internal_set_example_size_bytes(::int64_t value)934 inline void FLRunnerResult_ExampleStats::_internal_set_example_size_bytes(::int64_t value) {
935
936 _impl_.example_size_bytes_ = value;
937 }
set_example_size_bytes(::int64_t value)938 inline void FLRunnerResult_ExampleStats::set_example_size_bytes(::int64_t value) {
939 _internal_set_example_size_bytes(value);
940 // @@protoc_insertion_point(field_set:fcp.client.FLRunnerResult.ExampleStats.example_size_bytes)
941 }
942
943 // -------------------------------------------------------------------
944
945 // FLRunnerResult
946
947 // .fcp.client.RetryInfo retry_info = 4;
_internal_has_retry_info()948 inline bool FLRunnerResult::_internal_has_retry_info() const {
949 return this != internal_default_instance() && _impl_.retry_info_ != nullptr;
950 }
has_retry_info()951 inline bool FLRunnerResult::has_retry_info() const {
952 return _internal_has_retry_info();
953 }
clear_retry_info()954 inline void FLRunnerResult::clear_retry_info() {
955 if (GetArenaForAllocation() == nullptr && _impl_.retry_info_ != nullptr) {
956 delete _impl_.retry_info_;
957 }
958 _impl_.retry_info_ = nullptr;
959 }
_internal_retry_info()960 inline const ::fcp::client::RetryInfo& FLRunnerResult::_internal_retry_info() const {
961 const ::fcp::client::RetryInfo* p = _impl_.retry_info_;
962 return p != nullptr ? *p : reinterpret_cast<const ::fcp::client::RetryInfo&>(
963 ::fcp::client::_RetryInfo_default_instance_);
964 }
retry_info()965 inline const ::fcp::client::RetryInfo& FLRunnerResult::retry_info() const {
966 // @@protoc_insertion_point(field_get:fcp.client.FLRunnerResult.retry_info)
967 return _internal_retry_info();
968 }
unsafe_arena_set_allocated_retry_info(::fcp::client::RetryInfo * retry_info)969 inline void FLRunnerResult::unsafe_arena_set_allocated_retry_info(
970 ::fcp::client::RetryInfo* retry_info) {
971 if (GetArenaForAllocation() == nullptr) {
972 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.retry_info_);
973 }
974 _impl_.retry_info_ = retry_info;
975 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:fcp.client.FLRunnerResult.retry_info)
976 }
release_retry_info()977 inline ::fcp::client::RetryInfo* FLRunnerResult::release_retry_info() {
978
979 ::fcp::client::RetryInfo* temp = _impl_.retry_info_;
980 _impl_.retry_info_ = nullptr;
981 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
982 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
983 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
984 if (GetArenaForAllocation() == nullptr) { delete old; }
985 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
986 if (GetArenaForAllocation() != nullptr) {
987 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
988 }
989 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
990 return temp;
991 }
unsafe_arena_release_retry_info()992 inline ::fcp::client::RetryInfo* FLRunnerResult::unsafe_arena_release_retry_info() {
993 // @@protoc_insertion_point(field_release:fcp.client.FLRunnerResult.retry_info)
994
995 ::fcp::client::RetryInfo* temp = _impl_.retry_info_;
996 _impl_.retry_info_ = nullptr;
997 return temp;
998 }
_internal_mutable_retry_info()999 inline ::fcp::client::RetryInfo* FLRunnerResult::_internal_mutable_retry_info() {
1000
1001 if (_impl_.retry_info_ == nullptr) {
1002 auto* p = CreateMaybeMessage<::fcp::client::RetryInfo>(GetArenaForAllocation());
1003 _impl_.retry_info_ = p;
1004 }
1005 return _impl_.retry_info_;
1006 }
mutable_retry_info()1007 inline ::fcp::client::RetryInfo* FLRunnerResult::mutable_retry_info() {
1008 ::fcp::client::RetryInfo* _msg = _internal_mutable_retry_info();
1009 // @@protoc_insertion_point(field_mutable:fcp.client.FLRunnerResult.retry_info)
1010 return _msg;
1011 }
set_allocated_retry_info(::fcp::client::RetryInfo * retry_info)1012 inline void FLRunnerResult::set_allocated_retry_info(::fcp::client::RetryInfo* retry_info) {
1013 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
1014 if (message_arena == nullptr) {
1015 delete _impl_.retry_info_;
1016 }
1017 if (retry_info) {
1018 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1019 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(retry_info);
1020 if (message_arena != submessage_arena) {
1021 retry_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1022 message_arena, retry_info, submessage_arena);
1023 }
1024
1025 } else {
1026
1027 }
1028 _impl_.retry_info_ = retry_info;
1029 // @@protoc_insertion_point(field_set_allocated:fcp.client.FLRunnerResult.retry_info)
1030 }
1031
1032 // .fcp.client.FLRunnerResult.ContributionResult contribution_result = 5;
clear_contribution_result()1033 inline void FLRunnerResult::clear_contribution_result() {
1034 _impl_.contribution_result_ = 0;
1035 }
_internal_contribution_result()1036 inline ::fcp::client::FLRunnerResult_ContributionResult FLRunnerResult::_internal_contribution_result() const {
1037 return static_cast< ::fcp::client::FLRunnerResult_ContributionResult >(_impl_.contribution_result_);
1038 }
contribution_result()1039 inline ::fcp::client::FLRunnerResult_ContributionResult FLRunnerResult::contribution_result() const {
1040 // @@protoc_insertion_point(field_get:fcp.client.FLRunnerResult.contribution_result)
1041 return _internal_contribution_result();
1042 }
_internal_set_contribution_result(::fcp::client::FLRunnerResult_ContributionResult value)1043 inline void FLRunnerResult::_internal_set_contribution_result(::fcp::client::FLRunnerResult_ContributionResult value) {
1044
1045 _impl_.contribution_result_ = value;
1046 }
set_contribution_result(::fcp::client::FLRunnerResult_ContributionResult value)1047 inline void FLRunnerResult::set_contribution_result(::fcp::client::FLRunnerResult_ContributionResult value) {
1048 _internal_set_contribution_result(value);
1049 // @@protoc_insertion_point(field_set:fcp.client.FLRunnerResult.contribution_result)
1050 }
1051
1052 // string error_message = 200;
clear_error_message()1053 inline void FLRunnerResult::clear_error_message() {
1054 _impl_.error_message_.ClearToEmpty();
1055 }
error_message()1056 inline const std::string& FLRunnerResult::error_message() const {
1057 // @@protoc_insertion_point(field_get:fcp.client.FLRunnerResult.error_message)
1058 return _internal_error_message();
1059 }
1060 template <typename ArgT0, typename... ArgT>
1061 inline PROTOBUF_ALWAYS_INLINE
set_error_message(ArgT0 && arg0,ArgT...args)1062 void FLRunnerResult::set_error_message(ArgT0&& arg0, ArgT... args) {
1063
1064 _impl_.error_message_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1065 // @@protoc_insertion_point(field_set:fcp.client.FLRunnerResult.error_message)
1066 }
mutable_error_message()1067 inline std::string* FLRunnerResult::mutable_error_message() {
1068 std::string* _s = _internal_mutable_error_message();
1069 // @@protoc_insertion_point(field_mutable:fcp.client.FLRunnerResult.error_message)
1070 return _s;
1071 }
_internal_error_message()1072 inline const std::string& FLRunnerResult::_internal_error_message() const {
1073 return _impl_.error_message_.Get();
1074 }
_internal_set_error_message(const std::string & value)1075 inline void FLRunnerResult::_internal_set_error_message(const std::string& value) {
1076
1077 _impl_.error_message_.Set(value, GetArenaForAllocation());
1078 }
_internal_mutable_error_message()1079 inline std::string* FLRunnerResult::_internal_mutable_error_message() {
1080
1081 return _impl_.error_message_.Mutable(GetArenaForAllocation());
1082 }
release_error_message()1083 inline std::string* FLRunnerResult::release_error_message() {
1084 // @@protoc_insertion_point(field_release:fcp.client.FLRunnerResult.error_message)
1085 return _impl_.error_message_.Release();
1086 }
set_allocated_error_message(std::string * error_message)1087 inline void FLRunnerResult::set_allocated_error_message(std::string* error_message) {
1088 _impl_.error_message_.SetAllocated(error_message, GetArenaForAllocation());
1089 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1090 if (_impl_.error_message_.IsDefault()) {
1091 _impl_.error_message_.Set("", GetArenaForAllocation());
1092 }
1093 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1094 // @@protoc_insertion_point(field_set_allocated:fcp.client.FLRunnerResult.error_message)
1095 }
1096
1097 // .fcp.client.FLRunnerResult.ErrorStatus error_status = 201;
clear_error_status()1098 inline void FLRunnerResult::clear_error_status() {
1099 _impl_.error_status_ = 0;
1100 }
_internal_error_status()1101 inline ::fcp::client::FLRunnerResult_ErrorStatus FLRunnerResult::_internal_error_status() const {
1102 return static_cast< ::fcp::client::FLRunnerResult_ErrorStatus >(_impl_.error_status_);
1103 }
error_status()1104 inline ::fcp::client::FLRunnerResult_ErrorStatus FLRunnerResult::error_status() const {
1105 // @@protoc_insertion_point(field_get:fcp.client.FLRunnerResult.error_status)
1106 return _internal_error_status();
1107 }
_internal_set_error_status(::fcp::client::FLRunnerResult_ErrorStatus value)1108 inline void FLRunnerResult::_internal_set_error_status(::fcp::client::FLRunnerResult_ErrorStatus value) {
1109
1110 _impl_.error_status_ = value;
1111 }
set_error_status(::fcp::client::FLRunnerResult_ErrorStatus value)1112 inline void FLRunnerResult::set_error_status(::fcp::client::FLRunnerResult_ErrorStatus value) {
1113 _internal_set_error_status(value);
1114 // @@protoc_insertion_point(field_set:fcp.client.FLRunnerResult.error_status)
1115 }
1116
1117 // .fcp.client.FLRunnerResult.ExampleStats example_stats = 202;
_internal_has_example_stats()1118 inline bool FLRunnerResult::_internal_has_example_stats() const {
1119 return this != internal_default_instance() && _impl_.example_stats_ != nullptr;
1120 }
has_example_stats()1121 inline bool FLRunnerResult::has_example_stats() const {
1122 return _internal_has_example_stats();
1123 }
clear_example_stats()1124 inline void FLRunnerResult::clear_example_stats() {
1125 if (GetArenaForAllocation() == nullptr && _impl_.example_stats_ != nullptr) {
1126 delete _impl_.example_stats_;
1127 }
1128 _impl_.example_stats_ = nullptr;
1129 }
_internal_example_stats()1130 inline const ::fcp::client::FLRunnerResult_ExampleStats& FLRunnerResult::_internal_example_stats() const {
1131 const ::fcp::client::FLRunnerResult_ExampleStats* p = _impl_.example_stats_;
1132 return p != nullptr ? *p : reinterpret_cast<const ::fcp::client::FLRunnerResult_ExampleStats&>(
1133 ::fcp::client::_FLRunnerResult_ExampleStats_default_instance_);
1134 }
example_stats()1135 inline const ::fcp::client::FLRunnerResult_ExampleStats& FLRunnerResult::example_stats() const {
1136 // @@protoc_insertion_point(field_get:fcp.client.FLRunnerResult.example_stats)
1137 return _internal_example_stats();
1138 }
unsafe_arena_set_allocated_example_stats(::fcp::client::FLRunnerResult_ExampleStats * example_stats)1139 inline void FLRunnerResult::unsafe_arena_set_allocated_example_stats(
1140 ::fcp::client::FLRunnerResult_ExampleStats* example_stats) {
1141 if (GetArenaForAllocation() == nullptr) {
1142 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.example_stats_);
1143 }
1144 _impl_.example_stats_ = example_stats;
1145 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:fcp.client.FLRunnerResult.example_stats)
1146 }
release_example_stats()1147 inline ::fcp::client::FLRunnerResult_ExampleStats* FLRunnerResult::release_example_stats() {
1148
1149 ::fcp::client::FLRunnerResult_ExampleStats* temp = _impl_.example_stats_;
1150 _impl_.example_stats_ = nullptr;
1151 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
1152 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
1153 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1154 if (GetArenaForAllocation() == nullptr) { delete old; }
1155 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
1156 if (GetArenaForAllocation() != nullptr) {
1157 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1158 }
1159 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
1160 return temp;
1161 }
unsafe_arena_release_example_stats()1162 inline ::fcp::client::FLRunnerResult_ExampleStats* FLRunnerResult::unsafe_arena_release_example_stats() {
1163 // @@protoc_insertion_point(field_release:fcp.client.FLRunnerResult.example_stats)
1164
1165 ::fcp::client::FLRunnerResult_ExampleStats* temp = _impl_.example_stats_;
1166 _impl_.example_stats_ = nullptr;
1167 return temp;
1168 }
_internal_mutable_example_stats()1169 inline ::fcp::client::FLRunnerResult_ExampleStats* FLRunnerResult::_internal_mutable_example_stats() {
1170
1171 if (_impl_.example_stats_ == nullptr) {
1172 auto* p = CreateMaybeMessage<::fcp::client::FLRunnerResult_ExampleStats>(GetArenaForAllocation());
1173 _impl_.example_stats_ = p;
1174 }
1175 return _impl_.example_stats_;
1176 }
mutable_example_stats()1177 inline ::fcp::client::FLRunnerResult_ExampleStats* FLRunnerResult::mutable_example_stats() {
1178 ::fcp::client::FLRunnerResult_ExampleStats* _msg = _internal_mutable_example_stats();
1179 // @@protoc_insertion_point(field_mutable:fcp.client.FLRunnerResult.example_stats)
1180 return _msg;
1181 }
set_allocated_example_stats(::fcp::client::FLRunnerResult_ExampleStats * example_stats)1182 inline void FLRunnerResult::set_allocated_example_stats(::fcp::client::FLRunnerResult_ExampleStats* example_stats) {
1183 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
1184 if (message_arena == nullptr) {
1185 delete _impl_.example_stats_;
1186 }
1187 if (example_stats) {
1188 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1189 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(example_stats);
1190 if (message_arena != submessage_arena) {
1191 example_stats = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1192 message_arena, example_stats, submessage_arena);
1193 }
1194
1195 } else {
1196
1197 }
1198 _impl_.example_stats_ = example_stats;
1199 // @@protoc_insertion_point(field_set_allocated:fcp.client.FLRunnerResult.example_stats)
1200 }
1201
1202 // -------------------------------------------------------------------
1203
1204 // RetryInfo
1205
1206 // string retry_token = 1;
clear_retry_token()1207 inline void RetryInfo::clear_retry_token() {
1208 _impl_.retry_token_.ClearToEmpty();
1209 }
retry_token()1210 inline const std::string& RetryInfo::retry_token() const {
1211 // @@protoc_insertion_point(field_get:fcp.client.RetryInfo.retry_token)
1212 return _internal_retry_token();
1213 }
1214 template <typename ArgT0, typename... ArgT>
1215 inline PROTOBUF_ALWAYS_INLINE
set_retry_token(ArgT0 && arg0,ArgT...args)1216 void RetryInfo::set_retry_token(ArgT0&& arg0, ArgT... args) {
1217
1218 _impl_.retry_token_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1219 // @@protoc_insertion_point(field_set:fcp.client.RetryInfo.retry_token)
1220 }
mutable_retry_token()1221 inline std::string* RetryInfo::mutable_retry_token() {
1222 std::string* _s = _internal_mutable_retry_token();
1223 // @@protoc_insertion_point(field_mutable:fcp.client.RetryInfo.retry_token)
1224 return _s;
1225 }
_internal_retry_token()1226 inline const std::string& RetryInfo::_internal_retry_token() const {
1227 return _impl_.retry_token_.Get();
1228 }
_internal_set_retry_token(const std::string & value)1229 inline void RetryInfo::_internal_set_retry_token(const std::string& value) {
1230
1231 _impl_.retry_token_.Set(value, GetArenaForAllocation());
1232 }
_internal_mutable_retry_token()1233 inline std::string* RetryInfo::_internal_mutable_retry_token() {
1234
1235 return _impl_.retry_token_.Mutable(GetArenaForAllocation());
1236 }
release_retry_token()1237 inline std::string* RetryInfo::release_retry_token() {
1238 // @@protoc_insertion_point(field_release:fcp.client.RetryInfo.retry_token)
1239 return _impl_.retry_token_.Release();
1240 }
set_allocated_retry_token(std::string * retry_token)1241 inline void RetryInfo::set_allocated_retry_token(std::string* retry_token) {
1242 _impl_.retry_token_.SetAllocated(retry_token, GetArenaForAllocation());
1243 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1244 if (_impl_.retry_token_.IsDefault()) {
1245 _impl_.retry_token_.Set("", GetArenaForAllocation());
1246 }
1247 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1248 // @@protoc_insertion_point(field_set_allocated:fcp.client.RetryInfo.retry_token)
1249 }
1250
1251 // .google.protobuf.Duration minimum_delay = 2;
_internal_has_minimum_delay()1252 inline bool RetryInfo::_internal_has_minimum_delay() const {
1253 return this != internal_default_instance() && _impl_.minimum_delay_ != nullptr;
1254 }
has_minimum_delay()1255 inline bool RetryInfo::has_minimum_delay() const {
1256 return _internal_has_minimum_delay();
1257 }
_internal_minimum_delay()1258 inline const ::PROTOBUF_NAMESPACE_ID::Duration& RetryInfo::_internal_minimum_delay() const {
1259 const ::PROTOBUF_NAMESPACE_ID::Duration* p = _impl_.minimum_delay_;
1260 return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Duration&>(
1261 ::PROTOBUF_NAMESPACE_ID::_Duration_default_instance_);
1262 }
minimum_delay()1263 inline const ::PROTOBUF_NAMESPACE_ID::Duration& RetryInfo::minimum_delay() const {
1264 // @@protoc_insertion_point(field_get:fcp.client.RetryInfo.minimum_delay)
1265 return _internal_minimum_delay();
1266 }
unsafe_arena_set_allocated_minimum_delay(::PROTOBUF_NAMESPACE_ID::Duration * minimum_delay)1267 inline void RetryInfo::unsafe_arena_set_allocated_minimum_delay(
1268 ::PROTOBUF_NAMESPACE_ID::Duration* minimum_delay) {
1269 if (GetArenaForAllocation() == nullptr) {
1270 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.minimum_delay_);
1271 }
1272 _impl_.minimum_delay_ = minimum_delay;
1273 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:fcp.client.RetryInfo.minimum_delay)
1274 }
release_minimum_delay()1275 inline ::PROTOBUF_NAMESPACE_ID::Duration* RetryInfo::release_minimum_delay() {
1276
1277 ::PROTOBUF_NAMESPACE_ID::Duration* temp = _impl_.minimum_delay_;
1278 _impl_.minimum_delay_ = nullptr;
1279 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
1280 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
1281 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1282 if (GetArenaForAllocation() == nullptr) { delete old; }
1283 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
1284 if (GetArenaForAllocation() != nullptr) {
1285 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1286 }
1287 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
1288 return temp;
1289 }
unsafe_arena_release_minimum_delay()1290 inline ::PROTOBUF_NAMESPACE_ID::Duration* RetryInfo::unsafe_arena_release_minimum_delay() {
1291 // @@protoc_insertion_point(field_release:fcp.client.RetryInfo.minimum_delay)
1292
1293 ::PROTOBUF_NAMESPACE_ID::Duration* temp = _impl_.minimum_delay_;
1294 _impl_.minimum_delay_ = nullptr;
1295 return temp;
1296 }
_internal_mutable_minimum_delay()1297 inline ::PROTOBUF_NAMESPACE_ID::Duration* RetryInfo::_internal_mutable_minimum_delay() {
1298
1299 if (_impl_.minimum_delay_ == nullptr) {
1300 auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Duration>(GetArenaForAllocation());
1301 _impl_.minimum_delay_ = p;
1302 }
1303 return _impl_.minimum_delay_;
1304 }
mutable_minimum_delay()1305 inline ::PROTOBUF_NAMESPACE_ID::Duration* RetryInfo::mutable_minimum_delay() {
1306 ::PROTOBUF_NAMESPACE_ID::Duration* _msg = _internal_mutable_minimum_delay();
1307 // @@protoc_insertion_point(field_mutable:fcp.client.RetryInfo.minimum_delay)
1308 return _msg;
1309 }
set_allocated_minimum_delay(::PROTOBUF_NAMESPACE_ID::Duration * minimum_delay)1310 inline void RetryInfo::set_allocated_minimum_delay(::PROTOBUF_NAMESPACE_ID::Duration* minimum_delay) {
1311 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
1312 if (message_arena == nullptr) {
1313 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.minimum_delay_);
1314 }
1315 if (minimum_delay) {
1316 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1317 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
1318 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(minimum_delay));
1319 if (message_arena != submessage_arena) {
1320 minimum_delay = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1321 message_arena, minimum_delay, submessage_arena);
1322 }
1323
1324 } else {
1325
1326 }
1327 _impl_.minimum_delay_ = minimum_delay;
1328 // @@protoc_insertion_point(field_set_allocated:fcp.client.RetryInfo.minimum_delay)
1329 }
1330
1331 // -------------------------------------------------------------------
1332
1333 // -------------------------------------------------------------------
1334
1335 // FLRunnerTensorflowSpecResult
1336
1337 // .fcp.client.engine.PhaseOutcome outcome = 1;
clear_outcome()1338 inline void FLRunnerTensorflowSpecResult::clear_outcome() {
1339 _impl_.outcome_ = 0;
1340 }
_internal_outcome()1341 inline ::fcp::client::engine::PhaseOutcome FLRunnerTensorflowSpecResult::_internal_outcome() const {
1342 return static_cast< ::fcp::client::engine::PhaseOutcome >(_impl_.outcome_);
1343 }
outcome()1344 inline ::fcp::client::engine::PhaseOutcome FLRunnerTensorflowSpecResult::outcome() const {
1345 // @@protoc_insertion_point(field_get:fcp.client.FLRunnerTensorflowSpecResult.outcome)
1346 return _internal_outcome();
1347 }
_internal_set_outcome(::fcp::client::engine::PhaseOutcome value)1348 inline void FLRunnerTensorflowSpecResult::_internal_set_outcome(::fcp::client::engine::PhaseOutcome value) {
1349
1350 _impl_.outcome_ = value;
1351 }
set_outcome(::fcp::client::engine::PhaseOutcome value)1352 inline void FLRunnerTensorflowSpecResult::set_outcome(::fcp::client::engine::PhaseOutcome value) {
1353 _internal_set_outcome(value);
1354 // @@protoc_insertion_point(field_set:fcp.client.FLRunnerTensorflowSpecResult.outcome)
1355 }
1356
1357 // string checkpoint_output_filename = 2;
clear_checkpoint_output_filename()1358 inline void FLRunnerTensorflowSpecResult::clear_checkpoint_output_filename() {
1359 _impl_.checkpoint_output_filename_.ClearToEmpty();
1360 }
checkpoint_output_filename()1361 inline const std::string& FLRunnerTensorflowSpecResult::checkpoint_output_filename() const {
1362 // @@protoc_insertion_point(field_get:fcp.client.FLRunnerTensorflowSpecResult.checkpoint_output_filename)
1363 return _internal_checkpoint_output_filename();
1364 }
1365 template <typename ArgT0, typename... ArgT>
1366 inline PROTOBUF_ALWAYS_INLINE
set_checkpoint_output_filename(ArgT0 && arg0,ArgT...args)1367 void FLRunnerTensorflowSpecResult::set_checkpoint_output_filename(ArgT0&& arg0, ArgT... args) {
1368
1369 _impl_.checkpoint_output_filename_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1370 // @@protoc_insertion_point(field_set:fcp.client.FLRunnerTensorflowSpecResult.checkpoint_output_filename)
1371 }
mutable_checkpoint_output_filename()1372 inline std::string* FLRunnerTensorflowSpecResult::mutable_checkpoint_output_filename() {
1373 std::string* _s = _internal_mutable_checkpoint_output_filename();
1374 // @@protoc_insertion_point(field_mutable:fcp.client.FLRunnerTensorflowSpecResult.checkpoint_output_filename)
1375 return _s;
1376 }
_internal_checkpoint_output_filename()1377 inline const std::string& FLRunnerTensorflowSpecResult::_internal_checkpoint_output_filename() const {
1378 return _impl_.checkpoint_output_filename_.Get();
1379 }
_internal_set_checkpoint_output_filename(const std::string & value)1380 inline void FLRunnerTensorflowSpecResult::_internal_set_checkpoint_output_filename(const std::string& value) {
1381
1382 _impl_.checkpoint_output_filename_.Set(value, GetArenaForAllocation());
1383 }
_internal_mutable_checkpoint_output_filename()1384 inline std::string* FLRunnerTensorflowSpecResult::_internal_mutable_checkpoint_output_filename() {
1385
1386 return _impl_.checkpoint_output_filename_.Mutable(GetArenaForAllocation());
1387 }
release_checkpoint_output_filename()1388 inline std::string* FLRunnerTensorflowSpecResult::release_checkpoint_output_filename() {
1389 // @@protoc_insertion_point(field_release:fcp.client.FLRunnerTensorflowSpecResult.checkpoint_output_filename)
1390 return _impl_.checkpoint_output_filename_.Release();
1391 }
set_allocated_checkpoint_output_filename(std::string * checkpoint_output_filename)1392 inline void FLRunnerTensorflowSpecResult::set_allocated_checkpoint_output_filename(std::string* checkpoint_output_filename) {
1393 _impl_.checkpoint_output_filename_.SetAllocated(checkpoint_output_filename, GetArenaForAllocation());
1394 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1395 if (_impl_.checkpoint_output_filename_.IsDefault()) {
1396 _impl_.checkpoint_output_filename_.Set("", GetArenaForAllocation());
1397 }
1398 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1399 // @@protoc_insertion_point(field_set_allocated:fcp.client.FLRunnerTensorflowSpecResult.checkpoint_output_filename)
1400 }
1401
1402 // map<string, .tensorflow.TensorProto> output_tensors = 3;
_internal_output_tensors_size()1403 inline int FLRunnerTensorflowSpecResult::_internal_output_tensors_size() const {
1404 return _impl_.output_tensors_.size();
1405 }
output_tensors_size()1406 inline int FLRunnerTensorflowSpecResult::output_tensors_size() const {
1407 return _internal_output_tensors_size();
1408 }
1409 inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::TensorProto >&
_internal_output_tensors()1410 FLRunnerTensorflowSpecResult::_internal_output_tensors() const {
1411 return _impl_.output_tensors_.GetMap();
1412 }
1413 inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::TensorProto >&
output_tensors()1414 FLRunnerTensorflowSpecResult::output_tensors() const {
1415 // @@protoc_insertion_point(field_map:fcp.client.FLRunnerTensorflowSpecResult.output_tensors)
1416 return _internal_output_tensors();
1417 }
1418 inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::TensorProto >*
_internal_mutable_output_tensors()1419 FLRunnerTensorflowSpecResult::_internal_mutable_output_tensors() {
1420 return _impl_.output_tensors_.MutableMap();
1421 }
1422 inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::TensorProto >*
mutable_output_tensors()1423 FLRunnerTensorflowSpecResult::mutable_output_tensors() {
1424 // @@protoc_insertion_point(field_mutable_map:fcp.client.FLRunnerTensorflowSpecResult.output_tensors)
1425 return _internal_mutable_output_tensors();
1426 }
1427
1428 #ifdef __GNUC__
1429 #pragma GCC diagnostic pop
1430 #endif // __GNUC__
1431 // -------------------------------------------------------------------
1432
1433 // -------------------------------------------------------------------
1434
1435 // -------------------------------------------------------------------
1436
1437 // -------------------------------------------------------------------
1438
1439
1440 // @@protoc_insertion_point(namespace_scope)
1441
1442 } // namespace client
1443 } // namespace fcp
1444
1445 PROTOBUF_NAMESPACE_OPEN
1446
1447 template <> struct is_proto_enum< ::fcp::client::FLRunnerResult_ContributionResult> : ::std::true_type {};
1448 template <> struct is_proto_enum< ::fcp::client::FLRunnerResult_ErrorStatus> : ::std::true_type {};
1449
1450 PROTOBUF_NAMESPACE_CLOSE
1451
1452 // @@protoc_insertion_point(global_scope)
1453
1454 #include <google/protobuf/port_undef.inc>
1455 #endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_fcp_2fclient_2ffl_5frunner_2eproto
1456