1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: fcp/protos/opstats.proto
3 
4 #include "fcp/protos/opstats.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 opstats {
OperationalStats_Event(::_pbi::ConstantInitialized)24 PROTOBUF_CONSTEXPR OperationalStats_Event::OperationalStats_Event(
25     ::_pbi::ConstantInitialized): _impl_{
26     /*decltype(_impl_.timestamp_)*/nullptr
27   , /*decltype(_impl_.event_type_)*/0
28   , /*decltype(_impl_._cached_size_)*/{}} {}
29 struct OperationalStats_EventDefaultTypeInternal {
OperationalStats_EventDefaultTypeInternalfcp::client::opstats::OperationalStats_EventDefaultTypeInternal30   PROTOBUF_CONSTEXPR OperationalStats_EventDefaultTypeInternal()
31       : _instance(::_pbi::ConstantInitialized{}) {}
~OperationalStats_EventDefaultTypeInternalfcp::client::opstats::OperationalStats_EventDefaultTypeInternal32   ~OperationalStats_EventDefaultTypeInternal() {}
33   union {  // NOLINT(misc-non-private-member-variables-in-classes)
34     OperationalStats_Event _instance;
35   };
36 };
37 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OperationalStats_EventDefaultTypeInternal _OperationalStats_Event_default_instance_;
OperationalStats_DatasetStats(::_pbi::ConstantInitialized)38 PROTOBUF_CONSTEXPR OperationalStats_DatasetStats::OperationalStats_DatasetStats(
39     ::_pbi::ConstantInitialized): _impl_{
40     /*decltype(_impl_.num_examples_read_)*/::int64_t{0}
41   , /*decltype(_impl_.num_bytes_read_)*/::int64_t{0}
42   , /*decltype(_impl_._cached_size_)*/{}} {}
43 struct OperationalStats_DatasetStatsDefaultTypeInternal {
OperationalStats_DatasetStatsDefaultTypeInternalfcp::client::opstats::OperationalStats_DatasetStatsDefaultTypeInternal44   PROTOBUF_CONSTEXPR OperationalStats_DatasetStatsDefaultTypeInternal()
45       : _instance(::_pbi::ConstantInitialized{}) {}
~OperationalStats_DatasetStatsDefaultTypeInternalfcp::client::opstats::OperationalStats_DatasetStatsDefaultTypeInternal46   ~OperationalStats_DatasetStatsDefaultTypeInternal() {}
47   union {  // NOLINT(misc-non-private-member-variables-in-classes)
48     OperationalStats_DatasetStats _instance;
49   };
50 };
51 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OperationalStats_DatasetStatsDefaultTypeInternal _OperationalStats_DatasetStats_default_instance_;
OperationalStats_DatasetStatsEntry_DoNotUse(::_pbi::ConstantInitialized)52 PROTOBUF_CONSTEXPR OperationalStats_DatasetStatsEntry_DoNotUse::OperationalStats_DatasetStatsEntry_DoNotUse(
53     ::_pbi::ConstantInitialized) {}
54 struct OperationalStats_DatasetStatsEntry_DoNotUseDefaultTypeInternal {
OperationalStats_DatasetStatsEntry_DoNotUseDefaultTypeInternalfcp::client::opstats::OperationalStats_DatasetStatsEntry_DoNotUseDefaultTypeInternal55   PROTOBUF_CONSTEXPR OperationalStats_DatasetStatsEntry_DoNotUseDefaultTypeInternal()
56       : _instance(::_pbi::ConstantInitialized{}) {}
~OperationalStats_DatasetStatsEntry_DoNotUseDefaultTypeInternalfcp::client::opstats::OperationalStats_DatasetStatsEntry_DoNotUseDefaultTypeInternal57   ~OperationalStats_DatasetStatsEntry_DoNotUseDefaultTypeInternal() {}
58   union {  // NOLINT(misc-non-private-member-variables-in-classes)
59     OperationalStats_DatasetStatsEntry_DoNotUse _instance;
60   };
61 };
62 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OperationalStats_DatasetStatsEntry_DoNotUseDefaultTypeInternal _OperationalStats_DatasetStatsEntry_DoNotUse_default_instance_;
OperationalStats(::_pbi::ConstantInitialized)63 PROTOBUF_CONSTEXPR OperationalStats::OperationalStats(
64     ::_pbi::ConstantInitialized): _impl_{
65     /*decltype(_impl_.events_)*/{}
66   , /*decltype(_impl_.dataset_stats_)*/{}
67   , /*decltype(_impl_.population_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
68   , /*decltype(_impl_.session_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
69   , /*decltype(_impl_.task_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
70   , /*decltype(_impl_.error_message_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
71   , /*decltype(_impl_.retry_window_)*/nullptr
72   , /*decltype(_impl_.network_duration_)*/nullptr
73   , /*decltype(_impl_.chunking_layer_bytes_downloaded_)*/::int64_t{0}
74   , /*decltype(_impl_.chunking_layer_bytes_uploaded_)*/::int64_t{0}
75   , /*decltype(_impl_._cached_size_)*/{}} {}
76 struct OperationalStatsDefaultTypeInternal {
OperationalStatsDefaultTypeInternalfcp::client::opstats::OperationalStatsDefaultTypeInternal77   PROTOBUF_CONSTEXPR OperationalStatsDefaultTypeInternal()
78       : _instance(::_pbi::ConstantInitialized{}) {}
~OperationalStatsDefaultTypeInternalfcp::client::opstats::OperationalStatsDefaultTypeInternal79   ~OperationalStatsDefaultTypeInternal() {}
80   union {  // NOLINT(misc-non-private-member-variables-in-classes)
81     OperationalStats _instance;
82   };
83 };
84 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OperationalStatsDefaultTypeInternal _OperationalStats_default_instance_;
OpStatsSequence(::_pbi::ConstantInitialized)85 PROTOBUF_CONSTEXPR OpStatsSequence::OpStatsSequence(
86     ::_pbi::ConstantInitialized): _impl_{
87     /*decltype(_impl_.opstats_)*/{}
88   , /*decltype(_impl_.earliest_trustworthy_time_)*/nullptr
89   , /*decltype(_impl_._cached_size_)*/{}} {}
90 struct OpStatsSequenceDefaultTypeInternal {
OpStatsSequenceDefaultTypeInternalfcp::client::opstats::OpStatsSequenceDefaultTypeInternal91   PROTOBUF_CONSTEXPR OpStatsSequenceDefaultTypeInternal()
92       : _instance(::_pbi::ConstantInitialized{}) {}
~OpStatsSequenceDefaultTypeInternalfcp::client::opstats::OpStatsSequenceDefaultTypeInternal93   ~OpStatsSequenceDefaultTypeInternal() {}
94   union {  // NOLINT(misc-non-private-member-variables-in-classes)
95     OpStatsSequence _instance;
96   };
97 };
98 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OpStatsSequenceDefaultTypeInternal _OpStatsSequence_default_instance_;
OpStatsSelectionCriteria(::_pbi::ConstantInitialized)99 PROTOBUF_CONSTEXPR OpStatsSelectionCriteria::OpStatsSelectionCriteria(
100     ::_pbi::ConstantInitialized): _impl_{
101     /*decltype(_impl_.start_time_)*/nullptr
102   , /*decltype(_impl_.end_time_)*/nullptr
103   , /*decltype(_impl_.last_successful_contribution_)*/false
104   , /*decltype(_impl_._cached_size_)*/{}} {}
105 struct OpStatsSelectionCriteriaDefaultTypeInternal {
OpStatsSelectionCriteriaDefaultTypeInternalfcp::client::opstats::OpStatsSelectionCriteriaDefaultTypeInternal106   PROTOBUF_CONSTEXPR OpStatsSelectionCriteriaDefaultTypeInternal()
107       : _instance(::_pbi::ConstantInitialized{}) {}
~OpStatsSelectionCriteriaDefaultTypeInternalfcp::client::opstats::OpStatsSelectionCriteriaDefaultTypeInternal108   ~OpStatsSelectionCriteriaDefaultTypeInternal() {}
109   union {  // NOLINT(misc-non-private-member-variables-in-classes)
110     OpStatsSelectionCriteria _instance;
111   };
112 };
113 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OpStatsSelectionCriteriaDefaultTypeInternal _OpStatsSelectionCriteria_default_instance_;
114 }  // namespace opstats
115 }  // namespace client
116 }  // namespace fcp
117 namespace fcp {
118 namespace client {
119 namespace opstats {
OperationalStats_Event_EventKind_IsValid(int value)120 bool OperationalStats_Event_EventKind_IsValid(int value) {
121   switch (value) {
122     case 0:
123     case 1:
124     case 2:
125     case 3:
126     case 4:
127     case 5:
128     case 6:
129     case 7:
130     case 8:
131     case 9:
132     case 10:
133     case 11:
134     case 12:
135     case 13:
136     case 14:
137     case 15:
138     case 16:
139     case 17:
140     case 18:
141     case 19:
142     case 20:
143     case 21:
144     case 22:
145     case 23:
146     case 24:
147     case 25:
148     case 26:
149     case 27:
150     case 28:
151     case 29:
152     case 30:
153     case 31:
154     case 32:
155     case 33:
156     case 34:
157     case 35:
158     case 36:
159     case 37:
160     case 38:
161     case 39:
162     case 40:
163     case 41:
164     case 42:
165     case 43:
166     case 44:
167     case 45:
168     case 46:
169     case 47:
170     case 48:
171     case 49:
172     case 50:
173     case 51:
174       return true;
175     default:
176       return false;
177   }
178 }
179 
180 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> OperationalStats_Event_EventKind_strings[52] = {};
181 
182 static const char OperationalStats_Event_EventKind_names[] =
183   "EVENT_KIND_CHECKIN_ACCEPTED"
184   "EVENT_KIND_CHECKIN_CLIENT_INTERRUPTED"
185   "EVENT_KIND_CHECKIN_ERROR_INVALID_PAYLOAD"
186   "EVENT_KIND_CHECKIN_ERROR_IO"
187   "EVENT_KIND_CHECKIN_PLAN_URI_RECEIVED"
188   "EVENT_KIND_CHECKIN_REJECTED"
189   "EVENT_KIND_CHECKIN_SERVER_ABORTED"
190   "EVENT_KIND_CHECKIN_STARTED"
191   "EVENT_KIND_CLIENT_INTERRUPTED"
192   "EVENT_KIND_COMPUTATION_CLIENT_INTERRUPTED"
193   "EVENT_KIND_COMPUTATION_ERROR_EXAMPLE_ITERATOR"
194   "EVENT_KIND_COMPUTATION_ERROR_INVALID_ARGUMENT"
195   "EVENT_KIND_COMPUTATION_ERROR_IO"
196   "EVENT_KIND_COMPUTATION_ERROR_TENSORFLOW"
197   "EVENT_KIND_COMPUTATION_FINISHED"
198   "EVENT_KIND_COMPUTATION_STARTED"
199   "EVENT_KIND_ELIGIBILITY_CHECKIN_CLIENT_INTERRUPTED"
200   "EVENT_KIND_ELIGIBILITY_CHECKIN_ERROR_INVALID_PAYLOAD"
201   "EVENT_KIND_ELIGIBILITY_CHECKIN_ERROR_IO"
202   "EVENT_KIND_ELIGIBILITY_CHECKIN_SERVER_ABORTED"
203   "EVENT_KIND_ELIGIBILITY_CHECKIN_STARTED"
204   "EVENT_KIND_ELIGIBILITY_COMPUTATION_CLIENT_INTERRUPTED"
205   "EVENT_KIND_ELIGIBILITY_COMPUTATION_ERROR_EXAMPLE_ITERATOR"
206   "EVENT_KIND_ELIGIBILITY_COMPUTATION_ERROR_INVALID_ARGUMENT"
207   "EVENT_KIND_ELIGIBILITY_COMPUTATION_ERROR_IO"
208   "EVENT_KIND_ELIGIBILITY_COMPUTATION_ERROR_TENSORFLOW"
209   "EVENT_KIND_ELIGIBILITY_COMPUTATION_FINISHED"
210   "EVENT_KIND_ELIGIBILITY_COMPUTATION_STARTED"
211   "EVENT_KIND_ELIGIBILITY_DISABLED"
212   "EVENT_KIND_ELIGIBILITY_ENABLED"
213   "EVENT_KIND_ELIGIBILITY_PLAN_URI_RECEIVED"
214   "EVENT_KIND_ELIGIBILITY_REJECTED"
215   "EVENT_KIND_ERROR_EXAMPLE_SELECTOR"
216   "EVENT_KIND_ERROR_IO"
217   "EVENT_KIND_ERROR_TENSORFLOW"
218   "EVENT_KIND_FAILURE_UPLOAD_CLIENT_INTERRUPTED"
219   "EVENT_KIND_FAILURE_UPLOAD_ERROR_IO"
220   "EVENT_KIND_FAILURE_UPLOAD_FINISHED"
221   "EVENT_KIND_FAILURE_UPLOAD_SERVER_ABORTED"
222   "EVENT_KIND_FAILURE_UPLOAD_STARTED"
223   "EVENT_KIND_INITIALIZATION_ERROR_FATAL"
224   "EVENT_KIND_INITIALIZATION_ERROR_NONFATAL"
225   "EVENT_KIND_RESULT_UPLOAD_CLIENT_INTERRUPTED"
226   "EVENT_KIND_RESULT_UPLOAD_ERROR_IO"
227   "EVENT_KIND_RESULT_UPLOAD_FINISHED"
228   "EVENT_KIND_RESULT_UPLOAD_SERVER_ABORTED"
229   "EVENT_KIND_RESULT_UPLOAD_STARTED"
230   "EVENT_KIND_SERVER_ABORTED"
231   "EVENT_KIND_TRAIN_NOT_STARTED"
232   "EVENT_KIND_UNRECOGNIZED"
233   "EVENT_KIND_UPLOAD_FINISHED"
234   "EVENT_KIND_UPLOAD_STARTED";
235 
236 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry OperationalStats_Event_EventKind_entries[] = {
237   { {OperationalStats_Event_EventKind_names + 0, 27}, 9 },
238   { {OperationalStats_Event_EventKind_names + 27, 37}, 26 },
239   { {OperationalStats_Event_EventKind_names + 64, 40}, 25 },
240   { {OperationalStats_Event_EventKind_names + 104, 27}, 24 },
241   { {OperationalStats_Event_EventKind_names + 131, 36}, 49 },
242   { {OperationalStats_Event_EventKind_names + 167, 27}, 8 },
243   { {OperationalStats_Event_EventKind_names + 194, 33}, 27 },
244   { {OperationalStats_Event_EventKind_names + 227, 26}, 7 },
245   { {OperationalStats_Event_EventKind_names + 253, 29}, 14 },
246   { {OperationalStats_Event_EventKind_names + 282, 41}, 37 },
247   { {OperationalStats_Event_EventKind_names + 323, 45}, 36 },
248   { {OperationalStats_Event_EventKind_names + 368, 45}, 35 },
249   { {OperationalStats_Event_EventKind_names + 413, 31}, 34 },
250   { {OperationalStats_Event_EventKind_names + 444, 39}, 33 },
251   { {OperationalStats_Event_EventKind_names + 483, 31}, 11 },
252   { {OperationalStats_Event_EventKind_names + 514, 30}, 10 },
253   { {OperationalStats_Event_EventKind_names + 544, 49}, 22 },
254   { {OperationalStats_Event_EventKind_names + 593, 52}, 21 },
255   { {OperationalStats_Event_EventKind_names + 645, 39}, 20 },
256   { {OperationalStats_Event_EventKind_names + 684, 45}, 23 },
257   { {OperationalStats_Event_EventKind_names + 729, 38}, 1 },
258   { {OperationalStats_Event_EventKind_names + 767, 53}, 32 },
259   { {OperationalStats_Event_EventKind_names + 820, 57}, 31 },
260   { {OperationalStats_Event_EventKind_names + 877, 57}, 30 },
261   { {OperationalStats_Event_EventKind_names + 934, 43}, 29 },
262   { {OperationalStats_Event_EventKind_names + 977, 51}, 28 },
263   { {OperationalStats_Event_EventKind_names + 1028, 43}, 6 },
264   { {OperationalStats_Event_EventKind_names + 1071, 42}, 5 },
265   { {OperationalStats_Event_EventKind_names + 1113, 31}, 3 },
266   { {OperationalStats_Event_EventKind_names + 1144, 30}, 4 },
267   { {OperationalStats_Event_EventKind_names + 1174, 40}, 48 },
268   { {OperationalStats_Event_EventKind_names + 1214, 31}, 2 },
269   { {OperationalStats_Event_EventKind_names + 1245, 33}, 18 },
270   { {OperationalStats_Event_EventKind_names + 1278, 19}, 16 },
271   { {OperationalStats_Event_EventKind_names + 1297, 27}, 17 },
272   { {OperationalStats_Event_EventKind_names + 1324, 44}, 45 },
273   { {OperationalStats_Event_EventKind_names + 1368, 34}, 44 },
274   { {OperationalStats_Event_EventKind_names + 1402, 34}, 47 },
275   { {OperationalStats_Event_EventKind_names + 1436, 40}, 46 },
276   { {OperationalStats_Event_EventKind_names + 1476, 33}, 43 },
277   { {OperationalStats_Event_EventKind_names + 1509, 37}, 51 },
278   { {OperationalStats_Event_EventKind_names + 1546, 40}, 50 },
279   { {OperationalStats_Event_EventKind_names + 1586, 43}, 40 },
280   { {OperationalStats_Event_EventKind_names + 1629, 33}, 39 },
281   { {OperationalStats_Event_EventKind_names + 1662, 33}, 42 },
282   { {OperationalStats_Event_EventKind_names + 1695, 39}, 41 },
283   { {OperationalStats_Event_EventKind_names + 1734, 32}, 38 },
284   { {OperationalStats_Event_EventKind_names + 1766, 25}, 15 },
285   { {OperationalStats_Event_EventKind_names + 1791, 28}, 19 },
286   { {OperationalStats_Event_EventKind_names + 1819, 23}, 0 },
287   { {OperationalStats_Event_EventKind_names + 1842, 26}, 13 },
288   { {OperationalStats_Event_EventKind_names + 1868, 25}, 12 },
289 };
290 
291 static const int OperationalStats_Event_EventKind_entries_by_number[] = {
292   49, // 0 -> EVENT_KIND_UNRECOGNIZED
293   20, // 1 -> EVENT_KIND_ELIGIBILITY_CHECKIN_STARTED
294   31, // 2 -> EVENT_KIND_ELIGIBILITY_REJECTED
295   28, // 3 -> EVENT_KIND_ELIGIBILITY_DISABLED
296   29, // 4 -> EVENT_KIND_ELIGIBILITY_ENABLED
297   27, // 5 -> EVENT_KIND_ELIGIBILITY_COMPUTATION_STARTED
298   26, // 6 -> EVENT_KIND_ELIGIBILITY_COMPUTATION_FINISHED
299   7, // 7 -> EVENT_KIND_CHECKIN_STARTED
300   5, // 8 -> EVENT_KIND_CHECKIN_REJECTED
301   0, // 9 -> EVENT_KIND_CHECKIN_ACCEPTED
302   15, // 10 -> EVENT_KIND_COMPUTATION_STARTED
303   14, // 11 -> EVENT_KIND_COMPUTATION_FINISHED
304   51, // 12 -> EVENT_KIND_UPLOAD_STARTED
305   50, // 13 -> EVENT_KIND_UPLOAD_FINISHED
306   8, // 14 -> EVENT_KIND_CLIENT_INTERRUPTED
307   47, // 15 -> EVENT_KIND_SERVER_ABORTED
308   33, // 16 -> EVENT_KIND_ERROR_IO
309   34, // 17 -> EVENT_KIND_ERROR_TENSORFLOW
310   32, // 18 -> EVENT_KIND_ERROR_EXAMPLE_SELECTOR
311   48, // 19 -> EVENT_KIND_TRAIN_NOT_STARTED
312   18, // 20 -> EVENT_KIND_ELIGIBILITY_CHECKIN_ERROR_IO
313   17, // 21 -> EVENT_KIND_ELIGIBILITY_CHECKIN_ERROR_INVALID_PAYLOAD
314   16, // 22 -> EVENT_KIND_ELIGIBILITY_CHECKIN_CLIENT_INTERRUPTED
315   19, // 23 -> EVENT_KIND_ELIGIBILITY_CHECKIN_SERVER_ABORTED
316   3, // 24 -> EVENT_KIND_CHECKIN_ERROR_IO
317   2, // 25 -> EVENT_KIND_CHECKIN_ERROR_INVALID_PAYLOAD
318   1, // 26 -> EVENT_KIND_CHECKIN_CLIENT_INTERRUPTED
319   6, // 27 -> EVENT_KIND_CHECKIN_SERVER_ABORTED
320   25, // 28 -> EVENT_KIND_ELIGIBILITY_COMPUTATION_ERROR_TENSORFLOW
321   24, // 29 -> EVENT_KIND_ELIGIBILITY_COMPUTATION_ERROR_IO
322   23, // 30 -> EVENT_KIND_ELIGIBILITY_COMPUTATION_ERROR_INVALID_ARGUMENT
323   22, // 31 -> EVENT_KIND_ELIGIBILITY_COMPUTATION_ERROR_EXAMPLE_ITERATOR
324   21, // 32 -> EVENT_KIND_ELIGIBILITY_COMPUTATION_CLIENT_INTERRUPTED
325   13, // 33 -> EVENT_KIND_COMPUTATION_ERROR_TENSORFLOW
326   12, // 34 -> EVENT_KIND_COMPUTATION_ERROR_IO
327   11, // 35 -> EVENT_KIND_COMPUTATION_ERROR_INVALID_ARGUMENT
328   10, // 36 -> EVENT_KIND_COMPUTATION_ERROR_EXAMPLE_ITERATOR
329   9, // 37 -> EVENT_KIND_COMPUTATION_CLIENT_INTERRUPTED
330   46, // 38 -> EVENT_KIND_RESULT_UPLOAD_STARTED
331   43, // 39 -> EVENT_KIND_RESULT_UPLOAD_ERROR_IO
332   42, // 40 -> EVENT_KIND_RESULT_UPLOAD_CLIENT_INTERRUPTED
333   45, // 41 -> EVENT_KIND_RESULT_UPLOAD_SERVER_ABORTED
334   44, // 42 -> EVENT_KIND_RESULT_UPLOAD_FINISHED
335   39, // 43 -> EVENT_KIND_FAILURE_UPLOAD_STARTED
336   36, // 44 -> EVENT_KIND_FAILURE_UPLOAD_ERROR_IO
337   35, // 45 -> EVENT_KIND_FAILURE_UPLOAD_CLIENT_INTERRUPTED
338   38, // 46 -> EVENT_KIND_FAILURE_UPLOAD_SERVER_ABORTED
339   37, // 47 -> EVENT_KIND_FAILURE_UPLOAD_FINISHED
340   30, // 48 -> EVENT_KIND_ELIGIBILITY_PLAN_URI_RECEIVED
341   4, // 49 -> EVENT_KIND_CHECKIN_PLAN_URI_RECEIVED
342   41, // 50 -> EVENT_KIND_INITIALIZATION_ERROR_NONFATAL
343   40, // 51 -> EVENT_KIND_INITIALIZATION_ERROR_FATAL
344 };
345 
OperationalStats_Event_EventKind_Name(OperationalStats_Event_EventKind value)346 const std::string& OperationalStats_Event_EventKind_Name(
347     OperationalStats_Event_EventKind value) {
348   static const bool dummy =
349       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
350           OperationalStats_Event_EventKind_entries,
351           OperationalStats_Event_EventKind_entries_by_number,
352           52, OperationalStats_Event_EventKind_strings);
353   (void) dummy;
354   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
355       OperationalStats_Event_EventKind_entries,
356       OperationalStats_Event_EventKind_entries_by_number,
357       52, value);
358   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
359                      OperationalStats_Event_EventKind_strings[idx].get();
360 }
OperationalStats_Event_EventKind_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,OperationalStats_Event_EventKind * value)361 bool OperationalStats_Event_EventKind_Parse(
362     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OperationalStats_Event_EventKind* value) {
363   int int_value;
364   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
365       OperationalStats_Event_EventKind_entries, 52, name, &int_value);
366   if (success) {
367     *value = static_cast<OperationalStats_Event_EventKind>(int_value);
368   }
369   return success;
370 }
371 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
372 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_UNRECOGNIZED;
373 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_ELIGIBILITY_CHECKIN_STARTED;
374 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_ELIGIBILITY_REJECTED;
375 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_ELIGIBILITY_DISABLED;
376 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_ELIGIBILITY_PLAN_URI_RECEIVED;
377 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_ELIGIBILITY_ENABLED;
378 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_ELIGIBILITY_COMPUTATION_STARTED;
379 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_ELIGIBILITY_COMPUTATION_FINISHED;
380 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_CHECKIN_STARTED;
381 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_CHECKIN_REJECTED;
382 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_CHECKIN_PLAN_URI_RECEIVED;
383 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_CHECKIN_ACCEPTED;
384 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_COMPUTATION_STARTED;
385 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_COMPUTATION_FINISHED;
386 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_UPLOAD_STARTED;
387 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_UPLOAD_FINISHED;
388 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_CLIENT_INTERRUPTED;
389 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_SERVER_ABORTED;
390 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_ERROR_IO;
391 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_ERROR_TENSORFLOW;
392 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_ERROR_EXAMPLE_SELECTOR;
393 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_TRAIN_NOT_STARTED;
394 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_ELIGIBILITY_CHECKIN_ERROR_IO;
395 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_ELIGIBILITY_CHECKIN_ERROR_INVALID_PAYLOAD;
396 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_ELIGIBILITY_CHECKIN_CLIENT_INTERRUPTED;
397 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_ELIGIBILITY_CHECKIN_SERVER_ABORTED;
398 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_CHECKIN_ERROR_IO;
399 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_CHECKIN_ERROR_INVALID_PAYLOAD;
400 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_CHECKIN_CLIENT_INTERRUPTED;
401 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_CHECKIN_SERVER_ABORTED;
402 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_ELIGIBILITY_COMPUTATION_ERROR_TENSORFLOW;
403 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_ELIGIBILITY_COMPUTATION_ERROR_IO;
404 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_ELIGIBILITY_COMPUTATION_ERROR_INVALID_ARGUMENT;
405 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_ELIGIBILITY_COMPUTATION_ERROR_EXAMPLE_ITERATOR;
406 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_ELIGIBILITY_COMPUTATION_CLIENT_INTERRUPTED;
407 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_COMPUTATION_ERROR_TENSORFLOW;
408 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_COMPUTATION_ERROR_IO;
409 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_COMPUTATION_ERROR_INVALID_ARGUMENT;
410 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_COMPUTATION_ERROR_EXAMPLE_ITERATOR;
411 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_COMPUTATION_CLIENT_INTERRUPTED;
412 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_RESULT_UPLOAD_STARTED;
413 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_RESULT_UPLOAD_ERROR_IO;
414 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_RESULT_UPLOAD_CLIENT_INTERRUPTED;
415 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_RESULT_UPLOAD_SERVER_ABORTED;
416 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_RESULT_UPLOAD_FINISHED;
417 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_FAILURE_UPLOAD_STARTED;
418 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_FAILURE_UPLOAD_ERROR_IO;
419 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_FAILURE_UPLOAD_CLIENT_INTERRUPTED;
420 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_FAILURE_UPLOAD_SERVER_ABORTED;
421 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_FAILURE_UPLOAD_FINISHED;
422 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_INITIALIZATION_ERROR_NONFATAL;
423 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EVENT_KIND_INITIALIZATION_ERROR_FATAL;
424 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EventKind_MIN;
425 constexpr OperationalStats_Event_EventKind OperationalStats_Event::EventKind_MAX;
426 constexpr int OperationalStats_Event::EventKind_ARRAYSIZE;
427 #endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
428 
429 // ===================================================================
430 
431 class OperationalStats_Event::_Internal {
432  public:
433   static const ::PROTOBUF_NAMESPACE_ID::Timestamp& timestamp(const OperationalStats_Event* msg);
434 };
435 
436 const ::PROTOBUF_NAMESPACE_ID::Timestamp&
timestamp(const OperationalStats_Event * msg)437 OperationalStats_Event::_Internal::timestamp(const OperationalStats_Event* msg) {
438   return *msg->_impl_.timestamp_;
439 }
clear_timestamp()440 void OperationalStats_Event::clear_timestamp() {
441   if (GetArenaForAllocation() == nullptr && _impl_.timestamp_ != nullptr) {
442     delete _impl_.timestamp_;
443   }
444   _impl_.timestamp_ = nullptr;
445 }
OperationalStats_Event(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)446 OperationalStats_Event::OperationalStats_Event(::PROTOBUF_NAMESPACE_ID::Arena* arena,
447                          bool is_message_owned)
448   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
449   SharedCtor(arena, is_message_owned);
450   // @@protoc_insertion_point(arena_constructor:fcp.client.opstats.OperationalStats.Event)
451 }
OperationalStats_Event(const OperationalStats_Event & from)452 OperationalStats_Event::OperationalStats_Event(const OperationalStats_Event& from)
453   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
454   OperationalStats_Event* const _this = this; (void)_this;
455   new (&_impl_) Impl_{
456       decltype(_impl_.timestamp_){nullptr}
457     , decltype(_impl_.event_type_){}
458     , /*decltype(_impl_._cached_size_)*/{}};
459 
460   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
461   if (from._internal_has_timestamp()) {
462     _this->_impl_.timestamp_ = new ::PROTOBUF_NAMESPACE_ID::Timestamp(*from._impl_.timestamp_);
463   }
464   _this->_impl_.event_type_ = from._impl_.event_type_;
465   // @@protoc_insertion_point(copy_constructor:fcp.client.opstats.OperationalStats.Event)
466 }
467 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)468 inline void OperationalStats_Event::SharedCtor(
469     ::_pb::Arena* arena, bool is_message_owned) {
470   (void)arena;
471   (void)is_message_owned;
472   new (&_impl_) Impl_{
473       decltype(_impl_.timestamp_){nullptr}
474     , decltype(_impl_.event_type_){0}
475     , /*decltype(_impl_._cached_size_)*/{}
476   };
477 }
478 
~OperationalStats_Event()479 OperationalStats_Event::~OperationalStats_Event() {
480   // @@protoc_insertion_point(destructor:fcp.client.opstats.OperationalStats.Event)
481   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
482   (void)arena;
483     return;
484   }
485   SharedDtor();
486 }
487 
SharedDtor()488 inline void OperationalStats_Event::SharedDtor() {
489   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
490   if (this != internal_default_instance()) delete _impl_.timestamp_;
491 }
492 
SetCachedSize(int size) const493 void OperationalStats_Event::SetCachedSize(int size) const {
494   _impl_._cached_size_.Set(size);
495 }
496 
Clear()497 void OperationalStats_Event::Clear() {
498 // @@protoc_insertion_point(message_clear_start:fcp.client.opstats.OperationalStats.Event)
499   ::uint32_t cached_has_bits = 0;
500   // Prevent compiler warnings about cached_has_bits being unused
501   (void) cached_has_bits;
502 
503   if (GetArenaForAllocation() == nullptr && _impl_.timestamp_ != nullptr) {
504     delete _impl_.timestamp_;
505   }
506   _impl_.timestamp_ = nullptr;
507   _impl_.event_type_ = 0;
508   _internal_metadata_.Clear<std::string>();
509 }
510 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)511 const char* OperationalStats_Event::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
512 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
513   while (!ctx->Done(&ptr)) {
514     ::uint32_t tag;
515     ptr = ::_pbi::ReadTag(ptr, &tag);
516     switch (tag >> 3) {
517       // .fcp.client.opstats.OperationalStats.Event.EventKind event_type = 1;
518       case 1:
519         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
520           ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
521           CHK_(ptr);
522           _internal_set_event_type(static_cast<::fcp::client::opstats::OperationalStats_Event_EventKind>(val));
523         } else {
524           goto handle_unusual;
525         }
526         continue;
527       // .google.protobuf.Timestamp timestamp = 2;
528       case 2:
529         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
530           ptr = ctx->ParseMessage(_internal_mutable_timestamp(), ptr);
531           CHK_(ptr);
532         } else {
533           goto handle_unusual;
534         }
535         continue;
536       default:
537         goto handle_unusual;
538     }  // switch
539   handle_unusual:
540     if ((tag == 0) || ((tag & 7) == 4)) {
541       CHK_(ptr);
542       ctx->SetLastTag(tag);
543       goto message_done;
544     }
545     ptr = UnknownFieldParse(
546         tag,
547         _internal_metadata_.mutable_unknown_fields<std::string>(),
548         ptr, ctx);
549     CHK_(ptr != nullptr);
550   }  // while
551 message_done:
552   return ptr;
553 failure:
554   ptr = nullptr;
555   goto message_done;
556 #undef CHK_
557 }
558 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const559 ::uint8_t* OperationalStats_Event::_InternalSerialize(
560     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
561   // @@protoc_insertion_point(serialize_to_array_start:fcp.client.opstats.OperationalStats.Event)
562   ::uint32_t cached_has_bits = 0;
563   (void) cached_has_bits;
564 
565   // .fcp.client.opstats.OperationalStats.Event.EventKind event_type = 1;
566   if (this->_internal_event_type() != 0) {
567     target = stream->EnsureSpace(target);
568     target = ::_pbi::WireFormatLite::WriteEnumToArray(
569       1, this->_internal_event_type(), target);
570   }
571 
572   // .google.protobuf.Timestamp timestamp = 2;
573   if (this->_internal_has_timestamp()) {
574     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
575       InternalWriteMessage(2, _Internal::timestamp(this),
576         _Internal::timestamp(this).GetCachedSize(), target, stream);
577   }
578 
579   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
580     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
581         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
582   }
583   // @@protoc_insertion_point(serialize_to_array_end:fcp.client.opstats.OperationalStats.Event)
584   return target;
585 }
586 
ByteSizeLong() const587 size_t OperationalStats_Event::ByteSizeLong() const {
588 // @@protoc_insertion_point(message_byte_size_start:fcp.client.opstats.OperationalStats.Event)
589   size_t total_size = 0;
590 
591   ::uint32_t cached_has_bits = 0;
592   // Prevent compiler warnings about cached_has_bits being unused
593   (void) cached_has_bits;
594 
595   // .google.protobuf.Timestamp timestamp = 2;
596   if (this->_internal_has_timestamp()) {
597     total_size += 1 +
598       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
599         *_impl_.timestamp_);
600   }
601 
602   // .fcp.client.opstats.OperationalStats.Event.EventKind event_type = 1;
603   if (this->_internal_event_type() != 0) {
604     total_size += 1 +
605       ::_pbi::WireFormatLite::EnumSize(this->_internal_event_type());
606   }
607 
608   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
609     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
610   }
611   int cached_size = ::_pbi::ToCachedSize(total_size);
612   SetCachedSize(cached_size);
613   return total_size;
614 }
615 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)616 void OperationalStats_Event::CheckTypeAndMergeFrom(
617     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
618   MergeFrom(*::_pbi::DownCast<const OperationalStats_Event*>(
619       &from));
620 }
621 
MergeFrom(const OperationalStats_Event & from)622 void OperationalStats_Event::MergeFrom(const OperationalStats_Event& from) {
623   OperationalStats_Event* const _this = this;
624   // @@protoc_insertion_point(class_specific_merge_from_start:fcp.client.opstats.OperationalStats.Event)
625   GOOGLE_DCHECK_NE(&from, _this);
626   ::uint32_t cached_has_bits = 0;
627   (void) cached_has_bits;
628 
629   if (from._internal_has_timestamp()) {
630     _this->_internal_mutable_timestamp()->::PROTOBUF_NAMESPACE_ID::Timestamp::MergeFrom(
631         from._internal_timestamp());
632   }
633   if (from._internal_event_type() != 0) {
634     _this->_internal_set_event_type(from._internal_event_type());
635   }
636   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
637 }
638 
CopyFrom(const OperationalStats_Event & from)639 void OperationalStats_Event::CopyFrom(const OperationalStats_Event& from) {
640 // @@protoc_insertion_point(class_specific_copy_from_start:fcp.client.opstats.OperationalStats.Event)
641   if (&from == this) return;
642   Clear();
643   MergeFrom(from);
644 }
645 
IsInitialized() const646 bool OperationalStats_Event::IsInitialized() const {
647   return true;
648 }
649 
InternalSwap(OperationalStats_Event * other)650 void OperationalStats_Event::InternalSwap(OperationalStats_Event* other) {
651   using std::swap;
652   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
653   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
654       PROTOBUF_FIELD_OFFSET(OperationalStats_Event, _impl_.event_type_)
655       + sizeof(OperationalStats_Event::_impl_.event_type_)  // NOLINT
656       - PROTOBUF_FIELD_OFFSET(OperationalStats_Event, _impl_.timestamp_)>(
657           reinterpret_cast<char*>(&_impl_.timestamp_),
658           reinterpret_cast<char*>(&other->_impl_.timestamp_));
659 }
660 
GetTypeName() const661 std::string OperationalStats_Event::GetTypeName() const {
662   return "fcp.client.opstats.OperationalStats.Event";
663 }
664 
665 
666 // ===================================================================
667 
668 class OperationalStats_DatasetStats::_Internal {
669  public:
670 };
671 
OperationalStats_DatasetStats(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)672 OperationalStats_DatasetStats::OperationalStats_DatasetStats(::PROTOBUF_NAMESPACE_ID::Arena* arena,
673                          bool is_message_owned)
674   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
675   SharedCtor(arena, is_message_owned);
676   // @@protoc_insertion_point(arena_constructor:fcp.client.opstats.OperationalStats.DatasetStats)
677 }
OperationalStats_DatasetStats(const OperationalStats_DatasetStats & from)678 OperationalStats_DatasetStats::OperationalStats_DatasetStats(const OperationalStats_DatasetStats& from)
679   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
680   OperationalStats_DatasetStats* const _this = this; (void)_this;
681   new (&_impl_) Impl_{
682       decltype(_impl_.num_examples_read_){}
683     , decltype(_impl_.num_bytes_read_){}
684     , /*decltype(_impl_._cached_size_)*/{}};
685 
686   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
687   ::memcpy(&_impl_.num_examples_read_, &from._impl_.num_examples_read_,
688     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.num_bytes_read_) -
689     reinterpret_cast<char*>(&_impl_.num_examples_read_)) + sizeof(_impl_.num_bytes_read_));
690   // @@protoc_insertion_point(copy_constructor:fcp.client.opstats.OperationalStats.DatasetStats)
691 }
692 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)693 inline void OperationalStats_DatasetStats::SharedCtor(
694     ::_pb::Arena* arena, bool is_message_owned) {
695   (void)arena;
696   (void)is_message_owned;
697   new (&_impl_) Impl_{
698       decltype(_impl_.num_examples_read_){::int64_t{0}}
699     , decltype(_impl_.num_bytes_read_){::int64_t{0}}
700     , /*decltype(_impl_._cached_size_)*/{}
701   };
702 }
703 
~OperationalStats_DatasetStats()704 OperationalStats_DatasetStats::~OperationalStats_DatasetStats() {
705   // @@protoc_insertion_point(destructor:fcp.client.opstats.OperationalStats.DatasetStats)
706   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
707   (void)arena;
708     return;
709   }
710   SharedDtor();
711 }
712 
SharedDtor()713 inline void OperationalStats_DatasetStats::SharedDtor() {
714   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
715 }
716 
SetCachedSize(int size) const717 void OperationalStats_DatasetStats::SetCachedSize(int size) const {
718   _impl_._cached_size_.Set(size);
719 }
720 
Clear()721 void OperationalStats_DatasetStats::Clear() {
722 // @@protoc_insertion_point(message_clear_start:fcp.client.opstats.OperationalStats.DatasetStats)
723   ::uint32_t cached_has_bits = 0;
724   // Prevent compiler warnings about cached_has_bits being unused
725   (void) cached_has_bits;
726 
727   ::memset(&_impl_.num_examples_read_, 0, static_cast<size_t>(
728       reinterpret_cast<char*>(&_impl_.num_bytes_read_) -
729       reinterpret_cast<char*>(&_impl_.num_examples_read_)) + sizeof(_impl_.num_bytes_read_));
730   _internal_metadata_.Clear<std::string>();
731 }
732 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)733 const char* OperationalStats_DatasetStats::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
734 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
735   while (!ctx->Done(&ptr)) {
736     ::uint32_t tag;
737     ptr = ::_pbi::ReadTag(ptr, &tag);
738     switch (tag >> 3) {
739       // int64 num_examples_read = 1;
740       case 1:
741         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
742           _impl_.num_examples_read_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
743           CHK_(ptr);
744         } else {
745           goto handle_unusual;
746         }
747         continue;
748       // int64 num_bytes_read = 2;
749       case 2:
750         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
751           _impl_.num_bytes_read_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
752           CHK_(ptr);
753         } else {
754           goto handle_unusual;
755         }
756         continue;
757       default:
758         goto handle_unusual;
759     }  // switch
760   handle_unusual:
761     if ((tag == 0) || ((tag & 7) == 4)) {
762       CHK_(ptr);
763       ctx->SetLastTag(tag);
764       goto message_done;
765     }
766     ptr = UnknownFieldParse(
767         tag,
768         _internal_metadata_.mutable_unknown_fields<std::string>(),
769         ptr, ctx);
770     CHK_(ptr != nullptr);
771   }  // while
772 message_done:
773   return ptr;
774 failure:
775   ptr = nullptr;
776   goto message_done;
777 #undef CHK_
778 }
779 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const780 ::uint8_t* OperationalStats_DatasetStats::_InternalSerialize(
781     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
782   // @@protoc_insertion_point(serialize_to_array_start:fcp.client.opstats.OperationalStats.DatasetStats)
783   ::uint32_t cached_has_bits = 0;
784   (void) cached_has_bits;
785 
786   // int64 num_examples_read = 1;
787   if (this->_internal_num_examples_read() != 0) {
788     target = stream->EnsureSpace(target);
789     target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_num_examples_read(), target);
790   }
791 
792   // int64 num_bytes_read = 2;
793   if (this->_internal_num_bytes_read() != 0) {
794     target = stream->EnsureSpace(target);
795     target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_num_bytes_read(), target);
796   }
797 
798   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
799     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
800         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
801   }
802   // @@protoc_insertion_point(serialize_to_array_end:fcp.client.opstats.OperationalStats.DatasetStats)
803   return target;
804 }
805 
ByteSizeLong() const806 size_t OperationalStats_DatasetStats::ByteSizeLong() const {
807 // @@protoc_insertion_point(message_byte_size_start:fcp.client.opstats.OperationalStats.DatasetStats)
808   size_t total_size = 0;
809 
810   ::uint32_t cached_has_bits = 0;
811   // Prevent compiler warnings about cached_has_bits being unused
812   (void) cached_has_bits;
813 
814   // int64 num_examples_read = 1;
815   if (this->_internal_num_examples_read() != 0) {
816     total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_num_examples_read());
817   }
818 
819   // int64 num_bytes_read = 2;
820   if (this->_internal_num_bytes_read() != 0) {
821     total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_num_bytes_read());
822   }
823 
824   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
825     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
826   }
827   int cached_size = ::_pbi::ToCachedSize(total_size);
828   SetCachedSize(cached_size);
829   return total_size;
830 }
831 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)832 void OperationalStats_DatasetStats::CheckTypeAndMergeFrom(
833     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
834   MergeFrom(*::_pbi::DownCast<const OperationalStats_DatasetStats*>(
835       &from));
836 }
837 
MergeFrom(const OperationalStats_DatasetStats & from)838 void OperationalStats_DatasetStats::MergeFrom(const OperationalStats_DatasetStats& from) {
839   OperationalStats_DatasetStats* const _this = this;
840   // @@protoc_insertion_point(class_specific_merge_from_start:fcp.client.opstats.OperationalStats.DatasetStats)
841   GOOGLE_DCHECK_NE(&from, _this);
842   ::uint32_t cached_has_bits = 0;
843   (void) cached_has_bits;
844 
845   if (from._internal_num_examples_read() != 0) {
846     _this->_internal_set_num_examples_read(from._internal_num_examples_read());
847   }
848   if (from._internal_num_bytes_read() != 0) {
849     _this->_internal_set_num_bytes_read(from._internal_num_bytes_read());
850   }
851   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
852 }
853 
CopyFrom(const OperationalStats_DatasetStats & from)854 void OperationalStats_DatasetStats::CopyFrom(const OperationalStats_DatasetStats& from) {
855 // @@protoc_insertion_point(class_specific_copy_from_start:fcp.client.opstats.OperationalStats.DatasetStats)
856   if (&from == this) return;
857   Clear();
858   MergeFrom(from);
859 }
860 
IsInitialized() const861 bool OperationalStats_DatasetStats::IsInitialized() const {
862   return true;
863 }
864 
InternalSwap(OperationalStats_DatasetStats * other)865 void OperationalStats_DatasetStats::InternalSwap(OperationalStats_DatasetStats* other) {
866   using std::swap;
867   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
868   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
869       PROTOBUF_FIELD_OFFSET(OperationalStats_DatasetStats, _impl_.num_bytes_read_)
870       + sizeof(OperationalStats_DatasetStats::_impl_.num_bytes_read_)  // NOLINT
871       - PROTOBUF_FIELD_OFFSET(OperationalStats_DatasetStats, _impl_.num_examples_read_)>(
872           reinterpret_cast<char*>(&_impl_.num_examples_read_),
873           reinterpret_cast<char*>(&other->_impl_.num_examples_read_));
874 }
875 
GetTypeName() const876 std::string OperationalStats_DatasetStats::GetTypeName() const {
877   return "fcp.client.opstats.OperationalStats.DatasetStats";
878 }
879 
880 
881 // ===================================================================
882 
OperationalStats_DatasetStatsEntry_DoNotUse()883 OperationalStats_DatasetStatsEntry_DoNotUse::OperationalStats_DatasetStatsEntry_DoNotUse() {}
OperationalStats_DatasetStatsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena * arena)884 OperationalStats_DatasetStatsEntry_DoNotUse::OperationalStats_DatasetStatsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
885     : SuperType(arena) {}
MergeFrom(const OperationalStats_DatasetStatsEntry_DoNotUse & other)886 void OperationalStats_DatasetStatsEntry_DoNotUse::MergeFrom(const OperationalStats_DatasetStatsEntry_DoNotUse& other) {
887   MergeFromInternal(other);
888 }
889 
890 // ===================================================================
891 
892 class OperationalStats::_Internal {
893  public:
894   static const ::google::internal::federatedml::v2::RetryWindow& retry_window(const OperationalStats* msg);
895   static const ::PROTOBUF_NAMESPACE_ID::Duration& network_duration(const OperationalStats* msg);
896 };
897 
898 const ::google::internal::federatedml::v2::RetryWindow&
retry_window(const OperationalStats * msg)899 OperationalStats::_Internal::retry_window(const OperationalStats* msg) {
900   return *msg->_impl_.retry_window_;
901 }
902 const ::PROTOBUF_NAMESPACE_ID::Duration&
network_duration(const OperationalStats * msg)903 OperationalStats::_Internal::network_duration(const OperationalStats* msg) {
904   return *msg->_impl_.network_duration_;
905 }
clear_retry_window()906 void OperationalStats::clear_retry_window() {
907   if (GetArenaForAllocation() == nullptr && _impl_.retry_window_ != nullptr) {
908     delete _impl_.retry_window_;
909   }
910   _impl_.retry_window_ = nullptr;
911 }
clear_network_duration()912 void OperationalStats::clear_network_duration() {
913   if (GetArenaForAllocation() == nullptr && _impl_.network_duration_ != nullptr) {
914     delete _impl_.network_duration_;
915   }
916   _impl_.network_duration_ = nullptr;
917 }
OperationalStats(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)918 OperationalStats::OperationalStats(::PROTOBUF_NAMESPACE_ID::Arena* arena,
919                          bool is_message_owned)
920   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
921   SharedCtor(arena, is_message_owned);
922   // @@protoc_insertion_point(arena_constructor:fcp.client.opstats.OperationalStats)
923 }
OperationalStats(const OperationalStats & from)924 OperationalStats::OperationalStats(const OperationalStats& from)
925   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
926   OperationalStats* const _this = this; (void)_this;
927   new (&_impl_) Impl_{
928       decltype(_impl_.events_){from._impl_.events_}
929     , /*decltype(_impl_.dataset_stats_)*/{}
930     , decltype(_impl_.population_name_){}
931     , decltype(_impl_.session_name_){}
932     , decltype(_impl_.task_name_){}
933     , decltype(_impl_.error_message_){}
934     , decltype(_impl_.retry_window_){nullptr}
935     , decltype(_impl_.network_duration_){nullptr}
936     , decltype(_impl_.chunking_layer_bytes_downloaded_){}
937     , decltype(_impl_.chunking_layer_bytes_uploaded_){}
938     , /*decltype(_impl_._cached_size_)*/{}};
939 
940   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
941   _this->_impl_.dataset_stats_.MergeFrom(from._impl_.dataset_stats_);
942   _impl_.population_name_.InitDefault();
943   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
944     _impl_.population_name_.Set("", GetArenaForAllocation());
945   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
946   if (!from._internal_population_name().empty()) {
947     _this->_impl_.population_name_.Set(from._internal_population_name(),
948       _this->GetArenaForAllocation());
949   }
950   _impl_.session_name_.InitDefault();
951   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
952     _impl_.session_name_.Set("", GetArenaForAllocation());
953   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
954   if (!from._internal_session_name().empty()) {
955     _this->_impl_.session_name_.Set(from._internal_session_name(),
956       _this->GetArenaForAllocation());
957   }
958   _impl_.task_name_.InitDefault();
959   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
960     _impl_.task_name_.Set("", GetArenaForAllocation());
961   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
962   if (!from._internal_task_name().empty()) {
963     _this->_impl_.task_name_.Set(from._internal_task_name(),
964       _this->GetArenaForAllocation());
965   }
966   _impl_.error_message_.InitDefault();
967   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
968     _impl_.error_message_.Set("", GetArenaForAllocation());
969   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
970   if (!from._internal_error_message().empty()) {
971     _this->_impl_.error_message_.Set(from._internal_error_message(),
972       _this->GetArenaForAllocation());
973   }
974   if (from._internal_has_retry_window()) {
975     _this->_impl_.retry_window_ = new ::google::internal::federatedml::v2::RetryWindow(*from._impl_.retry_window_);
976   }
977   if (from._internal_has_network_duration()) {
978     _this->_impl_.network_duration_ = new ::PROTOBUF_NAMESPACE_ID::Duration(*from._impl_.network_duration_);
979   }
980   ::memcpy(&_impl_.chunking_layer_bytes_downloaded_, &from._impl_.chunking_layer_bytes_downloaded_,
981     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.chunking_layer_bytes_uploaded_) -
982     reinterpret_cast<char*>(&_impl_.chunking_layer_bytes_downloaded_)) + sizeof(_impl_.chunking_layer_bytes_uploaded_));
983   // @@protoc_insertion_point(copy_constructor:fcp.client.opstats.OperationalStats)
984 }
985 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)986 inline void OperationalStats::SharedCtor(
987     ::_pb::Arena* arena, bool is_message_owned) {
988   (void)arena;
989   (void)is_message_owned;
990   new (&_impl_) Impl_{
991       decltype(_impl_.events_){arena}
992     , /*decltype(_impl_.dataset_stats_)*/{::_pbi::ArenaInitialized(), arena}
993     , decltype(_impl_.population_name_){}
994     , decltype(_impl_.session_name_){}
995     , decltype(_impl_.task_name_){}
996     , decltype(_impl_.error_message_){}
997     , decltype(_impl_.retry_window_){nullptr}
998     , decltype(_impl_.network_duration_){nullptr}
999     , decltype(_impl_.chunking_layer_bytes_downloaded_){::int64_t{0}}
1000     , decltype(_impl_.chunking_layer_bytes_uploaded_){::int64_t{0}}
1001     , /*decltype(_impl_._cached_size_)*/{}
1002   };
1003   _impl_.population_name_.InitDefault();
1004   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1005     _impl_.population_name_.Set("", GetArenaForAllocation());
1006   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1007   _impl_.session_name_.InitDefault();
1008   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1009     _impl_.session_name_.Set("", GetArenaForAllocation());
1010   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1011   _impl_.task_name_.InitDefault();
1012   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1013     _impl_.task_name_.Set("", GetArenaForAllocation());
1014   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1015   _impl_.error_message_.InitDefault();
1016   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1017     _impl_.error_message_.Set("", GetArenaForAllocation());
1018   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1019 }
1020 
~OperationalStats()1021 OperationalStats::~OperationalStats() {
1022   // @@protoc_insertion_point(destructor:fcp.client.opstats.OperationalStats)
1023   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1024   (void)arena;
1025     return;
1026   }
1027   SharedDtor();
1028 }
1029 
SharedDtor()1030 inline void OperationalStats::SharedDtor() {
1031   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1032   _impl_.events_.~RepeatedPtrField();
1033   _impl_.dataset_stats_.Destruct();
1034   _impl_.dataset_stats_.~MapFieldLite();
1035   _impl_.population_name_.Destroy();
1036   _impl_.session_name_.Destroy();
1037   _impl_.task_name_.Destroy();
1038   _impl_.error_message_.Destroy();
1039   if (this != internal_default_instance()) delete _impl_.retry_window_;
1040   if (this != internal_default_instance()) delete _impl_.network_duration_;
1041 }
1042 
SetCachedSize(int size) const1043 void OperationalStats::SetCachedSize(int size) const {
1044   _impl_._cached_size_.Set(size);
1045 }
1046 
Clear()1047 void OperationalStats::Clear() {
1048 // @@protoc_insertion_point(message_clear_start:fcp.client.opstats.OperationalStats)
1049   ::uint32_t cached_has_bits = 0;
1050   // Prevent compiler warnings about cached_has_bits being unused
1051   (void) cached_has_bits;
1052 
1053   _impl_.events_.Clear();
1054   _impl_.dataset_stats_.Clear();
1055   _impl_.population_name_.ClearToEmpty();
1056   _impl_.session_name_.ClearToEmpty();
1057   _impl_.task_name_.ClearToEmpty();
1058   _impl_.error_message_.ClearToEmpty();
1059   if (GetArenaForAllocation() == nullptr && _impl_.retry_window_ != nullptr) {
1060     delete _impl_.retry_window_;
1061   }
1062   _impl_.retry_window_ = nullptr;
1063   if (GetArenaForAllocation() == nullptr && _impl_.network_duration_ != nullptr) {
1064     delete _impl_.network_duration_;
1065   }
1066   _impl_.network_duration_ = nullptr;
1067   ::memset(&_impl_.chunking_layer_bytes_downloaded_, 0, static_cast<size_t>(
1068       reinterpret_cast<char*>(&_impl_.chunking_layer_bytes_uploaded_) -
1069       reinterpret_cast<char*>(&_impl_.chunking_layer_bytes_downloaded_)) + sizeof(_impl_.chunking_layer_bytes_uploaded_));
1070   _internal_metadata_.Clear<std::string>();
1071 }
1072 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1073 const char* OperationalStats::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1074 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1075   while (!ctx->Done(&ptr)) {
1076     ::uint32_t tag;
1077     ptr = ::_pbi::ReadTag(ptr, &tag);
1078     switch (tag >> 3) {
1079       // string population_name = 1;
1080       case 1:
1081         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1082           auto str = _internal_mutable_population_name();
1083           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1084           CHK_(ptr);
1085           CHK_(::_pbi::VerifyUTF8(str, nullptr));
1086         } else {
1087           goto handle_unusual;
1088         }
1089         continue;
1090       // string session_name = 2;
1091       case 2:
1092         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1093           auto str = _internal_mutable_session_name();
1094           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1095           CHK_(ptr);
1096           CHK_(::_pbi::VerifyUTF8(str, nullptr));
1097         } else {
1098           goto handle_unusual;
1099         }
1100         continue;
1101       // string task_name = 3;
1102       case 3:
1103         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
1104           auto str = _internal_mutable_task_name();
1105           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1106           CHK_(ptr);
1107           CHK_(::_pbi::VerifyUTF8(str, nullptr));
1108         } else {
1109           goto handle_unusual;
1110         }
1111         continue;
1112       // repeated .fcp.client.opstats.OperationalStats.Event events = 4;
1113       case 4:
1114         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
1115           ptr -= 1;
1116           do {
1117             ptr += 1;
1118             ptr = ctx->ParseMessage(_internal_add_events(), ptr);
1119             CHK_(ptr);
1120             if (!ctx->DataAvailable(ptr)) break;
1121           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
1122         } else {
1123           goto handle_unusual;
1124         }
1125         continue;
1126       // map<string, .fcp.client.opstats.OperationalStats.DatasetStats> dataset_stats = 5;
1127       case 5:
1128         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
1129           ptr -= 1;
1130           do {
1131             ptr += 1;
1132             ptr = ctx->ParseMessage(&_impl_.dataset_stats_, ptr);
1133             CHK_(ptr);
1134             if (!ctx->DataAvailable(ptr)) break;
1135           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
1136         } else {
1137           goto handle_unusual;
1138         }
1139         continue;
1140       // string error_message = 6;
1141       case 6:
1142         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
1143           auto str = _internal_mutable_error_message();
1144           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1145           CHK_(ptr);
1146           CHK_(::_pbi::VerifyUTF8(str, nullptr));
1147         } else {
1148           goto handle_unusual;
1149         }
1150         continue;
1151       // .google.internal.federatedml.v2.RetryWindow retry_window = 7;
1152       case 7:
1153         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 58)) {
1154           ptr = ctx->ParseMessage(_internal_mutable_retry_window(), ptr);
1155           CHK_(ptr);
1156         } else {
1157           goto handle_unusual;
1158         }
1159         continue;
1160       // int64 chunking_layer_bytes_downloaded = 10;
1161       case 10:
1162         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 80)) {
1163           _impl_.chunking_layer_bytes_downloaded_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1164           CHK_(ptr);
1165         } else {
1166           goto handle_unusual;
1167         }
1168         continue;
1169       // int64 chunking_layer_bytes_uploaded = 11;
1170       case 11:
1171         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 88)) {
1172           _impl_.chunking_layer_bytes_uploaded_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1173           CHK_(ptr);
1174         } else {
1175           goto handle_unusual;
1176         }
1177         continue;
1178       // .google.protobuf.Duration network_duration = 12;
1179       case 12:
1180         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 98)) {
1181           ptr = ctx->ParseMessage(_internal_mutable_network_duration(), ptr);
1182           CHK_(ptr);
1183         } else {
1184           goto handle_unusual;
1185         }
1186         continue;
1187       default:
1188         goto handle_unusual;
1189     }  // switch
1190   handle_unusual:
1191     if ((tag == 0) || ((tag & 7) == 4)) {
1192       CHK_(ptr);
1193       ctx->SetLastTag(tag);
1194       goto message_done;
1195     }
1196     ptr = UnknownFieldParse(
1197         tag,
1198         _internal_metadata_.mutable_unknown_fields<std::string>(),
1199         ptr, ctx);
1200     CHK_(ptr != nullptr);
1201   }  // while
1202 message_done:
1203   return ptr;
1204 failure:
1205   ptr = nullptr;
1206   goto message_done;
1207 #undef CHK_
1208 }
1209 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1210 ::uint8_t* OperationalStats::_InternalSerialize(
1211     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1212   // @@protoc_insertion_point(serialize_to_array_start:fcp.client.opstats.OperationalStats)
1213   ::uint32_t cached_has_bits = 0;
1214   (void) cached_has_bits;
1215 
1216   // string population_name = 1;
1217   if (!this->_internal_population_name().empty()) {
1218     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1219       this->_internal_population_name().data(), static_cast<int>(this->_internal_population_name().length()),
1220       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1221       "fcp.client.opstats.OperationalStats.population_name");
1222     target = stream->WriteStringMaybeAliased(
1223         1, this->_internal_population_name(), target);
1224   }
1225 
1226   // string session_name = 2;
1227   if (!this->_internal_session_name().empty()) {
1228     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1229       this->_internal_session_name().data(), static_cast<int>(this->_internal_session_name().length()),
1230       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1231       "fcp.client.opstats.OperationalStats.session_name");
1232     target = stream->WriteStringMaybeAliased(
1233         2, this->_internal_session_name(), target);
1234   }
1235 
1236   // string task_name = 3;
1237   if (!this->_internal_task_name().empty()) {
1238     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1239       this->_internal_task_name().data(), static_cast<int>(this->_internal_task_name().length()),
1240       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1241       "fcp.client.opstats.OperationalStats.task_name");
1242     target = stream->WriteStringMaybeAliased(
1243         3, this->_internal_task_name(), target);
1244   }
1245 
1246   // repeated .fcp.client.opstats.OperationalStats.Event events = 4;
1247   for (unsigned i = 0,
1248       n = static_cast<unsigned>(this->_internal_events_size()); i < n; i++) {
1249     const auto& repfield = this->_internal_events(i);
1250     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1251         InternalWriteMessage(4, repfield, repfield.GetCachedSize(), target, stream);
1252   }
1253 
1254   // map<string, .fcp.client.opstats.OperationalStats.DatasetStats> dataset_stats = 5;
1255   if (!this->_internal_dataset_stats().empty()) {
1256     using MapType = ::_pb::Map<std::string, ::fcp::client::opstats::OperationalStats_DatasetStats>;
1257     using WireHelper = OperationalStats_DatasetStatsEntry_DoNotUse::Funcs;
1258     const auto& map_field = this->_internal_dataset_stats();
1259     auto check_utf8 = [](const MapType::value_type& entry) {
1260       (void)entry;
1261       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1262         entry.first.data(), static_cast<int>(entry.first.length()),
1263         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1264         "fcp.client.opstats.OperationalStats.DatasetStatsEntry.key");
1265     };
1266 
1267     if (stream->IsSerializationDeterministic() && map_field.size() > 1) {
1268       for (const auto& entry : ::_pbi::MapSorterPtr<MapType>(map_field)) {
1269         target = WireHelper::InternalSerialize(5, entry.first, entry.second, target, stream);
1270         check_utf8(entry);
1271       }
1272     } else {
1273       for (const auto& entry : map_field) {
1274         target = WireHelper::InternalSerialize(5, entry.first, entry.second, target, stream);
1275         check_utf8(entry);
1276       }
1277     }
1278   }
1279 
1280   // string error_message = 6;
1281   if (!this->_internal_error_message().empty()) {
1282     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1283       this->_internal_error_message().data(), static_cast<int>(this->_internal_error_message().length()),
1284       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1285       "fcp.client.opstats.OperationalStats.error_message");
1286     target = stream->WriteStringMaybeAliased(
1287         6, this->_internal_error_message(), target);
1288   }
1289 
1290   // .google.internal.federatedml.v2.RetryWindow retry_window = 7;
1291   if (this->_internal_has_retry_window()) {
1292     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1293       InternalWriteMessage(7, _Internal::retry_window(this),
1294         _Internal::retry_window(this).GetCachedSize(), target, stream);
1295   }
1296 
1297   // int64 chunking_layer_bytes_downloaded = 10;
1298   if (this->_internal_chunking_layer_bytes_downloaded() != 0) {
1299     target = stream->EnsureSpace(target);
1300     target = ::_pbi::WireFormatLite::WriteInt64ToArray(10, this->_internal_chunking_layer_bytes_downloaded(), target);
1301   }
1302 
1303   // int64 chunking_layer_bytes_uploaded = 11;
1304   if (this->_internal_chunking_layer_bytes_uploaded() != 0) {
1305     target = stream->EnsureSpace(target);
1306     target = ::_pbi::WireFormatLite::WriteInt64ToArray(11, this->_internal_chunking_layer_bytes_uploaded(), target);
1307   }
1308 
1309   // .google.protobuf.Duration network_duration = 12;
1310   if (this->_internal_has_network_duration()) {
1311     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1312       InternalWriteMessage(12, _Internal::network_duration(this),
1313         _Internal::network_duration(this).GetCachedSize(), target, stream);
1314   }
1315 
1316   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1317     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1318         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1319   }
1320   // @@protoc_insertion_point(serialize_to_array_end:fcp.client.opstats.OperationalStats)
1321   return target;
1322 }
1323 
ByteSizeLong() const1324 size_t OperationalStats::ByteSizeLong() const {
1325 // @@protoc_insertion_point(message_byte_size_start:fcp.client.opstats.OperationalStats)
1326   size_t total_size = 0;
1327 
1328   ::uint32_t cached_has_bits = 0;
1329   // Prevent compiler warnings about cached_has_bits being unused
1330   (void) cached_has_bits;
1331 
1332   // repeated .fcp.client.opstats.OperationalStats.Event events = 4;
1333   total_size += 1UL * this->_internal_events_size();
1334   for (const auto& msg : this->_impl_.events_) {
1335     total_size +=
1336       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
1337   }
1338 
1339   // map<string, .fcp.client.opstats.OperationalStats.DatasetStats> dataset_stats = 5;
1340   total_size += 1 *
1341       ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_dataset_stats_size());
1342   for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::fcp::client::opstats::OperationalStats_DatasetStats >::const_iterator
1343       it = this->_internal_dataset_stats().begin();
1344       it != this->_internal_dataset_stats().end(); ++it) {
1345     total_size += OperationalStats_DatasetStatsEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
1346   }
1347 
1348   // string population_name = 1;
1349   if (!this->_internal_population_name().empty()) {
1350     total_size += 1 +
1351       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1352         this->_internal_population_name());
1353   }
1354 
1355   // string session_name = 2;
1356   if (!this->_internal_session_name().empty()) {
1357     total_size += 1 +
1358       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1359         this->_internal_session_name());
1360   }
1361 
1362   // string task_name = 3;
1363   if (!this->_internal_task_name().empty()) {
1364     total_size += 1 +
1365       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1366         this->_internal_task_name());
1367   }
1368 
1369   // string error_message = 6;
1370   if (!this->_internal_error_message().empty()) {
1371     total_size += 1 +
1372       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1373         this->_internal_error_message());
1374   }
1375 
1376   // .google.internal.federatedml.v2.RetryWindow retry_window = 7;
1377   if (this->_internal_has_retry_window()) {
1378     total_size += 1 +
1379       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1380         *_impl_.retry_window_);
1381   }
1382 
1383   // .google.protobuf.Duration network_duration = 12;
1384   if (this->_internal_has_network_duration()) {
1385     total_size += 1 +
1386       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1387         *_impl_.network_duration_);
1388   }
1389 
1390   // int64 chunking_layer_bytes_downloaded = 10;
1391   if (this->_internal_chunking_layer_bytes_downloaded() != 0) {
1392     total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_chunking_layer_bytes_downloaded());
1393   }
1394 
1395   // int64 chunking_layer_bytes_uploaded = 11;
1396   if (this->_internal_chunking_layer_bytes_uploaded() != 0) {
1397     total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_chunking_layer_bytes_uploaded());
1398   }
1399 
1400   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1401     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1402   }
1403   int cached_size = ::_pbi::ToCachedSize(total_size);
1404   SetCachedSize(cached_size);
1405   return total_size;
1406 }
1407 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1408 void OperationalStats::CheckTypeAndMergeFrom(
1409     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1410   MergeFrom(*::_pbi::DownCast<const OperationalStats*>(
1411       &from));
1412 }
1413 
MergeFrom(const OperationalStats & from)1414 void OperationalStats::MergeFrom(const OperationalStats& from) {
1415   OperationalStats* const _this = this;
1416   // @@protoc_insertion_point(class_specific_merge_from_start:fcp.client.opstats.OperationalStats)
1417   GOOGLE_DCHECK_NE(&from, _this);
1418   ::uint32_t cached_has_bits = 0;
1419   (void) cached_has_bits;
1420 
1421   _this->_impl_.events_.MergeFrom(from._impl_.events_);
1422   _this->_impl_.dataset_stats_.MergeFrom(from._impl_.dataset_stats_);
1423   if (!from._internal_population_name().empty()) {
1424     _this->_internal_set_population_name(from._internal_population_name());
1425   }
1426   if (!from._internal_session_name().empty()) {
1427     _this->_internal_set_session_name(from._internal_session_name());
1428   }
1429   if (!from._internal_task_name().empty()) {
1430     _this->_internal_set_task_name(from._internal_task_name());
1431   }
1432   if (!from._internal_error_message().empty()) {
1433     _this->_internal_set_error_message(from._internal_error_message());
1434   }
1435   if (from._internal_has_retry_window()) {
1436     _this->_internal_mutable_retry_window()->::google::internal::federatedml::v2::RetryWindow::MergeFrom(
1437         from._internal_retry_window());
1438   }
1439   if (from._internal_has_network_duration()) {
1440     _this->_internal_mutable_network_duration()->::PROTOBUF_NAMESPACE_ID::Duration::MergeFrom(
1441         from._internal_network_duration());
1442   }
1443   if (from._internal_chunking_layer_bytes_downloaded() != 0) {
1444     _this->_internal_set_chunking_layer_bytes_downloaded(from._internal_chunking_layer_bytes_downloaded());
1445   }
1446   if (from._internal_chunking_layer_bytes_uploaded() != 0) {
1447     _this->_internal_set_chunking_layer_bytes_uploaded(from._internal_chunking_layer_bytes_uploaded());
1448   }
1449   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1450 }
1451 
CopyFrom(const OperationalStats & from)1452 void OperationalStats::CopyFrom(const OperationalStats& from) {
1453 // @@protoc_insertion_point(class_specific_copy_from_start:fcp.client.opstats.OperationalStats)
1454   if (&from == this) return;
1455   Clear();
1456   MergeFrom(from);
1457 }
1458 
IsInitialized() const1459 bool OperationalStats::IsInitialized() const {
1460   return true;
1461 }
1462 
InternalSwap(OperationalStats * other)1463 void OperationalStats::InternalSwap(OperationalStats* other) {
1464   using std::swap;
1465   auto* lhs_arena = GetArenaForAllocation();
1466   auto* rhs_arena = other->GetArenaForAllocation();
1467   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1468   _impl_.events_.InternalSwap(&other->_impl_.events_);
1469   _impl_.dataset_stats_.InternalSwap(&other->_impl_.dataset_stats_);
1470   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1471       &_impl_.population_name_, lhs_arena,
1472       &other->_impl_.population_name_, rhs_arena
1473   );
1474   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1475       &_impl_.session_name_, lhs_arena,
1476       &other->_impl_.session_name_, rhs_arena
1477   );
1478   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1479       &_impl_.task_name_, lhs_arena,
1480       &other->_impl_.task_name_, rhs_arena
1481   );
1482   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1483       &_impl_.error_message_, lhs_arena,
1484       &other->_impl_.error_message_, rhs_arena
1485   );
1486   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1487       PROTOBUF_FIELD_OFFSET(OperationalStats, _impl_.chunking_layer_bytes_uploaded_)
1488       + sizeof(OperationalStats::_impl_.chunking_layer_bytes_uploaded_)  // NOLINT
1489       - PROTOBUF_FIELD_OFFSET(OperationalStats, _impl_.retry_window_)>(
1490           reinterpret_cast<char*>(&_impl_.retry_window_),
1491           reinterpret_cast<char*>(&other->_impl_.retry_window_));
1492 }
1493 
GetTypeName() const1494 std::string OperationalStats::GetTypeName() const {
1495   return "fcp.client.opstats.OperationalStats";
1496 }
1497 
1498 
1499 // ===================================================================
1500 
1501 class OpStatsSequence::_Internal {
1502  public:
1503   static const ::PROTOBUF_NAMESPACE_ID::Timestamp& earliest_trustworthy_time(const OpStatsSequence* msg);
1504 };
1505 
1506 const ::PROTOBUF_NAMESPACE_ID::Timestamp&
earliest_trustworthy_time(const OpStatsSequence * msg)1507 OpStatsSequence::_Internal::earliest_trustworthy_time(const OpStatsSequence* msg) {
1508   return *msg->_impl_.earliest_trustworthy_time_;
1509 }
clear_earliest_trustworthy_time()1510 void OpStatsSequence::clear_earliest_trustworthy_time() {
1511   if (GetArenaForAllocation() == nullptr && _impl_.earliest_trustworthy_time_ != nullptr) {
1512     delete _impl_.earliest_trustworthy_time_;
1513   }
1514   _impl_.earliest_trustworthy_time_ = nullptr;
1515 }
OpStatsSequence(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1516 OpStatsSequence::OpStatsSequence(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1517                          bool is_message_owned)
1518   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1519   SharedCtor(arena, is_message_owned);
1520   // @@protoc_insertion_point(arena_constructor:fcp.client.opstats.OpStatsSequence)
1521 }
OpStatsSequence(const OpStatsSequence & from)1522 OpStatsSequence::OpStatsSequence(const OpStatsSequence& from)
1523   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1524   OpStatsSequence* const _this = this; (void)_this;
1525   new (&_impl_) Impl_{
1526       decltype(_impl_.opstats_){from._impl_.opstats_}
1527     , decltype(_impl_.earliest_trustworthy_time_){nullptr}
1528     , /*decltype(_impl_._cached_size_)*/{}};
1529 
1530   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1531   if (from._internal_has_earliest_trustworthy_time()) {
1532     _this->_impl_.earliest_trustworthy_time_ = new ::PROTOBUF_NAMESPACE_ID::Timestamp(*from._impl_.earliest_trustworthy_time_);
1533   }
1534   // @@protoc_insertion_point(copy_constructor:fcp.client.opstats.OpStatsSequence)
1535 }
1536 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1537 inline void OpStatsSequence::SharedCtor(
1538     ::_pb::Arena* arena, bool is_message_owned) {
1539   (void)arena;
1540   (void)is_message_owned;
1541   new (&_impl_) Impl_{
1542       decltype(_impl_.opstats_){arena}
1543     , decltype(_impl_.earliest_trustworthy_time_){nullptr}
1544     , /*decltype(_impl_._cached_size_)*/{}
1545   };
1546 }
1547 
~OpStatsSequence()1548 OpStatsSequence::~OpStatsSequence() {
1549   // @@protoc_insertion_point(destructor:fcp.client.opstats.OpStatsSequence)
1550   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1551   (void)arena;
1552     return;
1553   }
1554   SharedDtor();
1555 }
1556 
SharedDtor()1557 inline void OpStatsSequence::SharedDtor() {
1558   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1559   _impl_.opstats_.~RepeatedPtrField();
1560   if (this != internal_default_instance()) delete _impl_.earliest_trustworthy_time_;
1561 }
1562 
SetCachedSize(int size) const1563 void OpStatsSequence::SetCachedSize(int size) const {
1564   _impl_._cached_size_.Set(size);
1565 }
1566 
Clear()1567 void OpStatsSequence::Clear() {
1568 // @@protoc_insertion_point(message_clear_start:fcp.client.opstats.OpStatsSequence)
1569   ::uint32_t cached_has_bits = 0;
1570   // Prevent compiler warnings about cached_has_bits being unused
1571   (void) cached_has_bits;
1572 
1573   _impl_.opstats_.Clear();
1574   if (GetArenaForAllocation() == nullptr && _impl_.earliest_trustworthy_time_ != nullptr) {
1575     delete _impl_.earliest_trustworthy_time_;
1576   }
1577   _impl_.earliest_trustworthy_time_ = nullptr;
1578   _internal_metadata_.Clear<std::string>();
1579 }
1580 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1581 const char* OpStatsSequence::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1582 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1583   while (!ctx->Done(&ptr)) {
1584     ::uint32_t tag;
1585     ptr = ::_pbi::ReadTag(ptr, &tag);
1586     switch (tag >> 3) {
1587       // repeated .fcp.client.opstats.OperationalStats opstats = 1;
1588       case 1:
1589         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1590           ptr -= 1;
1591           do {
1592             ptr += 1;
1593             ptr = ctx->ParseMessage(_internal_add_opstats(), ptr);
1594             CHK_(ptr);
1595             if (!ctx->DataAvailable(ptr)) break;
1596           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
1597         } else {
1598           goto handle_unusual;
1599         }
1600         continue;
1601       // .google.protobuf.Timestamp earliest_trustworthy_time = 2;
1602       case 2:
1603         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1604           ptr = ctx->ParseMessage(_internal_mutable_earliest_trustworthy_time(), ptr);
1605           CHK_(ptr);
1606         } else {
1607           goto handle_unusual;
1608         }
1609         continue;
1610       default:
1611         goto handle_unusual;
1612     }  // switch
1613   handle_unusual:
1614     if ((tag == 0) || ((tag & 7) == 4)) {
1615       CHK_(ptr);
1616       ctx->SetLastTag(tag);
1617       goto message_done;
1618     }
1619     ptr = UnknownFieldParse(
1620         tag,
1621         _internal_metadata_.mutable_unknown_fields<std::string>(),
1622         ptr, ctx);
1623     CHK_(ptr != nullptr);
1624   }  // while
1625 message_done:
1626   return ptr;
1627 failure:
1628   ptr = nullptr;
1629   goto message_done;
1630 #undef CHK_
1631 }
1632 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1633 ::uint8_t* OpStatsSequence::_InternalSerialize(
1634     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1635   // @@protoc_insertion_point(serialize_to_array_start:fcp.client.opstats.OpStatsSequence)
1636   ::uint32_t cached_has_bits = 0;
1637   (void) cached_has_bits;
1638 
1639   // repeated .fcp.client.opstats.OperationalStats opstats = 1;
1640   for (unsigned i = 0,
1641       n = static_cast<unsigned>(this->_internal_opstats_size()); i < n; i++) {
1642     const auto& repfield = this->_internal_opstats(i);
1643     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1644         InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
1645   }
1646 
1647   // .google.protobuf.Timestamp earliest_trustworthy_time = 2;
1648   if (this->_internal_has_earliest_trustworthy_time()) {
1649     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1650       InternalWriteMessage(2, _Internal::earliest_trustworthy_time(this),
1651         _Internal::earliest_trustworthy_time(this).GetCachedSize(), target, stream);
1652   }
1653 
1654   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1655     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1656         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1657   }
1658   // @@protoc_insertion_point(serialize_to_array_end:fcp.client.opstats.OpStatsSequence)
1659   return target;
1660 }
1661 
ByteSizeLong() const1662 size_t OpStatsSequence::ByteSizeLong() const {
1663 // @@protoc_insertion_point(message_byte_size_start:fcp.client.opstats.OpStatsSequence)
1664   size_t total_size = 0;
1665 
1666   ::uint32_t cached_has_bits = 0;
1667   // Prevent compiler warnings about cached_has_bits being unused
1668   (void) cached_has_bits;
1669 
1670   // repeated .fcp.client.opstats.OperationalStats opstats = 1;
1671   total_size += 1UL * this->_internal_opstats_size();
1672   for (const auto& msg : this->_impl_.opstats_) {
1673     total_size +=
1674       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
1675   }
1676 
1677   // .google.protobuf.Timestamp earliest_trustworthy_time = 2;
1678   if (this->_internal_has_earliest_trustworthy_time()) {
1679     total_size += 1 +
1680       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1681         *_impl_.earliest_trustworthy_time_);
1682   }
1683 
1684   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1685     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1686   }
1687   int cached_size = ::_pbi::ToCachedSize(total_size);
1688   SetCachedSize(cached_size);
1689   return total_size;
1690 }
1691 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1692 void OpStatsSequence::CheckTypeAndMergeFrom(
1693     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1694   MergeFrom(*::_pbi::DownCast<const OpStatsSequence*>(
1695       &from));
1696 }
1697 
MergeFrom(const OpStatsSequence & from)1698 void OpStatsSequence::MergeFrom(const OpStatsSequence& from) {
1699   OpStatsSequence* const _this = this;
1700   // @@protoc_insertion_point(class_specific_merge_from_start:fcp.client.opstats.OpStatsSequence)
1701   GOOGLE_DCHECK_NE(&from, _this);
1702   ::uint32_t cached_has_bits = 0;
1703   (void) cached_has_bits;
1704 
1705   _this->_impl_.opstats_.MergeFrom(from._impl_.opstats_);
1706   if (from._internal_has_earliest_trustworthy_time()) {
1707     _this->_internal_mutable_earliest_trustworthy_time()->::PROTOBUF_NAMESPACE_ID::Timestamp::MergeFrom(
1708         from._internal_earliest_trustworthy_time());
1709   }
1710   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1711 }
1712 
CopyFrom(const OpStatsSequence & from)1713 void OpStatsSequence::CopyFrom(const OpStatsSequence& from) {
1714 // @@protoc_insertion_point(class_specific_copy_from_start:fcp.client.opstats.OpStatsSequence)
1715   if (&from == this) return;
1716   Clear();
1717   MergeFrom(from);
1718 }
1719 
IsInitialized() const1720 bool OpStatsSequence::IsInitialized() const {
1721   return true;
1722 }
1723 
InternalSwap(OpStatsSequence * other)1724 void OpStatsSequence::InternalSwap(OpStatsSequence* other) {
1725   using std::swap;
1726   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1727   _impl_.opstats_.InternalSwap(&other->_impl_.opstats_);
1728   swap(_impl_.earliest_trustworthy_time_, other->_impl_.earliest_trustworthy_time_);
1729 }
1730 
GetTypeName() const1731 std::string OpStatsSequence::GetTypeName() const {
1732   return "fcp.client.opstats.OpStatsSequence";
1733 }
1734 
1735 
1736 // ===================================================================
1737 
1738 class OpStatsSelectionCriteria::_Internal {
1739  public:
1740   static const ::PROTOBUF_NAMESPACE_ID::Timestamp& start_time(const OpStatsSelectionCriteria* msg);
1741   static const ::PROTOBUF_NAMESPACE_ID::Timestamp& end_time(const OpStatsSelectionCriteria* msg);
1742 };
1743 
1744 const ::PROTOBUF_NAMESPACE_ID::Timestamp&
start_time(const OpStatsSelectionCriteria * msg)1745 OpStatsSelectionCriteria::_Internal::start_time(const OpStatsSelectionCriteria* msg) {
1746   return *msg->_impl_.start_time_;
1747 }
1748 const ::PROTOBUF_NAMESPACE_ID::Timestamp&
end_time(const OpStatsSelectionCriteria * msg)1749 OpStatsSelectionCriteria::_Internal::end_time(const OpStatsSelectionCriteria* msg) {
1750   return *msg->_impl_.end_time_;
1751 }
clear_start_time()1752 void OpStatsSelectionCriteria::clear_start_time() {
1753   if (GetArenaForAllocation() == nullptr && _impl_.start_time_ != nullptr) {
1754     delete _impl_.start_time_;
1755   }
1756   _impl_.start_time_ = nullptr;
1757 }
clear_end_time()1758 void OpStatsSelectionCriteria::clear_end_time() {
1759   if (GetArenaForAllocation() == nullptr && _impl_.end_time_ != nullptr) {
1760     delete _impl_.end_time_;
1761   }
1762   _impl_.end_time_ = nullptr;
1763 }
OpStatsSelectionCriteria(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1764 OpStatsSelectionCriteria::OpStatsSelectionCriteria(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1765                          bool is_message_owned)
1766   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1767   SharedCtor(arena, is_message_owned);
1768   // @@protoc_insertion_point(arena_constructor:fcp.client.opstats.OpStatsSelectionCriteria)
1769 }
OpStatsSelectionCriteria(const OpStatsSelectionCriteria & from)1770 OpStatsSelectionCriteria::OpStatsSelectionCriteria(const OpStatsSelectionCriteria& from)
1771   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1772   OpStatsSelectionCriteria* const _this = this; (void)_this;
1773   new (&_impl_) Impl_{
1774       decltype(_impl_.start_time_){nullptr}
1775     , decltype(_impl_.end_time_){nullptr}
1776     , decltype(_impl_.last_successful_contribution_){}
1777     , /*decltype(_impl_._cached_size_)*/{}};
1778 
1779   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1780   if (from._internal_has_start_time()) {
1781     _this->_impl_.start_time_ = new ::PROTOBUF_NAMESPACE_ID::Timestamp(*from._impl_.start_time_);
1782   }
1783   if (from._internal_has_end_time()) {
1784     _this->_impl_.end_time_ = new ::PROTOBUF_NAMESPACE_ID::Timestamp(*from._impl_.end_time_);
1785   }
1786   _this->_impl_.last_successful_contribution_ = from._impl_.last_successful_contribution_;
1787   // @@protoc_insertion_point(copy_constructor:fcp.client.opstats.OpStatsSelectionCriteria)
1788 }
1789 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1790 inline void OpStatsSelectionCriteria::SharedCtor(
1791     ::_pb::Arena* arena, bool is_message_owned) {
1792   (void)arena;
1793   (void)is_message_owned;
1794   new (&_impl_) Impl_{
1795       decltype(_impl_.start_time_){nullptr}
1796     , decltype(_impl_.end_time_){nullptr}
1797     , decltype(_impl_.last_successful_contribution_){false}
1798     , /*decltype(_impl_._cached_size_)*/{}
1799   };
1800 }
1801 
~OpStatsSelectionCriteria()1802 OpStatsSelectionCriteria::~OpStatsSelectionCriteria() {
1803   // @@protoc_insertion_point(destructor:fcp.client.opstats.OpStatsSelectionCriteria)
1804   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1805   (void)arena;
1806     return;
1807   }
1808   SharedDtor();
1809 }
1810 
SharedDtor()1811 inline void OpStatsSelectionCriteria::SharedDtor() {
1812   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1813   if (this != internal_default_instance()) delete _impl_.start_time_;
1814   if (this != internal_default_instance()) delete _impl_.end_time_;
1815 }
1816 
SetCachedSize(int size) const1817 void OpStatsSelectionCriteria::SetCachedSize(int size) const {
1818   _impl_._cached_size_.Set(size);
1819 }
1820 
Clear()1821 void OpStatsSelectionCriteria::Clear() {
1822 // @@protoc_insertion_point(message_clear_start:fcp.client.opstats.OpStatsSelectionCriteria)
1823   ::uint32_t cached_has_bits = 0;
1824   // Prevent compiler warnings about cached_has_bits being unused
1825   (void) cached_has_bits;
1826 
1827   if (GetArenaForAllocation() == nullptr && _impl_.start_time_ != nullptr) {
1828     delete _impl_.start_time_;
1829   }
1830   _impl_.start_time_ = nullptr;
1831   if (GetArenaForAllocation() == nullptr && _impl_.end_time_ != nullptr) {
1832     delete _impl_.end_time_;
1833   }
1834   _impl_.end_time_ = nullptr;
1835   _impl_.last_successful_contribution_ = false;
1836   _internal_metadata_.Clear<std::string>();
1837 }
1838 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1839 const char* OpStatsSelectionCriteria::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1840 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1841   while (!ctx->Done(&ptr)) {
1842     ::uint32_t tag;
1843     ptr = ::_pbi::ReadTag(ptr, &tag);
1844     switch (tag >> 3) {
1845       // .google.protobuf.Timestamp start_time = 1;
1846       case 1:
1847         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1848           ptr = ctx->ParseMessage(_internal_mutable_start_time(), ptr);
1849           CHK_(ptr);
1850         } else {
1851           goto handle_unusual;
1852         }
1853         continue;
1854       // .google.protobuf.Timestamp end_time = 2;
1855       case 2:
1856         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1857           ptr = ctx->ParseMessage(_internal_mutable_end_time(), ptr);
1858           CHK_(ptr);
1859         } else {
1860           goto handle_unusual;
1861         }
1862         continue;
1863       // bool last_successful_contribution = 3;
1864       case 3:
1865         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1866           _impl_.last_successful_contribution_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1867           CHK_(ptr);
1868         } else {
1869           goto handle_unusual;
1870         }
1871         continue;
1872       default:
1873         goto handle_unusual;
1874     }  // switch
1875   handle_unusual:
1876     if ((tag == 0) || ((tag & 7) == 4)) {
1877       CHK_(ptr);
1878       ctx->SetLastTag(tag);
1879       goto message_done;
1880     }
1881     ptr = UnknownFieldParse(
1882         tag,
1883         _internal_metadata_.mutable_unknown_fields<std::string>(),
1884         ptr, ctx);
1885     CHK_(ptr != nullptr);
1886   }  // while
1887 message_done:
1888   return ptr;
1889 failure:
1890   ptr = nullptr;
1891   goto message_done;
1892 #undef CHK_
1893 }
1894 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1895 ::uint8_t* OpStatsSelectionCriteria::_InternalSerialize(
1896     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1897   // @@protoc_insertion_point(serialize_to_array_start:fcp.client.opstats.OpStatsSelectionCriteria)
1898   ::uint32_t cached_has_bits = 0;
1899   (void) cached_has_bits;
1900 
1901   // .google.protobuf.Timestamp start_time = 1;
1902   if (this->_internal_has_start_time()) {
1903     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1904       InternalWriteMessage(1, _Internal::start_time(this),
1905         _Internal::start_time(this).GetCachedSize(), target, stream);
1906   }
1907 
1908   // .google.protobuf.Timestamp end_time = 2;
1909   if (this->_internal_has_end_time()) {
1910     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1911       InternalWriteMessage(2, _Internal::end_time(this),
1912         _Internal::end_time(this).GetCachedSize(), target, stream);
1913   }
1914 
1915   // bool last_successful_contribution = 3;
1916   if (this->_internal_last_successful_contribution() != 0) {
1917     target = stream->EnsureSpace(target);
1918     target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_last_successful_contribution(), target);
1919   }
1920 
1921   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1922     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1923         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1924   }
1925   // @@protoc_insertion_point(serialize_to_array_end:fcp.client.opstats.OpStatsSelectionCriteria)
1926   return target;
1927 }
1928 
ByteSizeLong() const1929 size_t OpStatsSelectionCriteria::ByteSizeLong() const {
1930 // @@protoc_insertion_point(message_byte_size_start:fcp.client.opstats.OpStatsSelectionCriteria)
1931   size_t total_size = 0;
1932 
1933   ::uint32_t cached_has_bits = 0;
1934   // Prevent compiler warnings about cached_has_bits being unused
1935   (void) cached_has_bits;
1936 
1937   // .google.protobuf.Timestamp start_time = 1;
1938   if (this->_internal_has_start_time()) {
1939     total_size += 1 +
1940       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1941         *_impl_.start_time_);
1942   }
1943 
1944   // .google.protobuf.Timestamp end_time = 2;
1945   if (this->_internal_has_end_time()) {
1946     total_size += 1 +
1947       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1948         *_impl_.end_time_);
1949   }
1950 
1951   // bool last_successful_contribution = 3;
1952   if (this->_internal_last_successful_contribution() != 0) {
1953     total_size += 1 + 1;
1954   }
1955 
1956   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1957     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1958   }
1959   int cached_size = ::_pbi::ToCachedSize(total_size);
1960   SetCachedSize(cached_size);
1961   return total_size;
1962 }
1963 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1964 void OpStatsSelectionCriteria::CheckTypeAndMergeFrom(
1965     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1966   MergeFrom(*::_pbi::DownCast<const OpStatsSelectionCriteria*>(
1967       &from));
1968 }
1969 
MergeFrom(const OpStatsSelectionCriteria & from)1970 void OpStatsSelectionCriteria::MergeFrom(const OpStatsSelectionCriteria& from) {
1971   OpStatsSelectionCriteria* const _this = this;
1972   // @@protoc_insertion_point(class_specific_merge_from_start:fcp.client.opstats.OpStatsSelectionCriteria)
1973   GOOGLE_DCHECK_NE(&from, _this);
1974   ::uint32_t cached_has_bits = 0;
1975   (void) cached_has_bits;
1976 
1977   if (from._internal_has_start_time()) {
1978     _this->_internal_mutable_start_time()->::PROTOBUF_NAMESPACE_ID::Timestamp::MergeFrom(
1979         from._internal_start_time());
1980   }
1981   if (from._internal_has_end_time()) {
1982     _this->_internal_mutable_end_time()->::PROTOBUF_NAMESPACE_ID::Timestamp::MergeFrom(
1983         from._internal_end_time());
1984   }
1985   if (from._internal_last_successful_contribution() != 0) {
1986     _this->_internal_set_last_successful_contribution(from._internal_last_successful_contribution());
1987   }
1988   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1989 }
1990 
CopyFrom(const OpStatsSelectionCriteria & from)1991 void OpStatsSelectionCriteria::CopyFrom(const OpStatsSelectionCriteria& from) {
1992 // @@protoc_insertion_point(class_specific_copy_from_start:fcp.client.opstats.OpStatsSelectionCriteria)
1993   if (&from == this) return;
1994   Clear();
1995   MergeFrom(from);
1996 }
1997 
IsInitialized() const1998 bool OpStatsSelectionCriteria::IsInitialized() const {
1999   return true;
2000 }
2001 
InternalSwap(OpStatsSelectionCriteria * other)2002 void OpStatsSelectionCriteria::InternalSwap(OpStatsSelectionCriteria* other) {
2003   using std::swap;
2004   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2005   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2006       PROTOBUF_FIELD_OFFSET(OpStatsSelectionCriteria, _impl_.last_successful_contribution_)
2007       + sizeof(OpStatsSelectionCriteria::_impl_.last_successful_contribution_)  // NOLINT
2008       - PROTOBUF_FIELD_OFFSET(OpStatsSelectionCriteria, _impl_.start_time_)>(
2009           reinterpret_cast<char*>(&_impl_.start_time_),
2010           reinterpret_cast<char*>(&other->_impl_.start_time_));
2011 }
2012 
GetTypeName() const2013 std::string OpStatsSelectionCriteria::GetTypeName() const {
2014   return "fcp.client.opstats.OpStatsSelectionCriteria";
2015 }
2016 
2017 
2018 // @@protoc_insertion_point(namespace_scope)
2019 }  // namespace opstats
2020 }  // namespace client
2021 }  // namespace fcp
2022 PROTOBUF_NAMESPACE_OPEN
2023 template<> PROTOBUF_NOINLINE ::fcp::client::opstats::OperationalStats_Event*
CreateMaybeMessage(Arena * arena)2024 Arena::CreateMaybeMessage< ::fcp::client::opstats::OperationalStats_Event >(Arena* arena) {
2025   return Arena::CreateMessageInternal< ::fcp::client::opstats::OperationalStats_Event >(arena);
2026 }
2027 template<> PROTOBUF_NOINLINE ::fcp::client::opstats::OperationalStats_DatasetStats*
CreateMaybeMessage(Arena * arena)2028 Arena::CreateMaybeMessage< ::fcp::client::opstats::OperationalStats_DatasetStats >(Arena* arena) {
2029   return Arena::CreateMessageInternal< ::fcp::client::opstats::OperationalStats_DatasetStats >(arena);
2030 }
2031 template<> PROTOBUF_NOINLINE ::fcp::client::opstats::OperationalStats_DatasetStatsEntry_DoNotUse*
CreateMaybeMessage(Arena * arena)2032 Arena::CreateMaybeMessage< ::fcp::client::opstats::OperationalStats_DatasetStatsEntry_DoNotUse >(Arena* arena) {
2033   return Arena::CreateMessageInternal< ::fcp::client::opstats::OperationalStats_DatasetStatsEntry_DoNotUse >(arena);
2034 }
2035 template<> PROTOBUF_NOINLINE ::fcp::client::opstats::OperationalStats*
CreateMaybeMessage(Arena * arena)2036 Arena::CreateMaybeMessage< ::fcp::client::opstats::OperationalStats >(Arena* arena) {
2037   return Arena::CreateMessageInternal< ::fcp::client::opstats::OperationalStats >(arena);
2038 }
2039 template<> PROTOBUF_NOINLINE ::fcp::client::opstats::OpStatsSequence*
CreateMaybeMessage(Arena * arena)2040 Arena::CreateMaybeMessage< ::fcp::client::opstats::OpStatsSequence >(Arena* arena) {
2041   return Arena::CreateMessageInternal< ::fcp::client::opstats::OpStatsSequence >(arena);
2042 }
2043 template<> PROTOBUF_NOINLINE ::fcp::client::opstats::OpStatsSelectionCriteria*
CreateMaybeMessage(Arena * arena)2044 Arena::CreateMaybeMessage< ::fcp::client::opstats::OpStatsSelectionCriteria >(Arena* arena) {
2045   return Arena::CreateMessageInternal< ::fcp::client::opstats::OpStatsSelectionCriteria >(arena);
2046 }
2047 PROTOBUF_NAMESPACE_CLOSE
2048 
2049 // @@protoc_insertion_point(global_scope)
2050 #include <google/protobuf/port_undef.inc>
2051