1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: fcp/client/engine/engine.proto
3 
4 #include "fcp/client/engine/engine.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 {
23 namespace engine {
TaskRetry(::_pbi::ConstantInitialized)24 PROTOBUF_CONSTEXPR TaskRetry::TaskRetry(
25     ::_pbi::ConstantInitialized): _impl_{
26     /*decltype(_impl_.retry_token_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
27   , /*decltype(_impl_.delay_min_)*/::int64_t{0}
28   , /*decltype(_impl_.delay_max_)*/::int64_t{0}
29   , /*decltype(_impl_._cached_size_)*/{}} {}
30 struct TaskRetryDefaultTypeInternal {
TaskRetryDefaultTypeInternalfcp::client::engine::TaskRetryDefaultTypeInternal31   PROTOBUF_CONSTEXPR TaskRetryDefaultTypeInternal()
32       : _instance(::_pbi::ConstantInitialized{}) {}
~TaskRetryDefaultTypeInternalfcp::client::engine::TaskRetryDefaultTypeInternal33   ~TaskRetryDefaultTypeInternal() {}
34   union {  // NOLINT(misc-non-private-member-variables-in-classes)
35     TaskRetry _instance;
36   };
37 };
38 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TaskRetryDefaultTypeInternal _TaskRetry_default_instance_;
39 }  // namespace engine
40 }  // namespace client
41 }  // namespace fcp
42 namespace fcp {
43 namespace client {
44 namespace engine {
PhaseOutcome_IsValid(int value)45 bool PhaseOutcome_IsValid(int value) {
46   switch (value) {
47     case 0:
48     case 1:
49     case 2:
50     case 3:
51       return true;
52     default:
53       return false;
54   }
55 }
56 
57 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> PhaseOutcome_strings[4] = {};
58 
59 static const char PhaseOutcome_names[] =
60   "COMPLETED"
61   "ERROR"
62   "INTERRUPTED"
63   "PHASE_OUTCOME_UNDEFINED";
64 
65 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry PhaseOutcome_entries[] = {
66   { {PhaseOutcome_names + 0, 9}, 1 },
67   { {PhaseOutcome_names + 9, 5}, 3 },
68   { {PhaseOutcome_names + 14, 11}, 2 },
69   { {PhaseOutcome_names + 25, 23}, 0 },
70 };
71 
72 static const int PhaseOutcome_entries_by_number[] = {
73   3, // 0 -> PHASE_OUTCOME_UNDEFINED
74   0, // 1 -> COMPLETED
75   2, // 2 -> INTERRUPTED
76   1, // 3 -> ERROR
77 };
78 
PhaseOutcome_Name(PhaseOutcome value)79 const std::string& PhaseOutcome_Name(
80     PhaseOutcome value) {
81   static const bool dummy =
82       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
83           PhaseOutcome_entries,
84           PhaseOutcome_entries_by_number,
85           4, PhaseOutcome_strings);
86   (void) dummy;
87   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
88       PhaseOutcome_entries,
89       PhaseOutcome_entries_by_number,
90       4, value);
91   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
92                      PhaseOutcome_strings[idx].get();
93 }
PhaseOutcome_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,PhaseOutcome * value)94 bool PhaseOutcome_Parse(
95     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PhaseOutcome* value) {
96   int int_value;
97   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
98       PhaseOutcome_entries, 4, name, &int_value);
99   if (success) {
100     *value = static_cast<PhaseOutcome>(int_value);
101   }
102   return success;
103 }
DataSourceType_IsValid(int value)104 bool DataSourceType_IsValid(int value) {
105   switch (value) {
106     case 0:
107     case 1:
108     case 2:
109       return true;
110     default:
111       return false;
112   }
113 }
114 
115 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> DataSourceType_strings[3] = {};
116 
117 static const char DataSourceType_names[] =
118   "DATASET"
119   "FEED"
120   "TRAINING_DATA_SOURCE_UNDEFINED";
121 
122 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry DataSourceType_entries[] = {
123   { {DataSourceType_names + 0, 7}, 2 },
124   { {DataSourceType_names + 7, 4}, 1 },
125   { {DataSourceType_names + 11, 30}, 0 },
126 };
127 
128 static const int DataSourceType_entries_by_number[] = {
129   2, // 0 -> TRAINING_DATA_SOURCE_UNDEFINED
130   1, // 1 -> FEED
131   0, // 2 -> DATASET
132 };
133 
DataSourceType_Name(DataSourceType value)134 const std::string& DataSourceType_Name(
135     DataSourceType value) {
136   static const bool dummy =
137       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
138           DataSourceType_entries,
139           DataSourceType_entries_by_number,
140           3, DataSourceType_strings);
141   (void) dummy;
142   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
143       DataSourceType_entries,
144       DataSourceType_entries_by_number,
145       3, value);
146   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
147                      DataSourceType_strings[idx].get();
148 }
DataSourceType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,DataSourceType * value)149 bool DataSourceType_Parse(
150     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DataSourceType* value) {
151   int int_value;
152   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
153       DataSourceType_entries, 3, name, &int_value);
154   if (success) {
155     *value = static_cast<DataSourceType>(int_value);
156   }
157   return success;
158 }
159 
160 // ===================================================================
161 
162 class TaskRetry::_Internal {
163  public:
164 };
165 
TaskRetry(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)166 TaskRetry::TaskRetry(::PROTOBUF_NAMESPACE_ID::Arena* arena,
167                          bool is_message_owned)
168   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
169   SharedCtor(arena, is_message_owned);
170   // @@protoc_insertion_point(arena_constructor:fcp.client.engine.TaskRetry)
171 }
TaskRetry(const TaskRetry & from)172 TaskRetry::TaskRetry(const TaskRetry& from)
173   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
174   TaskRetry* const _this = this; (void)_this;
175   new (&_impl_) Impl_{
176       decltype(_impl_.retry_token_){}
177     , decltype(_impl_.delay_min_){}
178     , decltype(_impl_.delay_max_){}
179     , /*decltype(_impl_._cached_size_)*/{}};
180 
181   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
182   _impl_.retry_token_.InitDefault();
183   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
184     _impl_.retry_token_.Set("", GetArenaForAllocation());
185   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
186   if (!from._internal_retry_token().empty()) {
187     _this->_impl_.retry_token_.Set(from._internal_retry_token(),
188       _this->GetArenaForAllocation());
189   }
190   ::memcpy(&_impl_.delay_min_, &from._impl_.delay_min_,
191     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.delay_max_) -
192     reinterpret_cast<char*>(&_impl_.delay_min_)) + sizeof(_impl_.delay_max_));
193   // @@protoc_insertion_point(copy_constructor:fcp.client.engine.TaskRetry)
194 }
195 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)196 inline void TaskRetry::SharedCtor(
197     ::_pb::Arena* arena, bool is_message_owned) {
198   (void)arena;
199   (void)is_message_owned;
200   new (&_impl_) Impl_{
201       decltype(_impl_.retry_token_){}
202     , decltype(_impl_.delay_min_){::int64_t{0}}
203     , decltype(_impl_.delay_max_){::int64_t{0}}
204     , /*decltype(_impl_._cached_size_)*/{}
205   };
206   _impl_.retry_token_.InitDefault();
207   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
208     _impl_.retry_token_.Set("", GetArenaForAllocation());
209   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
210 }
211 
~TaskRetry()212 TaskRetry::~TaskRetry() {
213   // @@protoc_insertion_point(destructor:fcp.client.engine.TaskRetry)
214   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
215   (void)arena;
216     return;
217   }
218   SharedDtor();
219 }
220 
SharedDtor()221 inline void TaskRetry::SharedDtor() {
222   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
223   _impl_.retry_token_.Destroy();
224 }
225 
SetCachedSize(int size) const226 void TaskRetry::SetCachedSize(int size) const {
227   _impl_._cached_size_.Set(size);
228 }
229 
Clear()230 void TaskRetry::Clear() {
231 // @@protoc_insertion_point(message_clear_start:fcp.client.engine.TaskRetry)
232   ::uint32_t cached_has_bits = 0;
233   // Prevent compiler warnings about cached_has_bits being unused
234   (void) cached_has_bits;
235 
236   _impl_.retry_token_.ClearToEmpty();
237   ::memset(&_impl_.delay_min_, 0, static_cast<size_t>(
238       reinterpret_cast<char*>(&_impl_.delay_max_) -
239       reinterpret_cast<char*>(&_impl_.delay_min_)) + sizeof(_impl_.delay_max_));
240   _internal_metadata_.Clear<std::string>();
241 }
242 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)243 const char* TaskRetry::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
244 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
245   while (!ctx->Done(&ptr)) {
246     ::uint32_t tag;
247     ptr = ::_pbi::ReadTag(ptr, &tag);
248     switch (tag >> 3) {
249       // string retry_token = 1;
250       case 1:
251         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
252           auto str = _internal_mutable_retry_token();
253           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
254           CHK_(ptr);
255           CHK_(::_pbi::VerifyUTF8(str, nullptr));
256         } else {
257           goto handle_unusual;
258         }
259         continue;
260       // int64 delay_min = 2;
261       case 2:
262         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
263           _impl_.delay_min_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
264           CHK_(ptr);
265         } else {
266           goto handle_unusual;
267         }
268         continue;
269       // int64 delay_max = 3;
270       case 3:
271         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
272           _impl_.delay_max_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
273           CHK_(ptr);
274         } else {
275           goto handle_unusual;
276         }
277         continue;
278       default:
279         goto handle_unusual;
280     }  // switch
281   handle_unusual:
282     if ((tag == 0) || ((tag & 7) == 4)) {
283       CHK_(ptr);
284       ctx->SetLastTag(tag);
285       goto message_done;
286     }
287     ptr = UnknownFieldParse(
288         tag,
289         _internal_metadata_.mutable_unknown_fields<std::string>(),
290         ptr, ctx);
291     CHK_(ptr != nullptr);
292   }  // while
293 message_done:
294   return ptr;
295 failure:
296   ptr = nullptr;
297   goto message_done;
298 #undef CHK_
299 }
300 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const301 ::uint8_t* TaskRetry::_InternalSerialize(
302     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
303   // @@protoc_insertion_point(serialize_to_array_start:fcp.client.engine.TaskRetry)
304   ::uint32_t cached_has_bits = 0;
305   (void) cached_has_bits;
306 
307   // string retry_token = 1;
308   if (!this->_internal_retry_token().empty()) {
309     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
310       this->_internal_retry_token().data(), static_cast<int>(this->_internal_retry_token().length()),
311       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
312       "fcp.client.engine.TaskRetry.retry_token");
313     target = stream->WriteStringMaybeAliased(
314         1, this->_internal_retry_token(), target);
315   }
316 
317   // int64 delay_min = 2;
318   if (this->_internal_delay_min() != 0) {
319     target = stream->EnsureSpace(target);
320     target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_delay_min(), target);
321   }
322 
323   // int64 delay_max = 3;
324   if (this->_internal_delay_max() != 0) {
325     target = stream->EnsureSpace(target);
326     target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_delay_max(), target);
327   }
328 
329   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
330     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
331         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
332   }
333   // @@protoc_insertion_point(serialize_to_array_end:fcp.client.engine.TaskRetry)
334   return target;
335 }
336 
ByteSizeLong() const337 size_t TaskRetry::ByteSizeLong() const {
338 // @@protoc_insertion_point(message_byte_size_start:fcp.client.engine.TaskRetry)
339   size_t total_size = 0;
340 
341   ::uint32_t cached_has_bits = 0;
342   // Prevent compiler warnings about cached_has_bits being unused
343   (void) cached_has_bits;
344 
345   // string retry_token = 1;
346   if (!this->_internal_retry_token().empty()) {
347     total_size += 1 +
348       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
349         this->_internal_retry_token());
350   }
351 
352   // int64 delay_min = 2;
353   if (this->_internal_delay_min() != 0) {
354     total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_delay_min());
355   }
356 
357   // int64 delay_max = 3;
358   if (this->_internal_delay_max() != 0) {
359     total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_delay_max());
360   }
361 
362   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
363     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
364   }
365   int cached_size = ::_pbi::ToCachedSize(total_size);
366   SetCachedSize(cached_size);
367   return total_size;
368 }
369 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)370 void TaskRetry::CheckTypeAndMergeFrom(
371     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
372   MergeFrom(*::_pbi::DownCast<const TaskRetry*>(
373       &from));
374 }
375 
MergeFrom(const TaskRetry & from)376 void TaskRetry::MergeFrom(const TaskRetry& from) {
377   TaskRetry* const _this = this;
378   // @@protoc_insertion_point(class_specific_merge_from_start:fcp.client.engine.TaskRetry)
379   GOOGLE_DCHECK_NE(&from, _this);
380   ::uint32_t cached_has_bits = 0;
381   (void) cached_has_bits;
382 
383   if (!from._internal_retry_token().empty()) {
384     _this->_internal_set_retry_token(from._internal_retry_token());
385   }
386   if (from._internal_delay_min() != 0) {
387     _this->_internal_set_delay_min(from._internal_delay_min());
388   }
389   if (from._internal_delay_max() != 0) {
390     _this->_internal_set_delay_max(from._internal_delay_max());
391   }
392   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
393 }
394 
CopyFrom(const TaskRetry & from)395 void TaskRetry::CopyFrom(const TaskRetry& from) {
396 // @@protoc_insertion_point(class_specific_copy_from_start:fcp.client.engine.TaskRetry)
397   if (&from == this) return;
398   Clear();
399   MergeFrom(from);
400 }
401 
IsInitialized() const402 bool TaskRetry::IsInitialized() const {
403   return true;
404 }
405 
InternalSwap(TaskRetry * other)406 void TaskRetry::InternalSwap(TaskRetry* other) {
407   using std::swap;
408   auto* lhs_arena = GetArenaForAllocation();
409   auto* rhs_arena = other->GetArenaForAllocation();
410   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
411   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
412       &_impl_.retry_token_, lhs_arena,
413       &other->_impl_.retry_token_, rhs_arena
414   );
415   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
416       PROTOBUF_FIELD_OFFSET(TaskRetry, _impl_.delay_max_)
417       + sizeof(TaskRetry::_impl_.delay_max_)  // NOLINT
418       - PROTOBUF_FIELD_OFFSET(TaskRetry, _impl_.delay_min_)>(
419           reinterpret_cast<char*>(&_impl_.delay_min_),
420           reinterpret_cast<char*>(&other->_impl_.delay_min_));
421 }
422 
GetTypeName() const423 std::string TaskRetry::GetTypeName() const {
424   return "fcp.client.engine.TaskRetry";
425 }
426 
427 
428 // @@protoc_insertion_point(namespace_scope)
429 }  // namespace engine
430 }  // namespace client
431 }  // namespace fcp
432 PROTOBUF_NAMESPACE_OPEN
433 template<> PROTOBUF_NOINLINE ::fcp::client::engine::TaskRetry*
CreateMaybeMessage(Arena * arena)434 Arena::CreateMaybeMessage< ::fcp::client::engine::TaskRetry >(Arena* arena) {
435   return Arena::CreateMessageInternal< ::fcp::client::engine::TaskRetry >(arena);
436 }
437 PROTOBUF_NAMESPACE_CLOSE
438 
439 // @@protoc_insertion_point(global_scope)
440 #include <google/protobuf/port_undef.inc>
441