1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: fcp/client/selector_context.proto
3
4 #include "fcp/client/selector_context.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 {
SelectorContext(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR SelectorContext::SelectorContext(
24 ::_pbi::ConstantInitialized): _impl_{
25 /*decltype(_impl_.computation_properties_)*/nullptr
26 , /*decltype(_impl_._cached_size_)*/{}} {}
27 struct SelectorContextDefaultTypeInternal {
SelectorContextDefaultTypeInternalfcp::client::SelectorContextDefaultTypeInternal28 PROTOBUF_CONSTEXPR SelectorContextDefaultTypeInternal()
29 : _instance(::_pbi::ConstantInitialized{}) {}
~SelectorContextDefaultTypeInternalfcp::client::SelectorContextDefaultTypeInternal30 ~SelectorContextDefaultTypeInternal() {}
31 union { // NOLINT(misc-non-private-member-variables-in-classes)
32 SelectorContext _instance;
33 };
34 };
35 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SelectorContextDefaultTypeInternal _SelectorContext_default_instance_;
QueryTimeComputationProperties(::_pbi::ConstantInitialized)36 PROTOBUF_CONSTEXPR QueryTimeComputationProperties::QueryTimeComputationProperties(
37 ::_pbi::ConstantInitialized): _impl_{
38 /*decltype(_impl_.session_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
39 , /*decltype(_impl_.context_data_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
40 , /*decltype(_impl_.run_id_)*/::int64_t{0}
41 , /*decltype(_impl_.example_iterator_output_format_)*/0
42 , /*decltype(_impl_.computation_type_)*/{}
43 , /*decltype(_impl_._cached_size_)*/{}
44 , /*decltype(_impl_._oneof_case_)*/{}} {}
45 struct QueryTimeComputationPropertiesDefaultTypeInternal {
QueryTimeComputationPropertiesDefaultTypeInternalfcp::client::QueryTimeComputationPropertiesDefaultTypeInternal46 PROTOBUF_CONSTEXPR QueryTimeComputationPropertiesDefaultTypeInternal()
47 : _instance(::_pbi::ConstantInitialized{}) {}
~QueryTimeComputationPropertiesDefaultTypeInternalfcp::client::QueryTimeComputationPropertiesDefaultTypeInternal48 ~QueryTimeComputationPropertiesDefaultTypeInternal() {}
49 union { // NOLINT(misc-non-private-member-variables-in-classes)
50 QueryTimeComputationProperties _instance;
51 };
52 };
53 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 QueryTimeComputationPropertiesDefaultTypeInternal _QueryTimeComputationProperties_default_instance_;
LocalComputation_InputResourceMapEntry_DoNotUse(::_pbi::ConstantInitialized)54 PROTOBUF_CONSTEXPR LocalComputation_InputResourceMapEntry_DoNotUse::LocalComputation_InputResourceMapEntry_DoNotUse(
55 ::_pbi::ConstantInitialized) {}
56 struct LocalComputation_InputResourceMapEntry_DoNotUseDefaultTypeInternal {
LocalComputation_InputResourceMapEntry_DoNotUseDefaultTypeInternalfcp::client::LocalComputation_InputResourceMapEntry_DoNotUseDefaultTypeInternal57 PROTOBUF_CONSTEXPR LocalComputation_InputResourceMapEntry_DoNotUseDefaultTypeInternal()
58 : _instance(::_pbi::ConstantInitialized{}) {}
~LocalComputation_InputResourceMapEntry_DoNotUseDefaultTypeInternalfcp::client::LocalComputation_InputResourceMapEntry_DoNotUseDefaultTypeInternal59 ~LocalComputation_InputResourceMapEntry_DoNotUseDefaultTypeInternal() {}
60 union { // NOLINT(misc-non-private-member-variables-in-classes)
61 LocalComputation_InputResourceMapEntry_DoNotUse _instance;
62 };
63 };
64 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LocalComputation_InputResourceMapEntry_DoNotUseDefaultTypeInternal _LocalComputation_InputResourceMapEntry_DoNotUse_default_instance_;
LocalComputation(::_pbi::ConstantInitialized)65 PROTOBUF_CONSTEXPR LocalComputation::LocalComputation(
66 ::_pbi::ConstantInitialized): _impl_{
67 /*decltype(_impl_.input_resource_map_)*/{}
68 , /*decltype(_impl_.input_dir_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
69 , /*decltype(_impl_.output_dir_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
70 , /*decltype(_impl_._cached_size_)*/{}} {}
71 struct LocalComputationDefaultTypeInternal {
LocalComputationDefaultTypeInternalfcp::client::LocalComputationDefaultTypeInternal72 PROTOBUF_CONSTEXPR LocalComputationDefaultTypeInternal()
73 : _instance(::_pbi::ConstantInitialized{}) {}
~LocalComputationDefaultTypeInternalfcp::client::LocalComputationDefaultTypeInternal74 ~LocalComputationDefaultTypeInternal() {}
75 union { // NOLINT(misc-non-private-member-variables-in-classes)
76 LocalComputation _instance;
77 };
78 };
79 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LocalComputationDefaultTypeInternal _LocalComputation_default_instance_;
EligibilityEvalComputation(::_pbi::ConstantInitialized)80 PROTOBUF_CONSTEXPR EligibilityEvalComputation::EligibilityEvalComputation(
81 ::_pbi::ConstantInitialized): _impl_{
82 /*decltype(_impl_.population_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
83 , /*decltype(_impl_._cached_size_)*/{}} {}
84 struct EligibilityEvalComputationDefaultTypeInternal {
EligibilityEvalComputationDefaultTypeInternalfcp::client::EligibilityEvalComputationDefaultTypeInternal85 PROTOBUF_CONSTEXPR EligibilityEvalComputationDefaultTypeInternal()
86 : _instance(::_pbi::ConstantInitialized{}) {}
~EligibilityEvalComputationDefaultTypeInternalfcp::client::EligibilityEvalComputationDefaultTypeInternal87 ~EligibilityEvalComputationDefaultTypeInternal() {}
88 union { // NOLINT(misc-non-private-member-variables-in-classes)
89 EligibilityEvalComputation _instance;
90 };
91 };
92 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EligibilityEvalComputationDefaultTypeInternal _EligibilityEvalComputation_default_instance_;
FederatedComputation(::_pbi::ConstantInitialized)93 PROTOBUF_CONSTEXPR FederatedComputation::FederatedComputation(
94 ::_pbi::ConstantInitialized): _impl_{
95 /*decltype(_impl_.population_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
96 , /*decltype(_impl_.task_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
97 , /*decltype(_impl_.computation_id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
98 , /*decltype(_impl_.historical_context_)*/nullptr
99 , /*decltype(_impl_.aggregation_type_)*/{}
100 , /*decltype(_impl_._cached_size_)*/{}
101 , /*decltype(_impl_._oneof_case_)*/{}} {}
102 struct FederatedComputationDefaultTypeInternal {
FederatedComputationDefaultTypeInternalfcp::client::FederatedComputationDefaultTypeInternal103 PROTOBUF_CONSTEXPR FederatedComputationDefaultTypeInternal()
104 : _instance(::_pbi::ConstantInitialized{}) {}
~FederatedComputationDefaultTypeInternalfcp::client::FederatedComputationDefaultTypeInternal105 ~FederatedComputationDefaultTypeInternal() {}
106 union { // NOLINT(misc-non-private-member-variables-in-classes)
107 FederatedComputation _instance;
108 };
109 };
110 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FederatedComputationDefaultTypeInternal _FederatedComputation_default_instance_;
SimpleAggregation(::_pbi::ConstantInitialized)111 PROTOBUF_CONSTEXPR SimpleAggregation::SimpleAggregation(
112 ::_pbi::ConstantInitialized): _impl_{
113 /*decltype(_impl_._cached_size_)*/{}} {}
114 struct SimpleAggregationDefaultTypeInternal {
SimpleAggregationDefaultTypeInternalfcp::client::SimpleAggregationDefaultTypeInternal115 PROTOBUF_CONSTEXPR SimpleAggregationDefaultTypeInternal()
116 : _instance(::_pbi::ConstantInitialized{}) {}
~SimpleAggregationDefaultTypeInternalfcp::client::SimpleAggregationDefaultTypeInternal117 ~SimpleAggregationDefaultTypeInternal() {}
118 union { // NOLINT(misc-non-private-member-variables-in-classes)
119 SimpleAggregation _instance;
120 };
121 };
122 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SimpleAggregationDefaultTypeInternal _SimpleAggregation_default_instance_;
SecureAggregation(::_pbi::ConstantInitialized)123 PROTOBUF_CONSTEXPR SecureAggregation::SecureAggregation(
124 ::_pbi::ConstantInitialized): _impl_{
125 /*decltype(_impl_.minimum_clients_in_server_visible_aggregate_)*/0
126 , /*decltype(_impl_._cached_size_)*/{}} {}
127 struct SecureAggregationDefaultTypeInternal {
SecureAggregationDefaultTypeInternalfcp::client::SecureAggregationDefaultTypeInternal128 PROTOBUF_CONSTEXPR SecureAggregationDefaultTypeInternal()
129 : _instance(::_pbi::ConstantInitialized{}) {}
~SecureAggregationDefaultTypeInternalfcp::client::SecureAggregationDefaultTypeInternal130 ~SecureAggregationDefaultTypeInternal() {}
131 union { // NOLINT(misc-non-private-member-variables-in-classes)
132 SecureAggregation _instance;
133 };
134 };
135 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SecureAggregationDefaultTypeInternal _SecureAggregation_default_instance_;
HistoricalContext(::_pbi::ConstantInitialized)136 PROTOBUF_CONSTEXPR HistoricalContext::HistoricalContext(
137 ::_pbi::ConstantInitialized): _impl_{
138 /*decltype(_impl_.last_successful_contribution_time_)*/nullptr
139 , /*decltype(_impl_._cached_size_)*/{}} {}
140 struct HistoricalContextDefaultTypeInternal {
HistoricalContextDefaultTypeInternalfcp::client::HistoricalContextDefaultTypeInternal141 PROTOBUF_CONSTEXPR HistoricalContextDefaultTypeInternal()
142 : _instance(::_pbi::ConstantInitialized{}) {}
~HistoricalContextDefaultTypeInternalfcp::client::HistoricalContextDefaultTypeInternal143 ~HistoricalContextDefaultTypeInternal() {}
144 union { // NOLINT(misc-non-private-member-variables-in-classes)
145 HistoricalContext _instance;
146 };
147 };
148 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HistoricalContextDefaultTypeInternal _HistoricalContext_default_instance_;
149 } // namespace client
150 } // namespace fcp
151 namespace fcp {
152 namespace client {
QueryTimeComputationProperties_ExampleIteratorOutputFormat_IsValid(int value)153 bool QueryTimeComputationProperties_ExampleIteratorOutputFormat_IsValid(int value) {
154 switch (value) {
155 case 0:
156 case 1:
157 return true;
158 default:
159 return false;
160 }
161 }
162
163 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> QueryTimeComputationProperties_ExampleIteratorOutputFormat_strings[2] = {};
164
165 static const char QueryTimeComputationProperties_ExampleIteratorOutputFormat_names[] =
166 "EXAMPLE_ITERATOR_OUTPUT_FORMAT_UNSPECIFIED"
167 "EXAMPLE_QUERY_RESULT";
168
169 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry QueryTimeComputationProperties_ExampleIteratorOutputFormat_entries[] = {
170 { {QueryTimeComputationProperties_ExampleIteratorOutputFormat_names + 0, 42}, 0 },
171 { {QueryTimeComputationProperties_ExampleIteratorOutputFormat_names + 42, 20}, 1 },
172 };
173
174 static const int QueryTimeComputationProperties_ExampleIteratorOutputFormat_entries_by_number[] = {
175 0, // 0 -> EXAMPLE_ITERATOR_OUTPUT_FORMAT_UNSPECIFIED
176 1, // 1 -> EXAMPLE_QUERY_RESULT
177 };
178
QueryTimeComputationProperties_ExampleIteratorOutputFormat_Name(QueryTimeComputationProperties_ExampleIteratorOutputFormat value)179 const std::string& QueryTimeComputationProperties_ExampleIteratorOutputFormat_Name(
180 QueryTimeComputationProperties_ExampleIteratorOutputFormat value) {
181 static const bool dummy =
182 ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
183 QueryTimeComputationProperties_ExampleIteratorOutputFormat_entries,
184 QueryTimeComputationProperties_ExampleIteratorOutputFormat_entries_by_number,
185 2, QueryTimeComputationProperties_ExampleIteratorOutputFormat_strings);
186 (void) dummy;
187 int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
188 QueryTimeComputationProperties_ExampleIteratorOutputFormat_entries,
189 QueryTimeComputationProperties_ExampleIteratorOutputFormat_entries_by_number,
190 2, value);
191 return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
192 QueryTimeComputationProperties_ExampleIteratorOutputFormat_strings[idx].get();
193 }
QueryTimeComputationProperties_ExampleIteratorOutputFormat_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,QueryTimeComputationProperties_ExampleIteratorOutputFormat * value)194 bool QueryTimeComputationProperties_ExampleIteratorOutputFormat_Parse(
195 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, QueryTimeComputationProperties_ExampleIteratorOutputFormat* value) {
196 int int_value;
197 bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
198 QueryTimeComputationProperties_ExampleIteratorOutputFormat_entries, 2, name, &int_value);
199 if (success) {
200 *value = static_cast<QueryTimeComputationProperties_ExampleIteratorOutputFormat>(int_value);
201 }
202 return success;
203 }
204 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
205 constexpr QueryTimeComputationProperties_ExampleIteratorOutputFormat QueryTimeComputationProperties::EXAMPLE_ITERATOR_OUTPUT_FORMAT_UNSPECIFIED;
206 constexpr QueryTimeComputationProperties_ExampleIteratorOutputFormat QueryTimeComputationProperties::EXAMPLE_QUERY_RESULT;
207 constexpr QueryTimeComputationProperties_ExampleIteratorOutputFormat QueryTimeComputationProperties::ExampleIteratorOutputFormat_MIN;
208 constexpr QueryTimeComputationProperties_ExampleIteratorOutputFormat QueryTimeComputationProperties::ExampleIteratorOutputFormat_MAX;
209 constexpr int QueryTimeComputationProperties::ExampleIteratorOutputFormat_ARRAYSIZE;
210 #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
211
212 // ===================================================================
213
214 class SelectorContext::_Internal {
215 public:
216 static const ::fcp::client::QueryTimeComputationProperties& computation_properties(const SelectorContext* msg);
217 };
218
219 const ::fcp::client::QueryTimeComputationProperties&
computation_properties(const SelectorContext * msg)220 SelectorContext::_Internal::computation_properties(const SelectorContext* msg) {
221 return *msg->_impl_.computation_properties_;
222 }
SelectorContext(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)223 SelectorContext::SelectorContext(::PROTOBUF_NAMESPACE_ID::Arena* arena,
224 bool is_message_owned)
225 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
226 SharedCtor(arena, is_message_owned);
227 // @@protoc_insertion_point(arena_constructor:fcp.client.SelectorContext)
228 }
SelectorContext(const SelectorContext & from)229 SelectorContext::SelectorContext(const SelectorContext& from)
230 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
231 SelectorContext* const _this = this; (void)_this;
232 new (&_impl_) Impl_{
233 decltype(_impl_.computation_properties_){nullptr}
234 , /*decltype(_impl_._cached_size_)*/{}};
235
236 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
237 if (from._internal_has_computation_properties()) {
238 _this->_impl_.computation_properties_ = new ::fcp::client::QueryTimeComputationProperties(*from._impl_.computation_properties_);
239 }
240 // @@protoc_insertion_point(copy_constructor:fcp.client.SelectorContext)
241 }
242
SharedCtor(::_pb::Arena * arena,bool is_message_owned)243 inline void SelectorContext::SharedCtor(
244 ::_pb::Arena* arena, bool is_message_owned) {
245 (void)arena;
246 (void)is_message_owned;
247 new (&_impl_) Impl_{
248 decltype(_impl_.computation_properties_){nullptr}
249 , /*decltype(_impl_._cached_size_)*/{}
250 };
251 }
252
~SelectorContext()253 SelectorContext::~SelectorContext() {
254 // @@protoc_insertion_point(destructor:fcp.client.SelectorContext)
255 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
256 (void)arena;
257 return;
258 }
259 SharedDtor();
260 }
261
SharedDtor()262 inline void SelectorContext::SharedDtor() {
263 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
264 if (this != internal_default_instance()) delete _impl_.computation_properties_;
265 }
266
SetCachedSize(int size) const267 void SelectorContext::SetCachedSize(int size) const {
268 _impl_._cached_size_.Set(size);
269 }
270
Clear()271 void SelectorContext::Clear() {
272 // @@protoc_insertion_point(message_clear_start:fcp.client.SelectorContext)
273 ::uint32_t cached_has_bits = 0;
274 // Prevent compiler warnings about cached_has_bits being unused
275 (void) cached_has_bits;
276
277 if (GetArenaForAllocation() == nullptr && _impl_.computation_properties_ != nullptr) {
278 delete _impl_.computation_properties_;
279 }
280 _impl_.computation_properties_ = nullptr;
281 _internal_metadata_.Clear<std::string>();
282 }
283
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)284 const char* SelectorContext::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
285 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
286 while (!ctx->Done(&ptr)) {
287 ::uint32_t tag;
288 ptr = ::_pbi::ReadTag(ptr, &tag);
289 switch (tag >> 3) {
290 // .fcp.client.QueryTimeComputationProperties computation_properties = 1;
291 case 1:
292 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
293 ptr = ctx->ParseMessage(_internal_mutable_computation_properties(), ptr);
294 CHK_(ptr);
295 } else {
296 goto handle_unusual;
297 }
298 continue;
299 default:
300 goto handle_unusual;
301 } // switch
302 handle_unusual:
303 if ((tag == 0) || ((tag & 7) == 4)) {
304 CHK_(ptr);
305 ctx->SetLastTag(tag);
306 goto message_done;
307 }
308 ptr = UnknownFieldParse(
309 tag,
310 _internal_metadata_.mutable_unknown_fields<std::string>(),
311 ptr, ctx);
312 CHK_(ptr != nullptr);
313 } // while
314 message_done:
315 return ptr;
316 failure:
317 ptr = nullptr;
318 goto message_done;
319 #undef CHK_
320 }
321
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const322 ::uint8_t* SelectorContext::_InternalSerialize(
323 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
324 // @@protoc_insertion_point(serialize_to_array_start:fcp.client.SelectorContext)
325 ::uint32_t cached_has_bits = 0;
326 (void) cached_has_bits;
327
328 // .fcp.client.QueryTimeComputationProperties computation_properties = 1;
329 if (this->_internal_has_computation_properties()) {
330 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
331 InternalWriteMessage(1, _Internal::computation_properties(this),
332 _Internal::computation_properties(this).GetCachedSize(), target, stream);
333 }
334
335 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
336 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
337 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
338 }
339 // @@protoc_insertion_point(serialize_to_array_end:fcp.client.SelectorContext)
340 return target;
341 }
342
ByteSizeLong() const343 size_t SelectorContext::ByteSizeLong() const {
344 // @@protoc_insertion_point(message_byte_size_start:fcp.client.SelectorContext)
345 size_t total_size = 0;
346
347 ::uint32_t cached_has_bits = 0;
348 // Prevent compiler warnings about cached_has_bits being unused
349 (void) cached_has_bits;
350
351 // .fcp.client.QueryTimeComputationProperties computation_properties = 1;
352 if (this->_internal_has_computation_properties()) {
353 total_size += 1 +
354 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
355 *_impl_.computation_properties_);
356 }
357
358 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
359 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
360 }
361 int cached_size = ::_pbi::ToCachedSize(total_size);
362 SetCachedSize(cached_size);
363 return total_size;
364 }
365
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)366 void SelectorContext::CheckTypeAndMergeFrom(
367 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
368 MergeFrom(*::_pbi::DownCast<const SelectorContext*>(
369 &from));
370 }
371
MergeFrom(const SelectorContext & from)372 void SelectorContext::MergeFrom(const SelectorContext& from) {
373 SelectorContext* const _this = this;
374 // @@protoc_insertion_point(class_specific_merge_from_start:fcp.client.SelectorContext)
375 GOOGLE_DCHECK_NE(&from, _this);
376 ::uint32_t cached_has_bits = 0;
377 (void) cached_has_bits;
378
379 if (from._internal_has_computation_properties()) {
380 _this->_internal_mutable_computation_properties()->::fcp::client::QueryTimeComputationProperties::MergeFrom(
381 from._internal_computation_properties());
382 }
383 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
384 }
385
CopyFrom(const SelectorContext & from)386 void SelectorContext::CopyFrom(const SelectorContext& from) {
387 // @@protoc_insertion_point(class_specific_copy_from_start:fcp.client.SelectorContext)
388 if (&from == this) return;
389 Clear();
390 MergeFrom(from);
391 }
392
IsInitialized() const393 bool SelectorContext::IsInitialized() const {
394 return true;
395 }
396
InternalSwap(SelectorContext * other)397 void SelectorContext::InternalSwap(SelectorContext* other) {
398 using std::swap;
399 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
400 swap(_impl_.computation_properties_, other->_impl_.computation_properties_);
401 }
402
GetTypeName() const403 std::string SelectorContext::GetTypeName() const {
404 return "fcp.client.SelectorContext";
405 }
406
407
408 // ===================================================================
409
410 class QueryTimeComputationProperties::_Internal {
411 public:
412 static const ::fcp::client::LocalComputation& local_compute(const QueryTimeComputationProperties* msg);
413 static const ::fcp::client::EligibilityEvalComputation& eligibility_eval(const QueryTimeComputationProperties* msg);
414 static const ::fcp::client::FederatedComputation& federated(const QueryTimeComputationProperties* msg);
415 };
416
417 const ::fcp::client::LocalComputation&
local_compute(const QueryTimeComputationProperties * msg)418 QueryTimeComputationProperties::_Internal::local_compute(const QueryTimeComputationProperties* msg) {
419 return *msg->_impl_.computation_type_.local_compute_;
420 }
421 const ::fcp::client::EligibilityEvalComputation&
eligibility_eval(const QueryTimeComputationProperties * msg)422 QueryTimeComputationProperties::_Internal::eligibility_eval(const QueryTimeComputationProperties* msg) {
423 return *msg->_impl_.computation_type_.eligibility_eval_;
424 }
425 const ::fcp::client::FederatedComputation&
federated(const QueryTimeComputationProperties * msg)426 QueryTimeComputationProperties::_Internal::federated(const QueryTimeComputationProperties* msg) {
427 return *msg->_impl_.computation_type_.federated_;
428 }
set_allocated_local_compute(::fcp::client::LocalComputation * local_compute)429 void QueryTimeComputationProperties::set_allocated_local_compute(::fcp::client::LocalComputation* local_compute) {
430 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
431 clear_computation_type();
432 if (local_compute) {
433 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
434 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(local_compute);
435 if (message_arena != submessage_arena) {
436 local_compute = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
437 message_arena, local_compute, submessage_arena);
438 }
439 set_has_local_compute();
440 _impl_.computation_type_.local_compute_ = local_compute;
441 }
442 // @@protoc_insertion_point(field_set_allocated:fcp.client.QueryTimeComputationProperties.local_compute)
443 }
set_allocated_eligibility_eval(::fcp::client::EligibilityEvalComputation * eligibility_eval)444 void QueryTimeComputationProperties::set_allocated_eligibility_eval(::fcp::client::EligibilityEvalComputation* eligibility_eval) {
445 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
446 clear_computation_type();
447 if (eligibility_eval) {
448 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
449 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(eligibility_eval);
450 if (message_arena != submessage_arena) {
451 eligibility_eval = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
452 message_arena, eligibility_eval, submessage_arena);
453 }
454 set_has_eligibility_eval();
455 _impl_.computation_type_.eligibility_eval_ = eligibility_eval;
456 }
457 // @@protoc_insertion_point(field_set_allocated:fcp.client.QueryTimeComputationProperties.eligibility_eval)
458 }
set_allocated_federated(::fcp::client::FederatedComputation * federated)459 void QueryTimeComputationProperties::set_allocated_federated(::fcp::client::FederatedComputation* federated) {
460 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
461 clear_computation_type();
462 if (federated) {
463 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
464 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(federated);
465 if (message_arena != submessage_arena) {
466 federated = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
467 message_arena, federated, submessage_arena);
468 }
469 set_has_federated();
470 _impl_.computation_type_.federated_ = federated;
471 }
472 // @@protoc_insertion_point(field_set_allocated:fcp.client.QueryTimeComputationProperties.federated)
473 }
QueryTimeComputationProperties(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)474 QueryTimeComputationProperties::QueryTimeComputationProperties(::PROTOBUF_NAMESPACE_ID::Arena* arena,
475 bool is_message_owned)
476 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
477 SharedCtor(arena, is_message_owned);
478 // @@protoc_insertion_point(arena_constructor:fcp.client.QueryTimeComputationProperties)
479 }
QueryTimeComputationProperties(const QueryTimeComputationProperties & from)480 QueryTimeComputationProperties::QueryTimeComputationProperties(const QueryTimeComputationProperties& from)
481 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
482 QueryTimeComputationProperties* const _this = this; (void)_this;
483 new (&_impl_) Impl_{
484 decltype(_impl_.session_name_){}
485 , decltype(_impl_.context_data_){}
486 , decltype(_impl_.run_id_){}
487 , decltype(_impl_.example_iterator_output_format_){}
488 , decltype(_impl_.computation_type_){}
489 , /*decltype(_impl_._cached_size_)*/{}
490 , /*decltype(_impl_._oneof_case_)*/{}};
491
492 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
493 _impl_.session_name_.InitDefault();
494 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
495 _impl_.session_name_.Set("", GetArenaForAllocation());
496 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
497 if (!from._internal_session_name().empty()) {
498 _this->_impl_.session_name_.Set(from._internal_session_name(),
499 _this->GetArenaForAllocation());
500 }
501 _impl_.context_data_.InitDefault();
502 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
503 _impl_.context_data_.Set("", GetArenaForAllocation());
504 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
505 if (!from._internal_context_data().empty()) {
506 _this->_impl_.context_data_.Set(from._internal_context_data(),
507 _this->GetArenaForAllocation());
508 }
509 ::memcpy(&_impl_.run_id_, &from._impl_.run_id_,
510 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.example_iterator_output_format_) -
511 reinterpret_cast<char*>(&_impl_.run_id_)) + sizeof(_impl_.example_iterator_output_format_));
512 clear_has_computation_type();
513 switch (from.computation_type_case()) {
514 case kLocalCompute: {
515 _this->_internal_mutable_local_compute()->::fcp::client::LocalComputation::MergeFrom(
516 from._internal_local_compute());
517 break;
518 }
519 case kEligibilityEval: {
520 _this->_internal_mutable_eligibility_eval()->::fcp::client::EligibilityEvalComputation::MergeFrom(
521 from._internal_eligibility_eval());
522 break;
523 }
524 case kFederated: {
525 _this->_internal_mutable_federated()->::fcp::client::FederatedComputation::MergeFrom(
526 from._internal_federated());
527 break;
528 }
529 case COMPUTATION_TYPE_NOT_SET: {
530 break;
531 }
532 }
533 // @@protoc_insertion_point(copy_constructor:fcp.client.QueryTimeComputationProperties)
534 }
535
SharedCtor(::_pb::Arena * arena,bool is_message_owned)536 inline void QueryTimeComputationProperties::SharedCtor(
537 ::_pb::Arena* arena, bool is_message_owned) {
538 (void)arena;
539 (void)is_message_owned;
540 new (&_impl_) Impl_{
541 decltype(_impl_.session_name_){}
542 , decltype(_impl_.context_data_){}
543 , decltype(_impl_.run_id_){::int64_t{0}}
544 , decltype(_impl_.example_iterator_output_format_){0}
545 , decltype(_impl_.computation_type_){}
546 , /*decltype(_impl_._cached_size_)*/{}
547 , /*decltype(_impl_._oneof_case_)*/{}
548 };
549 _impl_.session_name_.InitDefault();
550 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
551 _impl_.session_name_.Set("", GetArenaForAllocation());
552 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
553 _impl_.context_data_.InitDefault();
554 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
555 _impl_.context_data_.Set("", GetArenaForAllocation());
556 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
557 clear_has_computation_type();
558 }
559
~QueryTimeComputationProperties()560 QueryTimeComputationProperties::~QueryTimeComputationProperties() {
561 // @@protoc_insertion_point(destructor:fcp.client.QueryTimeComputationProperties)
562 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
563 (void)arena;
564 return;
565 }
566 SharedDtor();
567 }
568
SharedDtor()569 inline void QueryTimeComputationProperties::SharedDtor() {
570 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
571 _impl_.session_name_.Destroy();
572 _impl_.context_data_.Destroy();
573 if (has_computation_type()) {
574 clear_computation_type();
575 }
576 }
577
SetCachedSize(int size) const578 void QueryTimeComputationProperties::SetCachedSize(int size) const {
579 _impl_._cached_size_.Set(size);
580 }
581
clear_computation_type()582 void QueryTimeComputationProperties::clear_computation_type() {
583 // @@protoc_insertion_point(one_of_clear_start:fcp.client.QueryTimeComputationProperties)
584 switch (computation_type_case()) {
585 case kLocalCompute: {
586 if (GetArenaForAllocation() == nullptr) {
587 delete _impl_.computation_type_.local_compute_;
588 }
589 break;
590 }
591 case kEligibilityEval: {
592 if (GetArenaForAllocation() == nullptr) {
593 delete _impl_.computation_type_.eligibility_eval_;
594 }
595 break;
596 }
597 case kFederated: {
598 if (GetArenaForAllocation() == nullptr) {
599 delete _impl_.computation_type_.federated_;
600 }
601 break;
602 }
603 case COMPUTATION_TYPE_NOT_SET: {
604 break;
605 }
606 }
607 _impl_._oneof_case_[0] = COMPUTATION_TYPE_NOT_SET;
608 }
609
610
Clear()611 void QueryTimeComputationProperties::Clear() {
612 // @@protoc_insertion_point(message_clear_start:fcp.client.QueryTimeComputationProperties)
613 ::uint32_t cached_has_bits = 0;
614 // Prevent compiler warnings about cached_has_bits being unused
615 (void) cached_has_bits;
616
617 _impl_.session_name_.ClearToEmpty();
618 _impl_.context_data_.ClearToEmpty();
619 ::memset(&_impl_.run_id_, 0, static_cast<size_t>(
620 reinterpret_cast<char*>(&_impl_.example_iterator_output_format_) -
621 reinterpret_cast<char*>(&_impl_.run_id_)) + sizeof(_impl_.example_iterator_output_format_));
622 clear_computation_type();
623 _internal_metadata_.Clear<std::string>();
624 }
625
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)626 const char* QueryTimeComputationProperties::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
627 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
628 while (!ctx->Done(&ptr)) {
629 ::uint32_t tag;
630 ptr = ::_pbi::ReadTag(ptr, &tag);
631 switch (tag >> 3) {
632 // string session_name = 1;
633 case 1:
634 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
635 auto str = _internal_mutable_session_name();
636 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
637 CHK_(ptr);
638 CHK_(::_pbi::VerifyUTF8(str, nullptr));
639 } else {
640 goto handle_unusual;
641 }
642 continue;
643 // .fcp.client.LocalComputation local_compute = 2;
644 case 2:
645 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
646 ptr = ctx->ParseMessage(_internal_mutable_local_compute(), ptr);
647 CHK_(ptr);
648 } else {
649 goto handle_unusual;
650 }
651 continue;
652 // .fcp.client.EligibilityEvalComputation eligibility_eval = 3;
653 case 3:
654 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
655 ptr = ctx->ParseMessage(_internal_mutable_eligibility_eval(), ptr);
656 CHK_(ptr);
657 } else {
658 goto handle_unusual;
659 }
660 continue;
661 // .fcp.client.FederatedComputation federated = 4;
662 case 4:
663 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
664 ptr = ctx->ParseMessage(_internal_mutable_federated(), ptr);
665 CHK_(ptr);
666 } else {
667 goto handle_unusual;
668 }
669 continue;
670 // int64 run_id = 5;
671 case 5:
672 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
673 _impl_.run_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
674 CHK_(ptr);
675 } else {
676 goto handle_unusual;
677 }
678 continue;
679 // bytes context_data = 6;
680 case 6:
681 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
682 auto str = _internal_mutable_context_data();
683 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
684 CHK_(ptr);
685 } else {
686 goto handle_unusual;
687 }
688 continue;
689 // .fcp.client.QueryTimeComputationProperties.ExampleIteratorOutputFormat example_iterator_output_format = 7;
690 case 7:
691 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
692 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
693 CHK_(ptr);
694 _internal_set_example_iterator_output_format(static_cast<::fcp::client::QueryTimeComputationProperties_ExampleIteratorOutputFormat>(val));
695 } else {
696 goto handle_unusual;
697 }
698 continue;
699 default:
700 goto handle_unusual;
701 } // switch
702 handle_unusual:
703 if ((tag == 0) || ((tag & 7) == 4)) {
704 CHK_(ptr);
705 ctx->SetLastTag(tag);
706 goto message_done;
707 }
708 ptr = UnknownFieldParse(
709 tag,
710 _internal_metadata_.mutable_unknown_fields<std::string>(),
711 ptr, ctx);
712 CHK_(ptr != nullptr);
713 } // while
714 message_done:
715 return ptr;
716 failure:
717 ptr = nullptr;
718 goto message_done;
719 #undef CHK_
720 }
721
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const722 ::uint8_t* QueryTimeComputationProperties::_InternalSerialize(
723 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
724 // @@protoc_insertion_point(serialize_to_array_start:fcp.client.QueryTimeComputationProperties)
725 ::uint32_t cached_has_bits = 0;
726 (void) cached_has_bits;
727
728 // string session_name = 1;
729 if (!this->_internal_session_name().empty()) {
730 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
731 this->_internal_session_name().data(), static_cast<int>(this->_internal_session_name().length()),
732 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
733 "fcp.client.QueryTimeComputationProperties.session_name");
734 target = stream->WriteStringMaybeAliased(
735 1, this->_internal_session_name(), target);
736 }
737
738 // .fcp.client.LocalComputation local_compute = 2;
739 if (_internal_has_local_compute()) {
740 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
741 InternalWriteMessage(2, _Internal::local_compute(this),
742 _Internal::local_compute(this).GetCachedSize(), target, stream);
743 }
744
745 // .fcp.client.EligibilityEvalComputation eligibility_eval = 3;
746 if (_internal_has_eligibility_eval()) {
747 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
748 InternalWriteMessage(3, _Internal::eligibility_eval(this),
749 _Internal::eligibility_eval(this).GetCachedSize(), target, stream);
750 }
751
752 // .fcp.client.FederatedComputation federated = 4;
753 if (_internal_has_federated()) {
754 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
755 InternalWriteMessage(4, _Internal::federated(this),
756 _Internal::federated(this).GetCachedSize(), target, stream);
757 }
758
759 // int64 run_id = 5;
760 if (this->_internal_run_id() != 0) {
761 target = stream->EnsureSpace(target);
762 target = ::_pbi::WireFormatLite::WriteInt64ToArray(5, this->_internal_run_id(), target);
763 }
764
765 // bytes context_data = 6;
766 if (!this->_internal_context_data().empty()) {
767 target = stream->WriteBytesMaybeAliased(
768 6, this->_internal_context_data(), target);
769 }
770
771 // .fcp.client.QueryTimeComputationProperties.ExampleIteratorOutputFormat example_iterator_output_format = 7;
772 if (this->_internal_example_iterator_output_format() != 0) {
773 target = stream->EnsureSpace(target);
774 target = ::_pbi::WireFormatLite::WriteEnumToArray(
775 7, this->_internal_example_iterator_output_format(), target);
776 }
777
778 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
779 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
780 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
781 }
782 // @@protoc_insertion_point(serialize_to_array_end:fcp.client.QueryTimeComputationProperties)
783 return target;
784 }
785
ByteSizeLong() const786 size_t QueryTimeComputationProperties::ByteSizeLong() const {
787 // @@protoc_insertion_point(message_byte_size_start:fcp.client.QueryTimeComputationProperties)
788 size_t total_size = 0;
789
790 ::uint32_t cached_has_bits = 0;
791 // Prevent compiler warnings about cached_has_bits being unused
792 (void) cached_has_bits;
793
794 // string session_name = 1;
795 if (!this->_internal_session_name().empty()) {
796 total_size += 1 +
797 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
798 this->_internal_session_name());
799 }
800
801 // bytes context_data = 6;
802 if (!this->_internal_context_data().empty()) {
803 total_size += 1 +
804 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
805 this->_internal_context_data());
806 }
807
808 // int64 run_id = 5;
809 if (this->_internal_run_id() != 0) {
810 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_run_id());
811 }
812
813 // .fcp.client.QueryTimeComputationProperties.ExampleIteratorOutputFormat example_iterator_output_format = 7;
814 if (this->_internal_example_iterator_output_format() != 0) {
815 total_size += 1 +
816 ::_pbi::WireFormatLite::EnumSize(this->_internal_example_iterator_output_format());
817 }
818
819 switch (computation_type_case()) {
820 // .fcp.client.LocalComputation local_compute = 2;
821 case kLocalCompute: {
822 total_size += 1 +
823 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
824 *_impl_.computation_type_.local_compute_);
825 break;
826 }
827 // .fcp.client.EligibilityEvalComputation eligibility_eval = 3;
828 case kEligibilityEval: {
829 total_size += 1 +
830 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
831 *_impl_.computation_type_.eligibility_eval_);
832 break;
833 }
834 // .fcp.client.FederatedComputation federated = 4;
835 case kFederated: {
836 total_size += 1 +
837 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
838 *_impl_.computation_type_.federated_);
839 break;
840 }
841 case COMPUTATION_TYPE_NOT_SET: {
842 break;
843 }
844 }
845 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
846 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
847 }
848 int cached_size = ::_pbi::ToCachedSize(total_size);
849 SetCachedSize(cached_size);
850 return total_size;
851 }
852
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)853 void QueryTimeComputationProperties::CheckTypeAndMergeFrom(
854 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
855 MergeFrom(*::_pbi::DownCast<const QueryTimeComputationProperties*>(
856 &from));
857 }
858
MergeFrom(const QueryTimeComputationProperties & from)859 void QueryTimeComputationProperties::MergeFrom(const QueryTimeComputationProperties& from) {
860 QueryTimeComputationProperties* const _this = this;
861 // @@protoc_insertion_point(class_specific_merge_from_start:fcp.client.QueryTimeComputationProperties)
862 GOOGLE_DCHECK_NE(&from, _this);
863 ::uint32_t cached_has_bits = 0;
864 (void) cached_has_bits;
865
866 if (!from._internal_session_name().empty()) {
867 _this->_internal_set_session_name(from._internal_session_name());
868 }
869 if (!from._internal_context_data().empty()) {
870 _this->_internal_set_context_data(from._internal_context_data());
871 }
872 if (from._internal_run_id() != 0) {
873 _this->_internal_set_run_id(from._internal_run_id());
874 }
875 if (from._internal_example_iterator_output_format() != 0) {
876 _this->_internal_set_example_iterator_output_format(from._internal_example_iterator_output_format());
877 }
878 switch (from.computation_type_case()) {
879 case kLocalCompute: {
880 _this->_internal_mutable_local_compute()->::fcp::client::LocalComputation::MergeFrom(
881 from._internal_local_compute());
882 break;
883 }
884 case kEligibilityEval: {
885 _this->_internal_mutable_eligibility_eval()->::fcp::client::EligibilityEvalComputation::MergeFrom(
886 from._internal_eligibility_eval());
887 break;
888 }
889 case kFederated: {
890 _this->_internal_mutable_federated()->::fcp::client::FederatedComputation::MergeFrom(
891 from._internal_federated());
892 break;
893 }
894 case COMPUTATION_TYPE_NOT_SET: {
895 break;
896 }
897 }
898 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
899 }
900
CopyFrom(const QueryTimeComputationProperties & from)901 void QueryTimeComputationProperties::CopyFrom(const QueryTimeComputationProperties& from) {
902 // @@protoc_insertion_point(class_specific_copy_from_start:fcp.client.QueryTimeComputationProperties)
903 if (&from == this) return;
904 Clear();
905 MergeFrom(from);
906 }
907
IsInitialized() const908 bool QueryTimeComputationProperties::IsInitialized() const {
909 return true;
910 }
911
InternalSwap(QueryTimeComputationProperties * other)912 void QueryTimeComputationProperties::InternalSwap(QueryTimeComputationProperties* other) {
913 using std::swap;
914 auto* lhs_arena = GetArenaForAllocation();
915 auto* rhs_arena = other->GetArenaForAllocation();
916 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
917 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
918 &_impl_.session_name_, lhs_arena,
919 &other->_impl_.session_name_, rhs_arena
920 );
921 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
922 &_impl_.context_data_, lhs_arena,
923 &other->_impl_.context_data_, rhs_arena
924 );
925 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
926 PROTOBUF_FIELD_OFFSET(QueryTimeComputationProperties, _impl_.example_iterator_output_format_)
927 + sizeof(QueryTimeComputationProperties::_impl_.example_iterator_output_format_) // NOLINT
928 - PROTOBUF_FIELD_OFFSET(QueryTimeComputationProperties, _impl_.run_id_)>(
929 reinterpret_cast<char*>(&_impl_.run_id_),
930 reinterpret_cast<char*>(&other->_impl_.run_id_));
931 swap(_impl_.computation_type_, other->_impl_.computation_type_);
932 swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
933 }
934
GetTypeName() const935 std::string QueryTimeComputationProperties::GetTypeName() const {
936 return "fcp.client.QueryTimeComputationProperties";
937 }
938
939
940 // ===================================================================
941
LocalComputation_InputResourceMapEntry_DoNotUse()942 LocalComputation_InputResourceMapEntry_DoNotUse::LocalComputation_InputResourceMapEntry_DoNotUse() {}
LocalComputation_InputResourceMapEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena * arena)943 LocalComputation_InputResourceMapEntry_DoNotUse::LocalComputation_InputResourceMapEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
944 : SuperType(arena) {}
MergeFrom(const LocalComputation_InputResourceMapEntry_DoNotUse & other)945 void LocalComputation_InputResourceMapEntry_DoNotUse::MergeFrom(const LocalComputation_InputResourceMapEntry_DoNotUse& other) {
946 MergeFromInternal(other);
947 }
948
949 // ===================================================================
950
951 class LocalComputation::_Internal {
952 public:
953 };
954
LocalComputation(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)955 LocalComputation::LocalComputation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
956 bool is_message_owned)
957 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
958 SharedCtor(arena, is_message_owned);
959 // @@protoc_insertion_point(arena_constructor:fcp.client.LocalComputation)
960 }
LocalComputation(const LocalComputation & from)961 LocalComputation::LocalComputation(const LocalComputation& from)
962 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
963 LocalComputation* const _this = this; (void)_this;
964 new (&_impl_) Impl_{
965 /*decltype(_impl_.input_resource_map_)*/{}
966 , decltype(_impl_.input_dir_){}
967 , decltype(_impl_.output_dir_){}
968 , /*decltype(_impl_._cached_size_)*/{}};
969
970 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
971 _this->_impl_.input_resource_map_.MergeFrom(from._impl_.input_resource_map_);
972 _impl_.input_dir_.InitDefault();
973 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
974 _impl_.input_dir_.Set("", GetArenaForAllocation());
975 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
976 if (!from._internal_input_dir().empty()) {
977 _this->_impl_.input_dir_.Set(from._internal_input_dir(),
978 _this->GetArenaForAllocation());
979 }
980 _impl_.output_dir_.InitDefault();
981 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
982 _impl_.output_dir_.Set("", GetArenaForAllocation());
983 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
984 if (!from._internal_output_dir().empty()) {
985 _this->_impl_.output_dir_.Set(from._internal_output_dir(),
986 _this->GetArenaForAllocation());
987 }
988 // @@protoc_insertion_point(copy_constructor:fcp.client.LocalComputation)
989 }
990
SharedCtor(::_pb::Arena * arena,bool is_message_owned)991 inline void LocalComputation::SharedCtor(
992 ::_pb::Arena* arena, bool is_message_owned) {
993 (void)arena;
994 (void)is_message_owned;
995 new (&_impl_) Impl_{
996 /*decltype(_impl_.input_resource_map_)*/{::_pbi::ArenaInitialized(), arena}
997 , decltype(_impl_.input_dir_){}
998 , decltype(_impl_.output_dir_){}
999 , /*decltype(_impl_._cached_size_)*/{}
1000 };
1001 _impl_.input_dir_.InitDefault();
1002 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1003 _impl_.input_dir_.Set("", GetArenaForAllocation());
1004 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1005 _impl_.output_dir_.InitDefault();
1006 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1007 _impl_.output_dir_.Set("", GetArenaForAllocation());
1008 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1009 }
1010
~LocalComputation()1011 LocalComputation::~LocalComputation() {
1012 // @@protoc_insertion_point(destructor:fcp.client.LocalComputation)
1013 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1014 (void)arena;
1015 return;
1016 }
1017 SharedDtor();
1018 }
1019
SharedDtor()1020 inline void LocalComputation::SharedDtor() {
1021 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1022 _impl_.input_resource_map_.Destruct();
1023 _impl_.input_resource_map_.~MapFieldLite();
1024 _impl_.input_dir_.Destroy();
1025 _impl_.output_dir_.Destroy();
1026 }
1027
SetCachedSize(int size) const1028 void LocalComputation::SetCachedSize(int size) const {
1029 _impl_._cached_size_.Set(size);
1030 }
1031
Clear()1032 void LocalComputation::Clear() {
1033 // @@protoc_insertion_point(message_clear_start:fcp.client.LocalComputation)
1034 ::uint32_t cached_has_bits = 0;
1035 // Prevent compiler warnings about cached_has_bits being unused
1036 (void) cached_has_bits;
1037
1038 _impl_.input_resource_map_.Clear();
1039 _impl_.input_dir_.ClearToEmpty();
1040 _impl_.output_dir_.ClearToEmpty();
1041 _internal_metadata_.Clear<std::string>();
1042 }
1043
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1044 const char* LocalComputation::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1045 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1046 while (!ctx->Done(&ptr)) {
1047 ::uint32_t tag;
1048 ptr = ::_pbi::ReadTag(ptr, &tag);
1049 switch (tag >> 3) {
1050 // string input_dir = 1;
1051 case 1:
1052 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1053 auto str = _internal_mutable_input_dir();
1054 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1055 CHK_(ptr);
1056 CHK_(::_pbi::VerifyUTF8(str, nullptr));
1057 } else {
1058 goto handle_unusual;
1059 }
1060 continue;
1061 // string output_dir = 2;
1062 case 2:
1063 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1064 auto str = _internal_mutable_output_dir();
1065 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1066 CHK_(ptr);
1067 CHK_(::_pbi::VerifyUTF8(str, nullptr));
1068 } else {
1069 goto handle_unusual;
1070 }
1071 continue;
1072 // map<string, string> input_resource_map = 3;
1073 case 3:
1074 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
1075 ptr -= 1;
1076 do {
1077 ptr += 1;
1078 ptr = ctx->ParseMessage(&_impl_.input_resource_map_, ptr);
1079 CHK_(ptr);
1080 if (!ctx->DataAvailable(ptr)) break;
1081 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
1082 } else {
1083 goto handle_unusual;
1084 }
1085 continue;
1086 default:
1087 goto handle_unusual;
1088 } // switch
1089 handle_unusual:
1090 if ((tag == 0) || ((tag & 7) == 4)) {
1091 CHK_(ptr);
1092 ctx->SetLastTag(tag);
1093 goto message_done;
1094 }
1095 ptr = UnknownFieldParse(
1096 tag,
1097 _internal_metadata_.mutable_unknown_fields<std::string>(),
1098 ptr, ctx);
1099 CHK_(ptr != nullptr);
1100 } // while
1101 message_done:
1102 return ptr;
1103 failure:
1104 ptr = nullptr;
1105 goto message_done;
1106 #undef CHK_
1107 }
1108
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1109 ::uint8_t* LocalComputation::_InternalSerialize(
1110 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1111 // @@protoc_insertion_point(serialize_to_array_start:fcp.client.LocalComputation)
1112 ::uint32_t cached_has_bits = 0;
1113 (void) cached_has_bits;
1114
1115 // string input_dir = 1;
1116 if (!this->_internal_input_dir().empty()) {
1117 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1118 this->_internal_input_dir().data(), static_cast<int>(this->_internal_input_dir().length()),
1119 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1120 "fcp.client.LocalComputation.input_dir");
1121 target = stream->WriteStringMaybeAliased(
1122 1, this->_internal_input_dir(), target);
1123 }
1124
1125 // string output_dir = 2;
1126 if (!this->_internal_output_dir().empty()) {
1127 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1128 this->_internal_output_dir().data(), static_cast<int>(this->_internal_output_dir().length()),
1129 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1130 "fcp.client.LocalComputation.output_dir");
1131 target = stream->WriteStringMaybeAliased(
1132 2, this->_internal_output_dir(), target);
1133 }
1134
1135 // map<string, string> input_resource_map = 3;
1136 if (!this->_internal_input_resource_map().empty()) {
1137 using MapType = ::_pb::Map<std::string, std::string>;
1138 using WireHelper = LocalComputation_InputResourceMapEntry_DoNotUse::Funcs;
1139 const auto& map_field = this->_internal_input_resource_map();
1140 auto check_utf8 = [](const MapType::value_type& entry) {
1141 (void)entry;
1142 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1143 entry.first.data(), static_cast<int>(entry.first.length()),
1144 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1145 "fcp.client.LocalComputation.InputResourceMapEntry.key");
1146 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1147 entry.second.data(), static_cast<int>(entry.second.length()),
1148 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1149 "fcp.client.LocalComputation.InputResourceMapEntry.value");
1150 };
1151
1152 if (stream->IsSerializationDeterministic() && map_field.size() > 1) {
1153 for (const auto& entry : ::_pbi::MapSorterPtr<MapType>(map_field)) {
1154 target = WireHelper::InternalSerialize(3, entry.first, entry.second, target, stream);
1155 check_utf8(entry);
1156 }
1157 } else {
1158 for (const auto& entry : map_field) {
1159 target = WireHelper::InternalSerialize(3, entry.first, entry.second, target, stream);
1160 check_utf8(entry);
1161 }
1162 }
1163 }
1164
1165 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1166 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1167 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1168 }
1169 // @@protoc_insertion_point(serialize_to_array_end:fcp.client.LocalComputation)
1170 return target;
1171 }
1172
ByteSizeLong() const1173 size_t LocalComputation::ByteSizeLong() const {
1174 // @@protoc_insertion_point(message_byte_size_start:fcp.client.LocalComputation)
1175 size_t total_size = 0;
1176
1177 ::uint32_t cached_has_bits = 0;
1178 // Prevent compiler warnings about cached_has_bits being unused
1179 (void) cached_has_bits;
1180
1181 // map<string, string> input_resource_map = 3;
1182 total_size += 1 *
1183 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_input_resource_map_size());
1184 for (::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::const_iterator
1185 it = this->_internal_input_resource_map().begin();
1186 it != this->_internal_input_resource_map().end(); ++it) {
1187 total_size += LocalComputation_InputResourceMapEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
1188 }
1189
1190 // string input_dir = 1;
1191 if (!this->_internal_input_dir().empty()) {
1192 total_size += 1 +
1193 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1194 this->_internal_input_dir());
1195 }
1196
1197 // string output_dir = 2;
1198 if (!this->_internal_output_dir().empty()) {
1199 total_size += 1 +
1200 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1201 this->_internal_output_dir());
1202 }
1203
1204 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1205 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1206 }
1207 int cached_size = ::_pbi::ToCachedSize(total_size);
1208 SetCachedSize(cached_size);
1209 return total_size;
1210 }
1211
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1212 void LocalComputation::CheckTypeAndMergeFrom(
1213 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1214 MergeFrom(*::_pbi::DownCast<const LocalComputation*>(
1215 &from));
1216 }
1217
MergeFrom(const LocalComputation & from)1218 void LocalComputation::MergeFrom(const LocalComputation& from) {
1219 LocalComputation* const _this = this;
1220 // @@protoc_insertion_point(class_specific_merge_from_start:fcp.client.LocalComputation)
1221 GOOGLE_DCHECK_NE(&from, _this);
1222 ::uint32_t cached_has_bits = 0;
1223 (void) cached_has_bits;
1224
1225 _this->_impl_.input_resource_map_.MergeFrom(from._impl_.input_resource_map_);
1226 if (!from._internal_input_dir().empty()) {
1227 _this->_internal_set_input_dir(from._internal_input_dir());
1228 }
1229 if (!from._internal_output_dir().empty()) {
1230 _this->_internal_set_output_dir(from._internal_output_dir());
1231 }
1232 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1233 }
1234
CopyFrom(const LocalComputation & from)1235 void LocalComputation::CopyFrom(const LocalComputation& from) {
1236 // @@protoc_insertion_point(class_specific_copy_from_start:fcp.client.LocalComputation)
1237 if (&from == this) return;
1238 Clear();
1239 MergeFrom(from);
1240 }
1241
IsInitialized() const1242 bool LocalComputation::IsInitialized() const {
1243 return true;
1244 }
1245
InternalSwap(LocalComputation * other)1246 void LocalComputation::InternalSwap(LocalComputation* other) {
1247 using std::swap;
1248 auto* lhs_arena = GetArenaForAllocation();
1249 auto* rhs_arena = other->GetArenaForAllocation();
1250 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1251 _impl_.input_resource_map_.InternalSwap(&other->_impl_.input_resource_map_);
1252 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1253 &_impl_.input_dir_, lhs_arena,
1254 &other->_impl_.input_dir_, rhs_arena
1255 );
1256 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1257 &_impl_.output_dir_, lhs_arena,
1258 &other->_impl_.output_dir_, rhs_arena
1259 );
1260 }
1261
GetTypeName() const1262 std::string LocalComputation::GetTypeName() const {
1263 return "fcp.client.LocalComputation";
1264 }
1265
1266
1267 // ===================================================================
1268
1269 class EligibilityEvalComputation::_Internal {
1270 public:
1271 };
1272
EligibilityEvalComputation(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1273 EligibilityEvalComputation::EligibilityEvalComputation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1274 bool is_message_owned)
1275 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1276 SharedCtor(arena, is_message_owned);
1277 // @@protoc_insertion_point(arena_constructor:fcp.client.EligibilityEvalComputation)
1278 }
EligibilityEvalComputation(const EligibilityEvalComputation & from)1279 EligibilityEvalComputation::EligibilityEvalComputation(const EligibilityEvalComputation& from)
1280 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1281 EligibilityEvalComputation* const _this = this; (void)_this;
1282 new (&_impl_) Impl_{
1283 decltype(_impl_.population_name_){}
1284 , /*decltype(_impl_._cached_size_)*/{}};
1285
1286 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1287 _impl_.population_name_.InitDefault();
1288 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1289 _impl_.population_name_.Set("", GetArenaForAllocation());
1290 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1291 if (!from._internal_population_name().empty()) {
1292 _this->_impl_.population_name_.Set(from._internal_population_name(),
1293 _this->GetArenaForAllocation());
1294 }
1295 // @@protoc_insertion_point(copy_constructor:fcp.client.EligibilityEvalComputation)
1296 }
1297
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1298 inline void EligibilityEvalComputation::SharedCtor(
1299 ::_pb::Arena* arena, bool is_message_owned) {
1300 (void)arena;
1301 (void)is_message_owned;
1302 new (&_impl_) Impl_{
1303 decltype(_impl_.population_name_){}
1304 , /*decltype(_impl_._cached_size_)*/{}
1305 };
1306 _impl_.population_name_.InitDefault();
1307 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1308 _impl_.population_name_.Set("", GetArenaForAllocation());
1309 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1310 }
1311
~EligibilityEvalComputation()1312 EligibilityEvalComputation::~EligibilityEvalComputation() {
1313 // @@protoc_insertion_point(destructor:fcp.client.EligibilityEvalComputation)
1314 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1315 (void)arena;
1316 return;
1317 }
1318 SharedDtor();
1319 }
1320
SharedDtor()1321 inline void EligibilityEvalComputation::SharedDtor() {
1322 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1323 _impl_.population_name_.Destroy();
1324 }
1325
SetCachedSize(int size) const1326 void EligibilityEvalComputation::SetCachedSize(int size) const {
1327 _impl_._cached_size_.Set(size);
1328 }
1329
Clear()1330 void EligibilityEvalComputation::Clear() {
1331 // @@protoc_insertion_point(message_clear_start:fcp.client.EligibilityEvalComputation)
1332 ::uint32_t cached_has_bits = 0;
1333 // Prevent compiler warnings about cached_has_bits being unused
1334 (void) cached_has_bits;
1335
1336 _impl_.population_name_.ClearToEmpty();
1337 _internal_metadata_.Clear<std::string>();
1338 }
1339
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1340 const char* EligibilityEvalComputation::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1341 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1342 while (!ctx->Done(&ptr)) {
1343 ::uint32_t tag;
1344 ptr = ::_pbi::ReadTag(ptr, &tag);
1345 switch (tag >> 3) {
1346 // string population_name = 1;
1347 case 1:
1348 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1349 auto str = _internal_mutable_population_name();
1350 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1351 CHK_(ptr);
1352 CHK_(::_pbi::VerifyUTF8(str, nullptr));
1353 } else {
1354 goto handle_unusual;
1355 }
1356 continue;
1357 default:
1358 goto handle_unusual;
1359 } // switch
1360 handle_unusual:
1361 if ((tag == 0) || ((tag & 7) == 4)) {
1362 CHK_(ptr);
1363 ctx->SetLastTag(tag);
1364 goto message_done;
1365 }
1366 ptr = UnknownFieldParse(
1367 tag,
1368 _internal_metadata_.mutable_unknown_fields<std::string>(),
1369 ptr, ctx);
1370 CHK_(ptr != nullptr);
1371 } // while
1372 message_done:
1373 return ptr;
1374 failure:
1375 ptr = nullptr;
1376 goto message_done;
1377 #undef CHK_
1378 }
1379
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1380 ::uint8_t* EligibilityEvalComputation::_InternalSerialize(
1381 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1382 // @@protoc_insertion_point(serialize_to_array_start:fcp.client.EligibilityEvalComputation)
1383 ::uint32_t cached_has_bits = 0;
1384 (void) cached_has_bits;
1385
1386 // string population_name = 1;
1387 if (!this->_internal_population_name().empty()) {
1388 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1389 this->_internal_population_name().data(), static_cast<int>(this->_internal_population_name().length()),
1390 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1391 "fcp.client.EligibilityEvalComputation.population_name");
1392 target = stream->WriteStringMaybeAliased(
1393 1, this->_internal_population_name(), target);
1394 }
1395
1396 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1397 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1398 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1399 }
1400 // @@protoc_insertion_point(serialize_to_array_end:fcp.client.EligibilityEvalComputation)
1401 return target;
1402 }
1403
ByteSizeLong() const1404 size_t EligibilityEvalComputation::ByteSizeLong() const {
1405 // @@protoc_insertion_point(message_byte_size_start:fcp.client.EligibilityEvalComputation)
1406 size_t total_size = 0;
1407
1408 ::uint32_t cached_has_bits = 0;
1409 // Prevent compiler warnings about cached_has_bits being unused
1410 (void) cached_has_bits;
1411
1412 // string population_name = 1;
1413 if (!this->_internal_population_name().empty()) {
1414 total_size += 1 +
1415 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1416 this->_internal_population_name());
1417 }
1418
1419 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1420 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1421 }
1422 int cached_size = ::_pbi::ToCachedSize(total_size);
1423 SetCachedSize(cached_size);
1424 return total_size;
1425 }
1426
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1427 void EligibilityEvalComputation::CheckTypeAndMergeFrom(
1428 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1429 MergeFrom(*::_pbi::DownCast<const EligibilityEvalComputation*>(
1430 &from));
1431 }
1432
MergeFrom(const EligibilityEvalComputation & from)1433 void EligibilityEvalComputation::MergeFrom(const EligibilityEvalComputation& from) {
1434 EligibilityEvalComputation* const _this = this;
1435 // @@protoc_insertion_point(class_specific_merge_from_start:fcp.client.EligibilityEvalComputation)
1436 GOOGLE_DCHECK_NE(&from, _this);
1437 ::uint32_t cached_has_bits = 0;
1438 (void) cached_has_bits;
1439
1440 if (!from._internal_population_name().empty()) {
1441 _this->_internal_set_population_name(from._internal_population_name());
1442 }
1443 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1444 }
1445
CopyFrom(const EligibilityEvalComputation & from)1446 void EligibilityEvalComputation::CopyFrom(const EligibilityEvalComputation& from) {
1447 // @@protoc_insertion_point(class_specific_copy_from_start:fcp.client.EligibilityEvalComputation)
1448 if (&from == this) return;
1449 Clear();
1450 MergeFrom(from);
1451 }
1452
IsInitialized() const1453 bool EligibilityEvalComputation::IsInitialized() const {
1454 return true;
1455 }
1456
InternalSwap(EligibilityEvalComputation * other)1457 void EligibilityEvalComputation::InternalSwap(EligibilityEvalComputation* other) {
1458 using std::swap;
1459 auto* lhs_arena = GetArenaForAllocation();
1460 auto* rhs_arena = other->GetArenaForAllocation();
1461 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1462 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1463 &_impl_.population_name_, lhs_arena,
1464 &other->_impl_.population_name_, rhs_arena
1465 );
1466 }
1467
GetTypeName() const1468 std::string EligibilityEvalComputation::GetTypeName() const {
1469 return "fcp.client.EligibilityEvalComputation";
1470 }
1471
1472
1473 // ===================================================================
1474
1475 class FederatedComputation::_Internal {
1476 public:
1477 static const ::fcp::client::HistoricalContext& historical_context(const FederatedComputation* msg);
1478 static const ::fcp::client::SimpleAggregation& simple_aggregation(const FederatedComputation* msg);
1479 static const ::fcp::client::SecureAggregation& secure_aggregation(const FederatedComputation* msg);
1480 };
1481
1482 const ::fcp::client::HistoricalContext&
historical_context(const FederatedComputation * msg)1483 FederatedComputation::_Internal::historical_context(const FederatedComputation* msg) {
1484 return *msg->_impl_.historical_context_;
1485 }
1486 const ::fcp::client::SimpleAggregation&
simple_aggregation(const FederatedComputation * msg)1487 FederatedComputation::_Internal::simple_aggregation(const FederatedComputation* msg) {
1488 return *msg->_impl_.aggregation_type_.simple_aggregation_;
1489 }
1490 const ::fcp::client::SecureAggregation&
secure_aggregation(const FederatedComputation * msg)1491 FederatedComputation::_Internal::secure_aggregation(const FederatedComputation* msg) {
1492 return *msg->_impl_.aggregation_type_.secure_aggregation_;
1493 }
set_allocated_simple_aggregation(::fcp::client::SimpleAggregation * simple_aggregation)1494 void FederatedComputation::set_allocated_simple_aggregation(::fcp::client::SimpleAggregation* simple_aggregation) {
1495 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
1496 clear_aggregation_type();
1497 if (simple_aggregation) {
1498 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1499 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(simple_aggregation);
1500 if (message_arena != submessage_arena) {
1501 simple_aggregation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1502 message_arena, simple_aggregation, submessage_arena);
1503 }
1504 set_has_simple_aggregation();
1505 _impl_.aggregation_type_.simple_aggregation_ = simple_aggregation;
1506 }
1507 // @@protoc_insertion_point(field_set_allocated:fcp.client.FederatedComputation.simple_aggregation)
1508 }
set_allocated_secure_aggregation(::fcp::client::SecureAggregation * secure_aggregation)1509 void FederatedComputation::set_allocated_secure_aggregation(::fcp::client::SecureAggregation* secure_aggregation) {
1510 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
1511 clear_aggregation_type();
1512 if (secure_aggregation) {
1513 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1514 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(secure_aggregation);
1515 if (message_arena != submessage_arena) {
1516 secure_aggregation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1517 message_arena, secure_aggregation, submessage_arena);
1518 }
1519 set_has_secure_aggregation();
1520 _impl_.aggregation_type_.secure_aggregation_ = secure_aggregation;
1521 }
1522 // @@protoc_insertion_point(field_set_allocated:fcp.client.FederatedComputation.secure_aggregation)
1523 }
FederatedComputation(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1524 FederatedComputation::FederatedComputation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1525 bool is_message_owned)
1526 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1527 SharedCtor(arena, is_message_owned);
1528 // @@protoc_insertion_point(arena_constructor:fcp.client.FederatedComputation)
1529 }
FederatedComputation(const FederatedComputation & from)1530 FederatedComputation::FederatedComputation(const FederatedComputation& from)
1531 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1532 FederatedComputation* const _this = this; (void)_this;
1533 new (&_impl_) Impl_{
1534 decltype(_impl_.population_name_){}
1535 , decltype(_impl_.task_name_){}
1536 , decltype(_impl_.computation_id_){}
1537 , decltype(_impl_.historical_context_){nullptr}
1538 , decltype(_impl_.aggregation_type_){}
1539 , /*decltype(_impl_._cached_size_)*/{}
1540 , /*decltype(_impl_._oneof_case_)*/{}};
1541
1542 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1543 _impl_.population_name_.InitDefault();
1544 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1545 _impl_.population_name_.Set("", GetArenaForAllocation());
1546 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1547 if (!from._internal_population_name().empty()) {
1548 _this->_impl_.population_name_.Set(from._internal_population_name(),
1549 _this->GetArenaForAllocation());
1550 }
1551 _impl_.task_name_.InitDefault();
1552 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1553 _impl_.task_name_.Set("", GetArenaForAllocation());
1554 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1555 if (!from._internal_task_name().empty()) {
1556 _this->_impl_.task_name_.Set(from._internal_task_name(),
1557 _this->GetArenaForAllocation());
1558 }
1559 _impl_.computation_id_.InitDefault();
1560 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1561 _impl_.computation_id_.Set("", GetArenaForAllocation());
1562 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1563 if (!from._internal_computation_id().empty()) {
1564 _this->_impl_.computation_id_.Set(from._internal_computation_id(),
1565 _this->GetArenaForAllocation());
1566 }
1567 if (from._internal_has_historical_context()) {
1568 _this->_impl_.historical_context_ = new ::fcp::client::HistoricalContext(*from._impl_.historical_context_);
1569 }
1570 clear_has_aggregation_type();
1571 switch (from.aggregation_type_case()) {
1572 case kSimpleAggregation: {
1573 _this->_internal_mutable_simple_aggregation()->::fcp::client::SimpleAggregation::MergeFrom(
1574 from._internal_simple_aggregation());
1575 break;
1576 }
1577 case kSecureAggregation: {
1578 _this->_internal_mutable_secure_aggregation()->::fcp::client::SecureAggregation::MergeFrom(
1579 from._internal_secure_aggregation());
1580 break;
1581 }
1582 case AGGREGATION_TYPE_NOT_SET: {
1583 break;
1584 }
1585 }
1586 // @@protoc_insertion_point(copy_constructor:fcp.client.FederatedComputation)
1587 }
1588
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1589 inline void FederatedComputation::SharedCtor(
1590 ::_pb::Arena* arena, bool is_message_owned) {
1591 (void)arena;
1592 (void)is_message_owned;
1593 new (&_impl_) Impl_{
1594 decltype(_impl_.population_name_){}
1595 , decltype(_impl_.task_name_){}
1596 , decltype(_impl_.computation_id_){}
1597 , decltype(_impl_.historical_context_){nullptr}
1598 , decltype(_impl_.aggregation_type_){}
1599 , /*decltype(_impl_._cached_size_)*/{}
1600 , /*decltype(_impl_._oneof_case_)*/{}
1601 };
1602 _impl_.population_name_.InitDefault();
1603 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1604 _impl_.population_name_.Set("", GetArenaForAllocation());
1605 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1606 _impl_.task_name_.InitDefault();
1607 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1608 _impl_.task_name_.Set("", GetArenaForAllocation());
1609 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1610 _impl_.computation_id_.InitDefault();
1611 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1612 _impl_.computation_id_.Set("", GetArenaForAllocation());
1613 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1614 clear_has_aggregation_type();
1615 }
1616
~FederatedComputation()1617 FederatedComputation::~FederatedComputation() {
1618 // @@protoc_insertion_point(destructor:fcp.client.FederatedComputation)
1619 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1620 (void)arena;
1621 return;
1622 }
1623 SharedDtor();
1624 }
1625
SharedDtor()1626 inline void FederatedComputation::SharedDtor() {
1627 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1628 _impl_.population_name_.Destroy();
1629 _impl_.task_name_.Destroy();
1630 _impl_.computation_id_.Destroy();
1631 if (this != internal_default_instance()) delete _impl_.historical_context_;
1632 if (has_aggregation_type()) {
1633 clear_aggregation_type();
1634 }
1635 }
1636
SetCachedSize(int size) const1637 void FederatedComputation::SetCachedSize(int size) const {
1638 _impl_._cached_size_.Set(size);
1639 }
1640
clear_aggregation_type()1641 void FederatedComputation::clear_aggregation_type() {
1642 // @@protoc_insertion_point(one_of_clear_start:fcp.client.FederatedComputation)
1643 switch (aggregation_type_case()) {
1644 case kSimpleAggregation: {
1645 if (GetArenaForAllocation() == nullptr) {
1646 delete _impl_.aggregation_type_.simple_aggregation_;
1647 }
1648 break;
1649 }
1650 case kSecureAggregation: {
1651 if (GetArenaForAllocation() == nullptr) {
1652 delete _impl_.aggregation_type_.secure_aggregation_;
1653 }
1654 break;
1655 }
1656 case AGGREGATION_TYPE_NOT_SET: {
1657 break;
1658 }
1659 }
1660 _impl_._oneof_case_[0] = AGGREGATION_TYPE_NOT_SET;
1661 }
1662
1663
Clear()1664 void FederatedComputation::Clear() {
1665 // @@protoc_insertion_point(message_clear_start:fcp.client.FederatedComputation)
1666 ::uint32_t cached_has_bits = 0;
1667 // Prevent compiler warnings about cached_has_bits being unused
1668 (void) cached_has_bits;
1669
1670 _impl_.population_name_.ClearToEmpty();
1671 _impl_.task_name_.ClearToEmpty();
1672 _impl_.computation_id_.ClearToEmpty();
1673 if (GetArenaForAllocation() == nullptr && _impl_.historical_context_ != nullptr) {
1674 delete _impl_.historical_context_;
1675 }
1676 _impl_.historical_context_ = nullptr;
1677 clear_aggregation_type();
1678 _internal_metadata_.Clear<std::string>();
1679 }
1680
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1681 const char* FederatedComputation::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1682 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1683 while (!ctx->Done(&ptr)) {
1684 ::uint32_t tag;
1685 ptr = ::_pbi::ReadTag(ptr, &tag);
1686 switch (tag >> 3) {
1687 // string population_name = 1;
1688 case 1:
1689 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1690 auto str = _internal_mutable_population_name();
1691 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1692 CHK_(ptr);
1693 CHK_(::_pbi::VerifyUTF8(str, nullptr));
1694 } else {
1695 goto handle_unusual;
1696 }
1697 continue;
1698 // string task_name = 2;
1699 case 2:
1700 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1701 auto str = _internal_mutable_task_name();
1702 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1703 CHK_(ptr);
1704 CHK_(::_pbi::VerifyUTF8(str, nullptr));
1705 } else {
1706 goto handle_unusual;
1707 }
1708 continue;
1709 // .fcp.client.SimpleAggregation simple_aggregation = 3;
1710 case 3:
1711 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
1712 ptr = ctx->ParseMessage(_internal_mutable_simple_aggregation(), ptr);
1713 CHK_(ptr);
1714 } else {
1715 goto handle_unusual;
1716 }
1717 continue;
1718 // .fcp.client.SecureAggregation secure_aggregation = 4;
1719 case 4:
1720 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
1721 ptr = ctx->ParseMessage(_internal_mutable_secure_aggregation(), ptr);
1722 CHK_(ptr);
1723 } else {
1724 goto handle_unusual;
1725 }
1726 continue;
1727 // bytes computation_id = 5;
1728 case 5:
1729 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
1730 auto str = _internal_mutable_computation_id();
1731 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1732 CHK_(ptr);
1733 } else {
1734 goto handle_unusual;
1735 }
1736 continue;
1737 // .fcp.client.HistoricalContext historical_context = 6;
1738 case 6:
1739 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
1740 ptr = ctx->ParseMessage(_internal_mutable_historical_context(), ptr);
1741 CHK_(ptr);
1742 } else {
1743 goto handle_unusual;
1744 }
1745 continue;
1746 default:
1747 goto handle_unusual;
1748 } // switch
1749 handle_unusual:
1750 if ((tag == 0) || ((tag & 7) == 4)) {
1751 CHK_(ptr);
1752 ctx->SetLastTag(tag);
1753 goto message_done;
1754 }
1755 ptr = UnknownFieldParse(
1756 tag,
1757 _internal_metadata_.mutable_unknown_fields<std::string>(),
1758 ptr, ctx);
1759 CHK_(ptr != nullptr);
1760 } // while
1761 message_done:
1762 return ptr;
1763 failure:
1764 ptr = nullptr;
1765 goto message_done;
1766 #undef CHK_
1767 }
1768
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1769 ::uint8_t* FederatedComputation::_InternalSerialize(
1770 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1771 // @@protoc_insertion_point(serialize_to_array_start:fcp.client.FederatedComputation)
1772 ::uint32_t cached_has_bits = 0;
1773 (void) cached_has_bits;
1774
1775 // string population_name = 1;
1776 if (!this->_internal_population_name().empty()) {
1777 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1778 this->_internal_population_name().data(), static_cast<int>(this->_internal_population_name().length()),
1779 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1780 "fcp.client.FederatedComputation.population_name");
1781 target = stream->WriteStringMaybeAliased(
1782 1, this->_internal_population_name(), target);
1783 }
1784
1785 // string task_name = 2;
1786 if (!this->_internal_task_name().empty()) {
1787 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1788 this->_internal_task_name().data(), static_cast<int>(this->_internal_task_name().length()),
1789 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1790 "fcp.client.FederatedComputation.task_name");
1791 target = stream->WriteStringMaybeAliased(
1792 2, this->_internal_task_name(), target);
1793 }
1794
1795 // .fcp.client.SimpleAggregation simple_aggregation = 3;
1796 if (_internal_has_simple_aggregation()) {
1797 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1798 InternalWriteMessage(3, _Internal::simple_aggregation(this),
1799 _Internal::simple_aggregation(this).GetCachedSize(), target, stream);
1800 }
1801
1802 // .fcp.client.SecureAggregation secure_aggregation = 4;
1803 if (_internal_has_secure_aggregation()) {
1804 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1805 InternalWriteMessage(4, _Internal::secure_aggregation(this),
1806 _Internal::secure_aggregation(this).GetCachedSize(), target, stream);
1807 }
1808
1809 // bytes computation_id = 5;
1810 if (!this->_internal_computation_id().empty()) {
1811 target = stream->WriteBytesMaybeAliased(
1812 5, this->_internal_computation_id(), target);
1813 }
1814
1815 // .fcp.client.HistoricalContext historical_context = 6;
1816 if (this->_internal_has_historical_context()) {
1817 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1818 InternalWriteMessage(6, _Internal::historical_context(this),
1819 _Internal::historical_context(this).GetCachedSize(), target, stream);
1820 }
1821
1822 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1823 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1824 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1825 }
1826 // @@protoc_insertion_point(serialize_to_array_end:fcp.client.FederatedComputation)
1827 return target;
1828 }
1829
ByteSizeLong() const1830 size_t FederatedComputation::ByteSizeLong() const {
1831 // @@protoc_insertion_point(message_byte_size_start:fcp.client.FederatedComputation)
1832 size_t total_size = 0;
1833
1834 ::uint32_t cached_has_bits = 0;
1835 // Prevent compiler warnings about cached_has_bits being unused
1836 (void) cached_has_bits;
1837
1838 // string population_name = 1;
1839 if (!this->_internal_population_name().empty()) {
1840 total_size += 1 +
1841 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1842 this->_internal_population_name());
1843 }
1844
1845 // string task_name = 2;
1846 if (!this->_internal_task_name().empty()) {
1847 total_size += 1 +
1848 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1849 this->_internal_task_name());
1850 }
1851
1852 // bytes computation_id = 5;
1853 if (!this->_internal_computation_id().empty()) {
1854 total_size += 1 +
1855 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
1856 this->_internal_computation_id());
1857 }
1858
1859 // .fcp.client.HistoricalContext historical_context = 6;
1860 if (this->_internal_has_historical_context()) {
1861 total_size += 1 +
1862 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1863 *_impl_.historical_context_);
1864 }
1865
1866 switch (aggregation_type_case()) {
1867 // .fcp.client.SimpleAggregation simple_aggregation = 3;
1868 case kSimpleAggregation: {
1869 total_size += 1 +
1870 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1871 *_impl_.aggregation_type_.simple_aggregation_);
1872 break;
1873 }
1874 // .fcp.client.SecureAggregation secure_aggregation = 4;
1875 case kSecureAggregation: {
1876 total_size += 1 +
1877 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1878 *_impl_.aggregation_type_.secure_aggregation_);
1879 break;
1880 }
1881 case AGGREGATION_TYPE_NOT_SET: {
1882 break;
1883 }
1884 }
1885 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1886 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1887 }
1888 int cached_size = ::_pbi::ToCachedSize(total_size);
1889 SetCachedSize(cached_size);
1890 return total_size;
1891 }
1892
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1893 void FederatedComputation::CheckTypeAndMergeFrom(
1894 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1895 MergeFrom(*::_pbi::DownCast<const FederatedComputation*>(
1896 &from));
1897 }
1898
MergeFrom(const FederatedComputation & from)1899 void FederatedComputation::MergeFrom(const FederatedComputation& from) {
1900 FederatedComputation* const _this = this;
1901 // @@protoc_insertion_point(class_specific_merge_from_start:fcp.client.FederatedComputation)
1902 GOOGLE_DCHECK_NE(&from, _this);
1903 ::uint32_t cached_has_bits = 0;
1904 (void) cached_has_bits;
1905
1906 if (!from._internal_population_name().empty()) {
1907 _this->_internal_set_population_name(from._internal_population_name());
1908 }
1909 if (!from._internal_task_name().empty()) {
1910 _this->_internal_set_task_name(from._internal_task_name());
1911 }
1912 if (!from._internal_computation_id().empty()) {
1913 _this->_internal_set_computation_id(from._internal_computation_id());
1914 }
1915 if (from._internal_has_historical_context()) {
1916 _this->_internal_mutable_historical_context()->::fcp::client::HistoricalContext::MergeFrom(
1917 from._internal_historical_context());
1918 }
1919 switch (from.aggregation_type_case()) {
1920 case kSimpleAggregation: {
1921 _this->_internal_mutable_simple_aggregation()->::fcp::client::SimpleAggregation::MergeFrom(
1922 from._internal_simple_aggregation());
1923 break;
1924 }
1925 case kSecureAggregation: {
1926 _this->_internal_mutable_secure_aggregation()->::fcp::client::SecureAggregation::MergeFrom(
1927 from._internal_secure_aggregation());
1928 break;
1929 }
1930 case AGGREGATION_TYPE_NOT_SET: {
1931 break;
1932 }
1933 }
1934 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1935 }
1936
CopyFrom(const FederatedComputation & from)1937 void FederatedComputation::CopyFrom(const FederatedComputation& from) {
1938 // @@protoc_insertion_point(class_specific_copy_from_start:fcp.client.FederatedComputation)
1939 if (&from == this) return;
1940 Clear();
1941 MergeFrom(from);
1942 }
1943
IsInitialized() const1944 bool FederatedComputation::IsInitialized() const {
1945 return true;
1946 }
1947
InternalSwap(FederatedComputation * other)1948 void FederatedComputation::InternalSwap(FederatedComputation* other) {
1949 using std::swap;
1950 auto* lhs_arena = GetArenaForAllocation();
1951 auto* rhs_arena = other->GetArenaForAllocation();
1952 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1953 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1954 &_impl_.population_name_, lhs_arena,
1955 &other->_impl_.population_name_, rhs_arena
1956 );
1957 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1958 &_impl_.task_name_, lhs_arena,
1959 &other->_impl_.task_name_, rhs_arena
1960 );
1961 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1962 &_impl_.computation_id_, lhs_arena,
1963 &other->_impl_.computation_id_, rhs_arena
1964 );
1965 swap(_impl_.historical_context_, other->_impl_.historical_context_);
1966 swap(_impl_.aggregation_type_, other->_impl_.aggregation_type_);
1967 swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
1968 }
1969
GetTypeName() const1970 std::string FederatedComputation::GetTypeName() const {
1971 return "fcp.client.FederatedComputation";
1972 }
1973
1974
1975 // ===================================================================
1976
1977 class SimpleAggregation::_Internal {
1978 public:
1979 };
1980
SimpleAggregation(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1981 SimpleAggregation::SimpleAggregation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1982 bool is_message_owned)
1983 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1984 SharedCtor(arena, is_message_owned);
1985 // @@protoc_insertion_point(arena_constructor:fcp.client.SimpleAggregation)
1986 }
SimpleAggregation(const SimpleAggregation & from)1987 SimpleAggregation::SimpleAggregation(const SimpleAggregation& from)
1988 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1989 SimpleAggregation* const _this = this; (void)_this;
1990 new (&_impl_) Impl_{
1991 /*decltype(_impl_._cached_size_)*/{}};
1992
1993 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1994 // @@protoc_insertion_point(copy_constructor:fcp.client.SimpleAggregation)
1995 }
1996
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1997 inline void SimpleAggregation::SharedCtor(
1998 ::_pb::Arena* arena, bool is_message_owned) {
1999 (void)arena;
2000 (void)is_message_owned;
2001 new (&_impl_) Impl_{
2002 /*decltype(_impl_._cached_size_)*/{}
2003 };
2004 }
2005
~SimpleAggregation()2006 SimpleAggregation::~SimpleAggregation() {
2007 // @@protoc_insertion_point(destructor:fcp.client.SimpleAggregation)
2008 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2009 (void)arena;
2010 return;
2011 }
2012 SharedDtor();
2013 }
2014
SharedDtor()2015 inline void SimpleAggregation::SharedDtor() {
2016 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2017 }
2018
SetCachedSize(int size) const2019 void SimpleAggregation::SetCachedSize(int size) const {
2020 _impl_._cached_size_.Set(size);
2021 }
2022
Clear()2023 void SimpleAggregation::Clear() {
2024 // @@protoc_insertion_point(message_clear_start:fcp.client.SimpleAggregation)
2025 ::uint32_t cached_has_bits = 0;
2026 // Prevent compiler warnings about cached_has_bits being unused
2027 (void) cached_has_bits;
2028
2029 _internal_metadata_.Clear<std::string>();
2030 }
2031
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2032 const char* SimpleAggregation::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2033 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2034 while (!ctx->Done(&ptr)) {
2035 ::uint32_t tag;
2036 ptr = ::_pbi::ReadTag(ptr, &tag);
2037 if ((tag == 0) || ((tag & 7) == 4)) {
2038 CHK_(ptr);
2039 ctx->SetLastTag(tag);
2040 goto message_done;
2041 }
2042 ptr = UnknownFieldParse(
2043 tag,
2044 _internal_metadata_.mutable_unknown_fields<std::string>(),
2045 ptr, ctx);
2046 CHK_(ptr != nullptr);
2047 } // while
2048 message_done:
2049 return ptr;
2050 failure:
2051 ptr = nullptr;
2052 goto message_done;
2053 #undef CHK_
2054 }
2055
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2056 ::uint8_t* SimpleAggregation::_InternalSerialize(
2057 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2058 // @@protoc_insertion_point(serialize_to_array_start:fcp.client.SimpleAggregation)
2059 ::uint32_t cached_has_bits = 0;
2060 (void) cached_has_bits;
2061
2062 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2063 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2064 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2065 }
2066 // @@protoc_insertion_point(serialize_to_array_end:fcp.client.SimpleAggregation)
2067 return target;
2068 }
2069
ByteSizeLong() const2070 size_t SimpleAggregation::ByteSizeLong() const {
2071 // @@protoc_insertion_point(message_byte_size_start:fcp.client.SimpleAggregation)
2072 size_t total_size = 0;
2073
2074 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2075 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2076 }
2077 int cached_size = ::_pbi::ToCachedSize(total_size);
2078 SetCachedSize(cached_size);
2079 return total_size;
2080 }
2081
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2082 void SimpleAggregation::CheckTypeAndMergeFrom(
2083 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2084 MergeFrom(*::_pbi::DownCast<const SimpleAggregation*>(
2085 &from));
2086 }
2087
MergeFrom(const SimpleAggregation & from)2088 void SimpleAggregation::MergeFrom(const SimpleAggregation& from) {
2089 SimpleAggregation* const _this = this;
2090 // @@protoc_insertion_point(class_specific_merge_from_start:fcp.client.SimpleAggregation)
2091 GOOGLE_DCHECK_NE(&from, _this);
2092 ::uint32_t cached_has_bits = 0;
2093 (void) cached_has_bits;
2094
2095 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2096 }
2097
CopyFrom(const SimpleAggregation & from)2098 void SimpleAggregation::CopyFrom(const SimpleAggregation& from) {
2099 // @@protoc_insertion_point(class_specific_copy_from_start:fcp.client.SimpleAggregation)
2100 if (&from == this) return;
2101 Clear();
2102 MergeFrom(from);
2103 }
2104
IsInitialized() const2105 bool SimpleAggregation::IsInitialized() const {
2106 return true;
2107 }
2108
InternalSwap(SimpleAggregation * other)2109 void SimpleAggregation::InternalSwap(SimpleAggregation* other) {
2110 using std::swap;
2111 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2112 }
2113
GetTypeName() const2114 std::string SimpleAggregation::GetTypeName() const {
2115 return "fcp.client.SimpleAggregation";
2116 }
2117
2118
2119 // ===================================================================
2120
2121 class SecureAggregation::_Internal {
2122 public:
2123 };
2124
SecureAggregation(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2125 SecureAggregation::SecureAggregation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2126 bool is_message_owned)
2127 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2128 SharedCtor(arena, is_message_owned);
2129 // @@protoc_insertion_point(arena_constructor:fcp.client.SecureAggregation)
2130 }
SecureAggregation(const SecureAggregation & from)2131 SecureAggregation::SecureAggregation(const SecureAggregation& from)
2132 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2133 SecureAggregation* const _this = this; (void)_this;
2134 new (&_impl_) Impl_{
2135 decltype(_impl_.minimum_clients_in_server_visible_aggregate_){}
2136 , /*decltype(_impl_._cached_size_)*/{}};
2137
2138 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2139 _this->_impl_.minimum_clients_in_server_visible_aggregate_ = from._impl_.minimum_clients_in_server_visible_aggregate_;
2140 // @@protoc_insertion_point(copy_constructor:fcp.client.SecureAggregation)
2141 }
2142
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2143 inline void SecureAggregation::SharedCtor(
2144 ::_pb::Arena* arena, bool is_message_owned) {
2145 (void)arena;
2146 (void)is_message_owned;
2147 new (&_impl_) Impl_{
2148 decltype(_impl_.minimum_clients_in_server_visible_aggregate_){0}
2149 , /*decltype(_impl_._cached_size_)*/{}
2150 };
2151 }
2152
~SecureAggregation()2153 SecureAggregation::~SecureAggregation() {
2154 // @@protoc_insertion_point(destructor:fcp.client.SecureAggregation)
2155 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2156 (void)arena;
2157 return;
2158 }
2159 SharedDtor();
2160 }
2161
SharedDtor()2162 inline void SecureAggregation::SharedDtor() {
2163 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2164 }
2165
SetCachedSize(int size) const2166 void SecureAggregation::SetCachedSize(int size) const {
2167 _impl_._cached_size_.Set(size);
2168 }
2169
Clear()2170 void SecureAggregation::Clear() {
2171 // @@protoc_insertion_point(message_clear_start:fcp.client.SecureAggregation)
2172 ::uint32_t cached_has_bits = 0;
2173 // Prevent compiler warnings about cached_has_bits being unused
2174 (void) cached_has_bits;
2175
2176 _impl_.minimum_clients_in_server_visible_aggregate_ = 0;
2177 _internal_metadata_.Clear<std::string>();
2178 }
2179
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2180 const char* SecureAggregation::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2181 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2182 while (!ctx->Done(&ptr)) {
2183 ::uint32_t tag;
2184 ptr = ::_pbi::ReadTag(ptr, &tag);
2185 switch (tag >> 3) {
2186 // int32 minimum_clients_in_server_visible_aggregate = 1;
2187 case 1:
2188 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2189 _impl_.minimum_clients_in_server_visible_aggregate_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2190 CHK_(ptr);
2191 } else {
2192 goto handle_unusual;
2193 }
2194 continue;
2195 default:
2196 goto handle_unusual;
2197 } // switch
2198 handle_unusual:
2199 if ((tag == 0) || ((tag & 7) == 4)) {
2200 CHK_(ptr);
2201 ctx->SetLastTag(tag);
2202 goto message_done;
2203 }
2204 ptr = UnknownFieldParse(
2205 tag,
2206 _internal_metadata_.mutable_unknown_fields<std::string>(),
2207 ptr, ctx);
2208 CHK_(ptr != nullptr);
2209 } // while
2210 message_done:
2211 return ptr;
2212 failure:
2213 ptr = nullptr;
2214 goto message_done;
2215 #undef CHK_
2216 }
2217
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2218 ::uint8_t* SecureAggregation::_InternalSerialize(
2219 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2220 // @@protoc_insertion_point(serialize_to_array_start:fcp.client.SecureAggregation)
2221 ::uint32_t cached_has_bits = 0;
2222 (void) cached_has_bits;
2223
2224 // int32 minimum_clients_in_server_visible_aggregate = 1;
2225 if (this->_internal_minimum_clients_in_server_visible_aggregate() != 0) {
2226 target = stream->EnsureSpace(target);
2227 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_minimum_clients_in_server_visible_aggregate(), target);
2228 }
2229
2230 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2231 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2232 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2233 }
2234 // @@protoc_insertion_point(serialize_to_array_end:fcp.client.SecureAggregation)
2235 return target;
2236 }
2237
ByteSizeLong() const2238 size_t SecureAggregation::ByteSizeLong() const {
2239 // @@protoc_insertion_point(message_byte_size_start:fcp.client.SecureAggregation)
2240 size_t total_size = 0;
2241
2242 ::uint32_t cached_has_bits = 0;
2243 // Prevent compiler warnings about cached_has_bits being unused
2244 (void) cached_has_bits;
2245
2246 // int32 minimum_clients_in_server_visible_aggregate = 1;
2247 if (this->_internal_minimum_clients_in_server_visible_aggregate() != 0) {
2248 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_minimum_clients_in_server_visible_aggregate());
2249 }
2250
2251 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2252 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2253 }
2254 int cached_size = ::_pbi::ToCachedSize(total_size);
2255 SetCachedSize(cached_size);
2256 return total_size;
2257 }
2258
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2259 void SecureAggregation::CheckTypeAndMergeFrom(
2260 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2261 MergeFrom(*::_pbi::DownCast<const SecureAggregation*>(
2262 &from));
2263 }
2264
MergeFrom(const SecureAggregation & from)2265 void SecureAggregation::MergeFrom(const SecureAggregation& from) {
2266 SecureAggregation* const _this = this;
2267 // @@protoc_insertion_point(class_specific_merge_from_start:fcp.client.SecureAggregation)
2268 GOOGLE_DCHECK_NE(&from, _this);
2269 ::uint32_t cached_has_bits = 0;
2270 (void) cached_has_bits;
2271
2272 if (from._internal_minimum_clients_in_server_visible_aggregate() != 0) {
2273 _this->_internal_set_minimum_clients_in_server_visible_aggregate(from._internal_minimum_clients_in_server_visible_aggregate());
2274 }
2275 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2276 }
2277
CopyFrom(const SecureAggregation & from)2278 void SecureAggregation::CopyFrom(const SecureAggregation& from) {
2279 // @@protoc_insertion_point(class_specific_copy_from_start:fcp.client.SecureAggregation)
2280 if (&from == this) return;
2281 Clear();
2282 MergeFrom(from);
2283 }
2284
IsInitialized() const2285 bool SecureAggregation::IsInitialized() const {
2286 return true;
2287 }
2288
InternalSwap(SecureAggregation * other)2289 void SecureAggregation::InternalSwap(SecureAggregation* other) {
2290 using std::swap;
2291 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2292 swap(_impl_.minimum_clients_in_server_visible_aggregate_, other->_impl_.minimum_clients_in_server_visible_aggregate_);
2293 }
2294
GetTypeName() const2295 std::string SecureAggregation::GetTypeName() const {
2296 return "fcp.client.SecureAggregation";
2297 }
2298
2299
2300 // ===================================================================
2301
2302 class HistoricalContext::_Internal {
2303 public:
2304 static const ::PROTOBUF_NAMESPACE_ID::Timestamp& last_successful_contribution_time(const HistoricalContext* msg);
2305 };
2306
2307 const ::PROTOBUF_NAMESPACE_ID::Timestamp&
last_successful_contribution_time(const HistoricalContext * msg)2308 HistoricalContext::_Internal::last_successful_contribution_time(const HistoricalContext* msg) {
2309 return *msg->_impl_.last_successful_contribution_time_;
2310 }
clear_last_successful_contribution_time()2311 void HistoricalContext::clear_last_successful_contribution_time() {
2312 if (GetArenaForAllocation() == nullptr && _impl_.last_successful_contribution_time_ != nullptr) {
2313 delete _impl_.last_successful_contribution_time_;
2314 }
2315 _impl_.last_successful_contribution_time_ = nullptr;
2316 }
HistoricalContext(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2317 HistoricalContext::HistoricalContext(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2318 bool is_message_owned)
2319 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2320 SharedCtor(arena, is_message_owned);
2321 // @@protoc_insertion_point(arena_constructor:fcp.client.HistoricalContext)
2322 }
HistoricalContext(const HistoricalContext & from)2323 HistoricalContext::HistoricalContext(const HistoricalContext& from)
2324 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2325 HistoricalContext* const _this = this; (void)_this;
2326 new (&_impl_) Impl_{
2327 decltype(_impl_.last_successful_contribution_time_){nullptr}
2328 , /*decltype(_impl_._cached_size_)*/{}};
2329
2330 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2331 if (from._internal_has_last_successful_contribution_time()) {
2332 _this->_impl_.last_successful_contribution_time_ = new ::PROTOBUF_NAMESPACE_ID::Timestamp(*from._impl_.last_successful_contribution_time_);
2333 }
2334 // @@protoc_insertion_point(copy_constructor:fcp.client.HistoricalContext)
2335 }
2336
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2337 inline void HistoricalContext::SharedCtor(
2338 ::_pb::Arena* arena, bool is_message_owned) {
2339 (void)arena;
2340 (void)is_message_owned;
2341 new (&_impl_) Impl_{
2342 decltype(_impl_.last_successful_contribution_time_){nullptr}
2343 , /*decltype(_impl_._cached_size_)*/{}
2344 };
2345 }
2346
~HistoricalContext()2347 HistoricalContext::~HistoricalContext() {
2348 // @@protoc_insertion_point(destructor:fcp.client.HistoricalContext)
2349 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2350 (void)arena;
2351 return;
2352 }
2353 SharedDtor();
2354 }
2355
SharedDtor()2356 inline void HistoricalContext::SharedDtor() {
2357 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2358 if (this != internal_default_instance()) delete _impl_.last_successful_contribution_time_;
2359 }
2360
SetCachedSize(int size) const2361 void HistoricalContext::SetCachedSize(int size) const {
2362 _impl_._cached_size_.Set(size);
2363 }
2364
Clear()2365 void HistoricalContext::Clear() {
2366 // @@protoc_insertion_point(message_clear_start:fcp.client.HistoricalContext)
2367 ::uint32_t cached_has_bits = 0;
2368 // Prevent compiler warnings about cached_has_bits being unused
2369 (void) cached_has_bits;
2370
2371 if (GetArenaForAllocation() == nullptr && _impl_.last_successful_contribution_time_ != nullptr) {
2372 delete _impl_.last_successful_contribution_time_;
2373 }
2374 _impl_.last_successful_contribution_time_ = nullptr;
2375 _internal_metadata_.Clear<std::string>();
2376 }
2377
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2378 const char* HistoricalContext::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2379 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2380 while (!ctx->Done(&ptr)) {
2381 ::uint32_t tag;
2382 ptr = ::_pbi::ReadTag(ptr, &tag);
2383 switch (tag >> 3) {
2384 // .google.protobuf.Timestamp last_successful_contribution_time = 1;
2385 case 1:
2386 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
2387 ptr = ctx->ParseMessage(_internal_mutable_last_successful_contribution_time(), ptr);
2388 CHK_(ptr);
2389 } else {
2390 goto handle_unusual;
2391 }
2392 continue;
2393 default:
2394 goto handle_unusual;
2395 } // switch
2396 handle_unusual:
2397 if ((tag == 0) || ((tag & 7) == 4)) {
2398 CHK_(ptr);
2399 ctx->SetLastTag(tag);
2400 goto message_done;
2401 }
2402 ptr = UnknownFieldParse(
2403 tag,
2404 _internal_metadata_.mutable_unknown_fields<std::string>(),
2405 ptr, ctx);
2406 CHK_(ptr != nullptr);
2407 } // while
2408 message_done:
2409 return ptr;
2410 failure:
2411 ptr = nullptr;
2412 goto message_done;
2413 #undef CHK_
2414 }
2415
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2416 ::uint8_t* HistoricalContext::_InternalSerialize(
2417 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2418 // @@protoc_insertion_point(serialize_to_array_start:fcp.client.HistoricalContext)
2419 ::uint32_t cached_has_bits = 0;
2420 (void) cached_has_bits;
2421
2422 // .google.protobuf.Timestamp last_successful_contribution_time = 1;
2423 if (this->_internal_has_last_successful_contribution_time()) {
2424 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
2425 InternalWriteMessage(1, _Internal::last_successful_contribution_time(this),
2426 _Internal::last_successful_contribution_time(this).GetCachedSize(), target, stream);
2427 }
2428
2429 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2430 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2431 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2432 }
2433 // @@protoc_insertion_point(serialize_to_array_end:fcp.client.HistoricalContext)
2434 return target;
2435 }
2436
ByteSizeLong() const2437 size_t HistoricalContext::ByteSizeLong() const {
2438 // @@protoc_insertion_point(message_byte_size_start:fcp.client.HistoricalContext)
2439 size_t total_size = 0;
2440
2441 ::uint32_t cached_has_bits = 0;
2442 // Prevent compiler warnings about cached_has_bits being unused
2443 (void) cached_has_bits;
2444
2445 // .google.protobuf.Timestamp last_successful_contribution_time = 1;
2446 if (this->_internal_has_last_successful_contribution_time()) {
2447 total_size += 1 +
2448 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
2449 *_impl_.last_successful_contribution_time_);
2450 }
2451
2452 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2453 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2454 }
2455 int cached_size = ::_pbi::ToCachedSize(total_size);
2456 SetCachedSize(cached_size);
2457 return total_size;
2458 }
2459
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2460 void HistoricalContext::CheckTypeAndMergeFrom(
2461 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2462 MergeFrom(*::_pbi::DownCast<const HistoricalContext*>(
2463 &from));
2464 }
2465
MergeFrom(const HistoricalContext & from)2466 void HistoricalContext::MergeFrom(const HistoricalContext& from) {
2467 HistoricalContext* const _this = this;
2468 // @@protoc_insertion_point(class_specific_merge_from_start:fcp.client.HistoricalContext)
2469 GOOGLE_DCHECK_NE(&from, _this);
2470 ::uint32_t cached_has_bits = 0;
2471 (void) cached_has_bits;
2472
2473 if (from._internal_has_last_successful_contribution_time()) {
2474 _this->_internal_mutable_last_successful_contribution_time()->::PROTOBUF_NAMESPACE_ID::Timestamp::MergeFrom(
2475 from._internal_last_successful_contribution_time());
2476 }
2477 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2478 }
2479
CopyFrom(const HistoricalContext & from)2480 void HistoricalContext::CopyFrom(const HistoricalContext& from) {
2481 // @@protoc_insertion_point(class_specific_copy_from_start:fcp.client.HistoricalContext)
2482 if (&from == this) return;
2483 Clear();
2484 MergeFrom(from);
2485 }
2486
IsInitialized() const2487 bool HistoricalContext::IsInitialized() const {
2488 return true;
2489 }
2490
InternalSwap(HistoricalContext * other)2491 void HistoricalContext::InternalSwap(HistoricalContext* other) {
2492 using std::swap;
2493 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2494 swap(_impl_.last_successful_contribution_time_, other->_impl_.last_successful_contribution_time_);
2495 }
2496
GetTypeName() const2497 std::string HistoricalContext::GetTypeName() const {
2498 return "fcp.client.HistoricalContext";
2499 }
2500
2501
2502 // @@protoc_insertion_point(namespace_scope)
2503 } // namespace client
2504 } // namespace fcp
2505 PROTOBUF_NAMESPACE_OPEN
2506 template<> PROTOBUF_NOINLINE ::fcp::client::SelectorContext*
CreateMaybeMessage(Arena * arena)2507 Arena::CreateMaybeMessage< ::fcp::client::SelectorContext >(Arena* arena) {
2508 return Arena::CreateMessageInternal< ::fcp::client::SelectorContext >(arena);
2509 }
2510 template<> PROTOBUF_NOINLINE ::fcp::client::QueryTimeComputationProperties*
CreateMaybeMessage(Arena * arena)2511 Arena::CreateMaybeMessage< ::fcp::client::QueryTimeComputationProperties >(Arena* arena) {
2512 return Arena::CreateMessageInternal< ::fcp::client::QueryTimeComputationProperties >(arena);
2513 }
2514 template<> PROTOBUF_NOINLINE ::fcp::client::LocalComputation_InputResourceMapEntry_DoNotUse*
CreateMaybeMessage(Arena * arena)2515 Arena::CreateMaybeMessage< ::fcp::client::LocalComputation_InputResourceMapEntry_DoNotUse >(Arena* arena) {
2516 return Arena::CreateMessageInternal< ::fcp::client::LocalComputation_InputResourceMapEntry_DoNotUse >(arena);
2517 }
2518 template<> PROTOBUF_NOINLINE ::fcp::client::LocalComputation*
CreateMaybeMessage(Arena * arena)2519 Arena::CreateMaybeMessage< ::fcp::client::LocalComputation >(Arena* arena) {
2520 return Arena::CreateMessageInternal< ::fcp::client::LocalComputation >(arena);
2521 }
2522 template<> PROTOBUF_NOINLINE ::fcp::client::EligibilityEvalComputation*
CreateMaybeMessage(Arena * arena)2523 Arena::CreateMaybeMessage< ::fcp::client::EligibilityEvalComputation >(Arena* arena) {
2524 return Arena::CreateMessageInternal< ::fcp::client::EligibilityEvalComputation >(arena);
2525 }
2526 template<> PROTOBUF_NOINLINE ::fcp::client::FederatedComputation*
CreateMaybeMessage(Arena * arena)2527 Arena::CreateMaybeMessage< ::fcp::client::FederatedComputation >(Arena* arena) {
2528 return Arena::CreateMessageInternal< ::fcp::client::FederatedComputation >(arena);
2529 }
2530 template<> PROTOBUF_NOINLINE ::fcp::client::SimpleAggregation*
CreateMaybeMessage(Arena * arena)2531 Arena::CreateMaybeMessage< ::fcp::client::SimpleAggregation >(Arena* arena) {
2532 return Arena::CreateMessageInternal< ::fcp::client::SimpleAggregation >(arena);
2533 }
2534 template<> PROTOBUF_NOINLINE ::fcp::client::SecureAggregation*
CreateMaybeMessage(Arena * arena)2535 Arena::CreateMaybeMessage< ::fcp::client::SecureAggregation >(Arena* arena) {
2536 return Arena::CreateMessageInternal< ::fcp::client::SecureAggregation >(arena);
2537 }
2538 template<> PROTOBUF_NOINLINE ::fcp::client::HistoricalContext*
CreateMaybeMessage(Arena * arena)2539 Arena::CreateMaybeMessage< ::fcp::client::HistoricalContext >(Arena* arena) {
2540 return Arena::CreateMessageInternal< ::fcp::client::HistoricalContext >(arena);
2541 }
2542 PROTOBUF_NAMESPACE_CLOSE
2543
2544 // @@protoc_insertion_point(global_scope)
2545 #include <google/protobuf/port_undef.inc>
2546