1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: fcp/protos/federatedcompute/eligibility_eval_tasks.proto
3
4 #include "fcp/protos/federatedcompute/eligibility_eval_tasks.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 google {
22 namespace internal {
23 namespace federatedcompute {
24 namespace v1 {
EligibilityEvalTaskRequest(::_pbi::ConstantInitialized)25 PROTOBUF_CONSTEXPR EligibilityEvalTaskRequest::EligibilityEvalTaskRequest(
26 ::_pbi::ConstantInitialized): _impl_{
27 /*decltype(_impl_.population_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
28 , /*decltype(_impl_.attestation_measurement_)*/nullptr
29 , /*decltype(_impl_.client_version_)*/nullptr
30 , /*decltype(_impl_.resource_capabilities_)*/nullptr
31 , /*decltype(_impl_.eligibility_eval_task_capabilities_)*/nullptr
32 , /*decltype(_impl_._cached_size_)*/{}} {}
33 struct EligibilityEvalTaskRequestDefaultTypeInternal {
EligibilityEvalTaskRequestDefaultTypeInternalgoogle::internal::federatedcompute::v1::EligibilityEvalTaskRequestDefaultTypeInternal34 PROTOBUF_CONSTEXPR EligibilityEvalTaskRequestDefaultTypeInternal()
35 : _instance(::_pbi::ConstantInitialized{}) {}
~EligibilityEvalTaskRequestDefaultTypeInternalgoogle::internal::federatedcompute::v1::EligibilityEvalTaskRequestDefaultTypeInternal36 ~EligibilityEvalTaskRequestDefaultTypeInternal() {}
37 union { // NOLINT(misc-non-private-member-variables-in-classes)
38 EligibilityEvalTaskRequest _instance;
39 };
40 };
41 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EligibilityEvalTaskRequestDefaultTypeInternal _EligibilityEvalTaskRequest_default_instance_;
EligibilityEvalTaskCapabilities(::_pbi::ConstantInitialized)42 PROTOBUF_CONSTEXPR EligibilityEvalTaskCapabilities::EligibilityEvalTaskCapabilities(
43 ::_pbi::ConstantInitialized): _impl_{
44 /*decltype(_impl_.supports_multiple_task_assignment_)*/false
45 , /*decltype(_impl_._cached_size_)*/{}} {}
46 struct EligibilityEvalTaskCapabilitiesDefaultTypeInternal {
EligibilityEvalTaskCapabilitiesDefaultTypeInternalgoogle::internal::federatedcompute::v1::EligibilityEvalTaskCapabilitiesDefaultTypeInternal47 PROTOBUF_CONSTEXPR EligibilityEvalTaskCapabilitiesDefaultTypeInternal()
48 : _instance(::_pbi::ConstantInitialized{}) {}
~EligibilityEvalTaskCapabilitiesDefaultTypeInternalgoogle::internal::federatedcompute::v1::EligibilityEvalTaskCapabilitiesDefaultTypeInternal49 ~EligibilityEvalTaskCapabilitiesDefaultTypeInternal() {}
50 union { // NOLINT(misc-non-private-member-variables-in-classes)
51 EligibilityEvalTaskCapabilities _instance;
52 };
53 };
54 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EligibilityEvalTaskCapabilitiesDefaultTypeInternal _EligibilityEvalTaskCapabilities_default_instance_;
EligibilityEvalTaskResponse(::_pbi::ConstantInitialized)55 PROTOBUF_CONSTEXPR EligibilityEvalTaskResponse::EligibilityEvalTaskResponse(
56 ::_pbi::ConstantInitialized): _impl_{
57 /*decltype(_impl_.session_id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
58 , /*decltype(_impl_.task_assignment_forwarding_info_)*/nullptr
59 , /*decltype(_impl_.retry_window_if_accepted_)*/nullptr
60 , /*decltype(_impl_.retry_window_if_rejected_)*/nullptr
61 , /*decltype(_impl_.result_)*/{}
62 , /*decltype(_impl_._cached_size_)*/{}
63 , /*decltype(_impl_._oneof_case_)*/{}} {}
64 struct EligibilityEvalTaskResponseDefaultTypeInternal {
EligibilityEvalTaskResponseDefaultTypeInternalgoogle::internal::federatedcompute::v1::EligibilityEvalTaskResponseDefaultTypeInternal65 PROTOBUF_CONSTEXPR EligibilityEvalTaskResponseDefaultTypeInternal()
66 : _instance(::_pbi::ConstantInitialized{}) {}
~EligibilityEvalTaskResponseDefaultTypeInternalgoogle::internal::federatedcompute::v1::EligibilityEvalTaskResponseDefaultTypeInternal67 ~EligibilityEvalTaskResponseDefaultTypeInternal() {}
68 union { // NOLINT(misc-non-private-member-variables-in-classes)
69 EligibilityEvalTaskResponse _instance;
70 };
71 };
72 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EligibilityEvalTaskResponseDefaultTypeInternal _EligibilityEvalTaskResponse_default_instance_;
EligibilityEvalTask(::_pbi::ConstantInitialized)73 PROTOBUF_CONSTEXPR EligibilityEvalTask::EligibilityEvalTask(
74 ::_pbi::ConstantInitialized): _impl_{
75 /*decltype(_impl_.execution_id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
76 , /*decltype(_impl_.init_checkpoint_)*/nullptr
77 , /*decltype(_impl_.plan_)*/nullptr
78 , /*decltype(_impl_.population_eligibility_spec_)*/nullptr
79 , /*decltype(_impl_._cached_size_)*/{}} {}
80 struct EligibilityEvalTaskDefaultTypeInternal {
EligibilityEvalTaskDefaultTypeInternalgoogle::internal::federatedcompute::v1::EligibilityEvalTaskDefaultTypeInternal81 PROTOBUF_CONSTEXPR EligibilityEvalTaskDefaultTypeInternal()
82 : _instance(::_pbi::ConstantInitialized{}) {}
~EligibilityEvalTaskDefaultTypeInternalgoogle::internal::federatedcompute::v1::EligibilityEvalTaskDefaultTypeInternal83 ~EligibilityEvalTaskDefaultTypeInternal() {}
84 union { // NOLINT(misc-non-private-member-variables-in-classes)
85 EligibilityEvalTask _instance;
86 };
87 };
88 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EligibilityEvalTaskDefaultTypeInternal _EligibilityEvalTask_default_instance_;
NoEligibilityEvalConfigured(::_pbi::ConstantInitialized)89 PROTOBUF_CONSTEXPR NoEligibilityEvalConfigured::NoEligibilityEvalConfigured(
90 ::_pbi::ConstantInitialized): _impl_{
91 /*decltype(_impl_._cached_size_)*/{}} {}
92 struct NoEligibilityEvalConfiguredDefaultTypeInternal {
NoEligibilityEvalConfiguredDefaultTypeInternalgoogle::internal::federatedcompute::v1::NoEligibilityEvalConfiguredDefaultTypeInternal93 PROTOBUF_CONSTEXPR NoEligibilityEvalConfiguredDefaultTypeInternal()
94 : _instance(::_pbi::ConstantInitialized{}) {}
~NoEligibilityEvalConfiguredDefaultTypeInternalgoogle::internal::federatedcompute::v1::NoEligibilityEvalConfiguredDefaultTypeInternal95 ~NoEligibilityEvalConfiguredDefaultTypeInternal() {}
96 union { // NOLINT(misc-non-private-member-variables-in-classes)
97 NoEligibilityEvalConfigured _instance;
98 };
99 };
100 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NoEligibilityEvalConfiguredDefaultTypeInternal _NoEligibilityEvalConfigured_default_instance_;
PopulationEligibilitySpec_TaskInfo(::_pbi::ConstantInitialized)101 PROTOBUF_CONSTEXPR PopulationEligibilitySpec_TaskInfo::PopulationEligibilitySpec_TaskInfo(
102 ::_pbi::ConstantInitialized): _impl_{
103 /*decltype(_impl_.task_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
104 , /*decltype(_impl_.task_assignment_mode_)*/0
105 , /*decltype(_impl_._cached_size_)*/{}} {}
106 struct PopulationEligibilitySpec_TaskInfoDefaultTypeInternal {
PopulationEligibilitySpec_TaskInfoDefaultTypeInternalgoogle::internal::federatedcompute::v1::PopulationEligibilitySpec_TaskInfoDefaultTypeInternal107 PROTOBUF_CONSTEXPR PopulationEligibilitySpec_TaskInfoDefaultTypeInternal()
108 : _instance(::_pbi::ConstantInitialized{}) {}
~PopulationEligibilitySpec_TaskInfoDefaultTypeInternalgoogle::internal::federatedcompute::v1::PopulationEligibilitySpec_TaskInfoDefaultTypeInternal109 ~PopulationEligibilitySpec_TaskInfoDefaultTypeInternal() {}
110 union { // NOLINT(misc-non-private-member-variables-in-classes)
111 PopulationEligibilitySpec_TaskInfo _instance;
112 };
113 };
114 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PopulationEligibilitySpec_TaskInfoDefaultTypeInternal _PopulationEligibilitySpec_TaskInfo_default_instance_;
PopulationEligibilitySpec(::_pbi::ConstantInitialized)115 PROTOBUF_CONSTEXPR PopulationEligibilitySpec::PopulationEligibilitySpec(
116 ::_pbi::ConstantInitialized): _impl_{
117 /*decltype(_impl_.task_info_)*/{}
118 , /*decltype(_impl_._cached_size_)*/{}} {}
119 struct PopulationEligibilitySpecDefaultTypeInternal {
PopulationEligibilitySpecDefaultTypeInternalgoogle::internal::federatedcompute::v1::PopulationEligibilitySpecDefaultTypeInternal120 PROTOBUF_CONSTEXPR PopulationEligibilitySpecDefaultTypeInternal()
121 : _instance(::_pbi::ConstantInitialized{}) {}
~PopulationEligibilitySpecDefaultTypeInternalgoogle::internal::federatedcompute::v1::PopulationEligibilitySpecDefaultTypeInternal122 ~PopulationEligibilitySpecDefaultTypeInternal() {}
123 union { // NOLINT(misc-non-private-member-variables-in-classes)
124 PopulationEligibilitySpec _instance;
125 };
126 };
127 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PopulationEligibilitySpecDefaultTypeInternal _PopulationEligibilitySpec_default_instance_;
ReportEligibilityEvalTaskResultRequest(::_pbi::ConstantInitialized)128 PROTOBUF_CONSTEXPR ReportEligibilityEvalTaskResultRequest::ReportEligibilityEvalTaskResultRequest(
129 ::_pbi::ConstantInitialized): _impl_{
130 /*decltype(_impl_.population_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
131 , /*decltype(_impl_.session_id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
132 , /*decltype(_impl_.status_code_)*/0
133 , /*decltype(_impl_._cached_size_)*/{}} {}
134 struct ReportEligibilityEvalTaskResultRequestDefaultTypeInternal {
ReportEligibilityEvalTaskResultRequestDefaultTypeInternalgoogle::internal::federatedcompute::v1::ReportEligibilityEvalTaskResultRequestDefaultTypeInternal135 PROTOBUF_CONSTEXPR ReportEligibilityEvalTaskResultRequestDefaultTypeInternal()
136 : _instance(::_pbi::ConstantInitialized{}) {}
~ReportEligibilityEvalTaskResultRequestDefaultTypeInternalgoogle::internal::federatedcompute::v1::ReportEligibilityEvalTaskResultRequestDefaultTypeInternal137 ~ReportEligibilityEvalTaskResultRequestDefaultTypeInternal() {}
138 union { // NOLINT(misc-non-private-member-variables-in-classes)
139 ReportEligibilityEvalTaskResultRequest _instance;
140 };
141 };
142 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ReportEligibilityEvalTaskResultRequestDefaultTypeInternal _ReportEligibilityEvalTaskResultRequest_default_instance_;
ReportEligibilityEvalTaskResultResponse(::_pbi::ConstantInitialized)143 PROTOBUF_CONSTEXPR ReportEligibilityEvalTaskResultResponse::ReportEligibilityEvalTaskResultResponse(
144 ::_pbi::ConstantInitialized): _impl_{
145 /*decltype(_impl_._cached_size_)*/{}} {}
146 struct ReportEligibilityEvalTaskResultResponseDefaultTypeInternal {
ReportEligibilityEvalTaskResultResponseDefaultTypeInternalgoogle::internal::federatedcompute::v1::ReportEligibilityEvalTaskResultResponseDefaultTypeInternal147 PROTOBUF_CONSTEXPR ReportEligibilityEvalTaskResultResponseDefaultTypeInternal()
148 : _instance(::_pbi::ConstantInitialized{}) {}
~ReportEligibilityEvalTaskResultResponseDefaultTypeInternalgoogle::internal::federatedcompute::v1::ReportEligibilityEvalTaskResultResponseDefaultTypeInternal149 ~ReportEligibilityEvalTaskResultResponseDefaultTypeInternal() {}
150 union { // NOLINT(misc-non-private-member-variables-in-classes)
151 ReportEligibilityEvalTaskResultResponse _instance;
152 };
153 };
154 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ReportEligibilityEvalTaskResultResponseDefaultTypeInternal _ReportEligibilityEvalTaskResultResponse_default_instance_;
155 } // namespace v1
156 } // namespace federatedcompute
157 } // namespace internal
158 } // namespace google
159 namespace google {
160 namespace internal {
161 namespace federatedcompute {
162 namespace v1 {
PopulationEligibilitySpec_TaskInfo_TaskAssignmentMode_IsValid(int value)163 bool PopulationEligibilitySpec_TaskInfo_TaskAssignmentMode_IsValid(int value) {
164 switch (value) {
165 case 0:
166 case 1:
167 case 2:
168 return true;
169 default:
170 return false;
171 }
172 }
173
174 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> PopulationEligibilitySpec_TaskInfo_TaskAssignmentMode_strings[3] = {};
175
176 static const char PopulationEligibilitySpec_TaskInfo_TaskAssignmentMode_names[] =
177 "TASK_ASSIGNMENT_MODE_MULTIPLE"
178 "TASK_ASSIGNMENT_MODE_SINGLE"
179 "TASK_ASSIGNMENT_MODE_UNSPECIFIED";
180
181 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry PopulationEligibilitySpec_TaskInfo_TaskAssignmentMode_entries[] = {
182 { {PopulationEligibilitySpec_TaskInfo_TaskAssignmentMode_names + 0, 29}, 2 },
183 { {PopulationEligibilitySpec_TaskInfo_TaskAssignmentMode_names + 29, 27}, 1 },
184 { {PopulationEligibilitySpec_TaskInfo_TaskAssignmentMode_names + 56, 32}, 0 },
185 };
186
187 static const int PopulationEligibilitySpec_TaskInfo_TaskAssignmentMode_entries_by_number[] = {
188 2, // 0 -> TASK_ASSIGNMENT_MODE_UNSPECIFIED
189 1, // 1 -> TASK_ASSIGNMENT_MODE_SINGLE
190 0, // 2 -> TASK_ASSIGNMENT_MODE_MULTIPLE
191 };
192
PopulationEligibilitySpec_TaskInfo_TaskAssignmentMode_Name(PopulationEligibilitySpec_TaskInfo_TaskAssignmentMode value)193 const std::string& PopulationEligibilitySpec_TaskInfo_TaskAssignmentMode_Name(
194 PopulationEligibilitySpec_TaskInfo_TaskAssignmentMode value) {
195 static const bool dummy =
196 ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
197 PopulationEligibilitySpec_TaskInfo_TaskAssignmentMode_entries,
198 PopulationEligibilitySpec_TaskInfo_TaskAssignmentMode_entries_by_number,
199 3, PopulationEligibilitySpec_TaskInfo_TaskAssignmentMode_strings);
200 (void) dummy;
201 int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
202 PopulationEligibilitySpec_TaskInfo_TaskAssignmentMode_entries,
203 PopulationEligibilitySpec_TaskInfo_TaskAssignmentMode_entries_by_number,
204 3, value);
205 return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
206 PopulationEligibilitySpec_TaskInfo_TaskAssignmentMode_strings[idx].get();
207 }
PopulationEligibilitySpec_TaskInfo_TaskAssignmentMode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,PopulationEligibilitySpec_TaskInfo_TaskAssignmentMode * value)208 bool PopulationEligibilitySpec_TaskInfo_TaskAssignmentMode_Parse(
209 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PopulationEligibilitySpec_TaskInfo_TaskAssignmentMode* value) {
210 int int_value;
211 bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
212 PopulationEligibilitySpec_TaskInfo_TaskAssignmentMode_entries, 3, name, &int_value);
213 if (success) {
214 *value = static_cast<PopulationEligibilitySpec_TaskInfo_TaskAssignmentMode>(int_value);
215 }
216 return success;
217 }
218 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
219 constexpr PopulationEligibilitySpec_TaskInfo_TaskAssignmentMode PopulationEligibilitySpec_TaskInfo::TASK_ASSIGNMENT_MODE_UNSPECIFIED;
220 constexpr PopulationEligibilitySpec_TaskInfo_TaskAssignmentMode PopulationEligibilitySpec_TaskInfo::TASK_ASSIGNMENT_MODE_SINGLE;
221 constexpr PopulationEligibilitySpec_TaskInfo_TaskAssignmentMode PopulationEligibilitySpec_TaskInfo::TASK_ASSIGNMENT_MODE_MULTIPLE;
222 constexpr PopulationEligibilitySpec_TaskInfo_TaskAssignmentMode PopulationEligibilitySpec_TaskInfo::TaskAssignmentMode_MIN;
223 constexpr PopulationEligibilitySpec_TaskInfo_TaskAssignmentMode PopulationEligibilitySpec_TaskInfo::TaskAssignmentMode_MAX;
224 constexpr int PopulationEligibilitySpec_TaskInfo::TaskAssignmentMode_ARRAYSIZE;
225 #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
226
227 // ===================================================================
228
229 class EligibilityEvalTaskRequest::_Internal {
230 public:
231 static const ::google::internal::federatedcompute::v1::AttestationMeasurement& attestation_measurement(const EligibilityEvalTaskRequest* msg);
232 static const ::google::internal::federatedcompute::v1::ClientVersion& client_version(const EligibilityEvalTaskRequest* msg);
233 static const ::google::internal::federatedcompute::v1::ResourceCapabilities& resource_capabilities(const EligibilityEvalTaskRequest* msg);
234 static const ::google::internal::federatedcompute::v1::EligibilityEvalTaskCapabilities& eligibility_eval_task_capabilities(const EligibilityEvalTaskRequest* msg);
235 };
236
237 const ::google::internal::federatedcompute::v1::AttestationMeasurement&
attestation_measurement(const EligibilityEvalTaskRequest * msg)238 EligibilityEvalTaskRequest::_Internal::attestation_measurement(const EligibilityEvalTaskRequest* msg) {
239 return *msg->_impl_.attestation_measurement_;
240 }
241 const ::google::internal::federatedcompute::v1::ClientVersion&
client_version(const EligibilityEvalTaskRequest * msg)242 EligibilityEvalTaskRequest::_Internal::client_version(const EligibilityEvalTaskRequest* msg) {
243 return *msg->_impl_.client_version_;
244 }
245 const ::google::internal::federatedcompute::v1::ResourceCapabilities&
resource_capabilities(const EligibilityEvalTaskRequest * msg)246 EligibilityEvalTaskRequest::_Internal::resource_capabilities(const EligibilityEvalTaskRequest* msg) {
247 return *msg->_impl_.resource_capabilities_;
248 }
249 const ::google::internal::federatedcompute::v1::EligibilityEvalTaskCapabilities&
eligibility_eval_task_capabilities(const EligibilityEvalTaskRequest * msg)250 EligibilityEvalTaskRequest::_Internal::eligibility_eval_task_capabilities(const EligibilityEvalTaskRequest* msg) {
251 return *msg->_impl_.eligibility_eval_task_capabilities_;
252 }
clear_attestation_measurement()253 void EligibilityEvalTaskRequest::clear_attestation_measurement() {
254 if (GetArenaForAllocation() == nullptr && _impl_.attestation_measurement_ != nullptr) {
255 delete _impl_.attestation_measurement_;
256 }
257 _impl_.attestation_measurement_ = nullptr;
258 }
clear_client_version()259 void EligibilityEvalTaskRequest::clear_client_version() {
260 if (GetArenaForAllocation() == nullptr && _impl_.client_version_ != nullptr) {
261 delete _impl_.client_version_;
262 }
263 _impl_.client_version_ = nullptr;
264 }
clear_resource_capabilities()265 void EligibilityEvalTaskRequest::clear_resource_capabilities() {
266 if (GetArenaForAllocation() == nullptr && _impl_.resource_capabilities_ != nullptr) {
267 delete _impl_.resource_capabilities_;
268 }
269 _impl_.resource_capabilities_ = nullptr;
270 }
EligibilityEvalTaskRequest(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)271 EligibilityEvalTaskRequest::EligibilityEvalTaskRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
272 bool is_message_owned)
273 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
274 SharedCtor(arena, is_message_owned);
275 // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.EligibilityEvalTaskRequest)
276 }
EligibilityEvalTaskRequest(const EligibilityEvalTaskRequest & from)277 EligibilityEvalTaskRequest::EligibilityEvalTaskRequest(const EligibilityEvalTaskRequest& from)
278 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
279 EligibilityEvalTaskRequest* const _this = this; (void)_this;
280 new (&_impl_) Impl_{
281 decltype(_impl_.population_name_){}
282 , decltype(_impl_.attestation_measurement_){nullptr}
283 , decltype(_impl_.client_version_){nullptr}
284 , decltype(_impl_.resource_capabilities_){nullptr}
285 , decltype(_impl_.eligibility_eval_task_capabilities_){nullptr}
286 , /*decltype(_impl_._cached_size_)*/{}};
287
288 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
289 _impl_.population_name_.InitDefault();
290 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
291 _impl_.population_name_.Set("", GetArenaForAllocation());
292 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
293 if (!from._internal_population_name().empty()) {
294 _this->_impl_.population_name_.Set(from._internal_population_name(),
295 _this->GetArenaForAllocation());
296 }
297 if (from._internal_has_attestation_measurement()) {
298 _this->_impl_.attestation_measurement_ = new ::google::internal::federatedcompute::v1::AttestationMeasurement(*from._impl_.attestation_measurement_);
299 }
300 if (from._internal_has_client_version()) {
301 _this->_impl_.client_version_ = new ::google::internal::federatedcompute::v1::ClientVersion(*from._impl_.client_version_);
302 }
303 if (from._internal_has_resource_capabilities()) {
304 _this->_impl_.resource_capabilities_ = new ::google::internal::federatedcompute::v1::ResourceCapabilities(*from._impl_.resource_capabilities_);
305 }
306 if (from._internal_has_eligibility_eval_task_capabilities()) {
307 _this->_impl_.eligibility_eval_task_capabilities_ = new ::google::internal::federatedcompute::v1::EligibilityEvalTaskCapabilities(*from._impl_.eligibility_eval_task_capabilities_);
308 }
309 // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.EligibilityEvalTaskRequest)
310 }
311
SharedCtor(::_pb::Arena * arena,bool is_message_owned)312 inline void EligibilityEvalTaskRequest::SharedCtor(
313 ::_pb::Arena* arena, bool is_message_owned) {
314 (void)arena;
315 (void)is_message_owned;
316 new (&_impl_) Impl_{
317 decltype(_impl_.population_name_){}
318 , decltype(_impl_.attestation_measurement_){nullptr}
319 , decltype(_impl_.client_version_){nullptr}
320 , decltype(_impl_.resource_capabilities_){nullptr}
321 , decltype(_impl_.eligibility_eval_task_capabilities_){nullptr}
322 , /*decltype(_impl_._cached_size_)*/{}
323 };
324 _impl_.population_name_.InitDefault();
325 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
326 _impl_.population_name_.Set("", GetArenaForAllocation());
327 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
328 }
329
~EligibilityEvalTaskRequest()330 EligibilityEvalTaskRequest::~EligibilityEvalTaskRequest() {
331 // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.EligibilityEvalTaskRequest)
332 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
333 (void)arena;
334 return;
335 }
336 SharedDtor();
337 }
338
SharedDtor()339 inline void EligibilityEvalTaskRequest::SharedDtor() {
340 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
341 _impl_.population_name_.Destroy();
342 if (this != internal_default_instance()) delete _impl_.attestation_measurement_;
343 if (this != internal_default_instance()) delete _impl_.client_version_;
344 if (this != internal_default_instance()) delete _impl_.resource_capabilities_;
345 if (this != internal_default_instance()) delete _impl_.eligibility_eval_task_capabilities_;
346 }
347
SetCachedSize(int size) const348 void EligibilityEvalTaskRequest::SetCachedSize(int size) const {
349 _impl_._cached_size_.Set(size);
350 }
351
Clear()352 void EligibilityEvalTaskRequest::Clear() {
353 // @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.EligibilityEvalTaskRequest)
354 ::uint32_t cached_has_bits = 0;
355 // Prevent compiler warnings about cached_has_bits being unused
356 (void) cached_has_bits;
357
358 _impl_.population_name_.ClearToEmpty();
359 if (GetArenaForAllocation() == nullptr && _impl_.attestation_measurement_ != nullptr) {
360 delete _impl_.attestation_measurement_;
361 }
362 _impl_.attestation_measurement_ = nullptr;
363 if (GetArenaForAllocation() == nullptr && _impl_.client_version_ != nullptr) {
364 delete _impl_.client_version_;
365 }
366 _impl_.client_version_ = nullptr;
367 if (GetArenaForAllocation() == nullptr && _impl_.resource_capabilities_ != nullptr) {
368 delete _impl_.resource_capabilities_;
369 }
370 _impl_.resource_capabilities_ = nullptr;
371 if (GetArenaForAllocation() == nullptr && _impl_.eligibility_eval_task_capabilities_ != nullptr) {
372 delete _impl_.eligibility_eval_task_capabilities_;
373 }
374 _impl_.eligibility_eval_task_capabilities_ = nullptr;
375 _internal_metadata_.Clear<std::string>();
376 }
377
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)378 const char* EligibilityEvalTaskRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
379 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
380 while (!ctx->Done(&ptr)) {
381 ::uint32_t tag;
382 ptr = ::_pbi::ReadTag(ptr, &tag);
383 switch (tag >> 3) {
384 // string population_name = 1;
385 case 1:
386 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
387 auto str = _internal_mutable_population_name();
388 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
389 CHK_(ptr);
390 CHK_(::_pbi::VerifyUTF8(str, nullptr));
391 } else {
392 goto handle_unusual;
393 }
394 continue;
395 // .google.internal.federatedcompute.v1.AttestationMeasurement attestation_measurement = 2;
396 case 2:
397 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
398 ptr = ctx->ParseMessage(_internal_mutable_attestation_measurement(), ptr);
399 CHK_(ptr);
400 } else {
401 goto handle_unusual;
402 }
403 continue;
404 // .google.internal.federatedcompute.v1.ClientVersion client_version = 3;
405 case 3:
406 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
407 ptr = ctx->ParseMessage(_internal_mutable_client_version(), ptr);
408 CHK_(ptr);
409 } else {
410 goto handle_unusual;
411 }
412 continue;
413 // .google.internal.federatedcompute.v1.ResourceCapabilities resource_capabilities = 4;
414 case 4:
415 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
416 ptr = ctx->ParseMessage(_internal_mutable_resource_capabilities(), ptr);
417 CHK_(ptr);
418 } else {
419 goto handle_unusual;
420 }
421 continue;
422 // .google.internal.federatedcompute.v1.EligibilityEvalTaskCapabilities eligibility_eval_task_capabilities = 5;
423 case 5:
424 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
425 ptr = ctx->ParseMessage(_internal_mutable_eligibility_eval_task_capabilities(), ptr);
426 CHK_(ptr);
427 } else {
428 goto handle_unusual;
429 }
430 continue;
431 default:
432 goto handle_unusual;
433 } // switch
434 handle_unusual:
435 if ((tag == 0) || ((tag & 7) == 4)) {
436 CHK_(ptr);
437 ctx->SetLastTag(tag);
438 goto message_done;
439 }
440 ptr = UnknownFieldParse(
441 tag,
442 _internal_metadata_.mutable_unknown_fields<std::string>(),
443 ptr, ctx);
444 CHK_(ptr != nullptr);
445 } // while
446 message_done:
447 return ptr;
448 failure:
449 ptr = nullptr;
450 goto message_done;
451 #undef CHK_
452 }
453
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const454 ::uint8_t* EligibilityEvalTaskRequest::_InternalSerialize(
455 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
456 // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.EligibilityEvalTaskRequest)
457 ::uint32_t cached_has_bits = 0;
458 (void) cached_has_bits;
459
460 // string population_name = 1;
461 if (!this->_internal_population_name().empty()) {
462 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
463 this->_internal_population_name().data(), static_cast<int>(this->_internal_population_name().length()),
464 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
465 "google.internal.federatedcompute.v1.EligibilityEvalTaskRequest.population_name");
466 target = stream->WriteStringMaybeAliased(
467 1, this->_internal_population_name(), target);
468 }
469
470 // .google.internal.federatedcompute.v1.AttestationMeasurement attestation_measurement = 2;
471 if (this->_internal_has_attestation_measurement()) {
472 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
473 InternalWriteMessage(2, _Internal::attestation_measurement(this),
474 _Internal::attestation_measurement(this).GetCachedSize(), target, stream);
475 }
476
477 // .google.internal.federatedcompute.v1.ClientVersion client_version = 3;
478 if (this->_internal_has_client_version()) {
479 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
480 InternalWriteMessage(3, _Internal::client_version(this),
481 _Internal::client_version(this).GetCachedSize(), target, stream);
482 }
483
484 // .google.internal.federatedcompute.v1.ResourceCapabilities resource_capabilities = 4;
485 if (this->_internal_has_resource_capabilities()) {
486 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
487 InternalWriteMessage(4, _Internal::resource_capabilities(this),
488 _Internal::resource_capabilities(this).GetCachedSize(), target, stream);
489 }
490
491 // .google.internal.federatedcompute.v1.EligibilityEvalTaskCapabilities eligibility_eval_task_capabilities = 5;
492 if (this->_internal_has_eligibility_eval_task_capabilities()) {
493 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
494 InternalWriteMessage(5, _Internal::eligibility_eval_task_capabilities(this),
495 _Internal::eligibility_eval_task_capabilities(this).GetCachedSize(), target, stream);
496 }
497
498 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
499 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
500 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
501 }
502 // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.EligibilityEvalTaskRequest)
503 return target;
504 }
505
ByteSizeLong() const506 size_t EligibilityEvalTaskRequest::ByteSizeLong() const {
507 // @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.EligibilityEvalTaskRequest)
508 size_t total_size = 0;
509
510 ::uint32_t cached_has_bits = 0;
511 // Prevent compiler warnings about cached_has_bits being unused
512 (void) cached_has_bits;
513
514 // string population_name = 1;
515 if (!this->_internal_population_name().empty()) {
516 total_size += 1 +
517 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
518 this->_internal_population_name());
519 }
520
521 // .google.internal.federatedcompute.v1.AttestationMeasurement attestation_measurement = 2;
522 if (this->_internal_has_attestation_measurement()) {
523 total_size += 1 +
524 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
525 *_impl_.attestation_measurement_);
526 }
527
528 // .google.internal.federatedcompute.v1.ClientVersion client_version = 3;
529 if (this->_internal_has_client_version()) {
530 total_size += 1 +
531 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
532 *_impl_.client_version_);
533 }
534
535 // .google.internal.federatedcompute.v1.ResourceCapabilities resource_capabilities = 4;
536 if (this->_internal_has_resource_capabilities()) {
537 total_size += 1 +
538 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
539 *_impl_.resource_capabilities_);
540 }
541
542 // .google.internal.federatedcompute.v1.EligibilityEvalTaskCapabilities eligibility_eval_task_capabilities = 5;
543 if (this->_internal_has_eligibility_eval_task_capabilities()) {
544 total_size += 1 +
545 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
546 *_impl_.eligibility_eval_task_capabilities_);
547 }
548
549 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
550 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
551 }
552 int cached_size = ::_pbi::ToCachedSize(total_size);
553 SetCachedSize(cached_size);
554 return total_size;
555 }
556
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)557 void EligibilityEvalTaskRequest::CheckTypeAndMergeFrom(
558 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
559 MergeFrom(*::_pbi::DownCast<const EligibilityEvalTaskRequest*>(
560 &from));
561 }
562
MergeFrom(const EligibilityEvalTaskRequest & from)563 void EligibilityEvalTaskRequest::MergeFrom(const EligibilityEvalTaskRequest& from) {
564 EligibilityEvalTaskRequest* const _this = this;
565 // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.EligibilityEvalTaskRequest)
566 GOOGLE_DCHECK_NE(&from, _this);
567 ::uint32_t cached_has_bits = 0;
568 (void) cached_has_bits;
569
570 if (!from._internal_population_name().empty()) {
571 _this->_internal_set_population_name(from._internal_population_name());
572 }
573 if (from._internal_has_attestation_measurement()) {
574 _this->_internal_mutable_attestation_measurement()->::google::internal::federatedcompute::v1::AttestationMeasurement::MergeFrom(
575 from._internal_attestation_measurement());
576 }
577 if (from._internal_has_client_version()) {
578 _this->_internal_mutable_client_version()->::google::internal::federatedcompute::v1::ClientVersion::MergeFrom(
579 from._internal_client_version());
580 }
581 if (from._internal_has_resource_capabilities()) {
582 _this->_internal_mutable_resource_capabilities()->::google::internal::federatedcompute::v1::ResourceCapabilities::MergeFrom(
583 from._internal_resource_capabilities());
584 }
585 if (from._internal_has_eligibility_eval_task_capabilities()) {
586 _this->_internal_mutable_eligibility_eval_task_capabilities()->::google::internal::federatedcompute::v1::EligibilityEvalTaskCapabilities::MergeFrom(
587 from._internal_eligibility_eval_task_capabilities());
588 }
589 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
590 }
591
CopyFrom(const EligibilityEvalTaskRequest & from)592 void EligibilityEvalTaskRequest::CopyFrom(const EligibilityEvalTaskRequest& from) {
593 // @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.EligibilityEvalTaskRequest)
594 if (&from == this) return;
595 Clear();
596 MergeFrom(from);
597 }
598
IsInitialized() const599 bool EligibilityEvalTaskRequest::IsInitialized() const {
600 return true;
601 }
602
InternalSwap(EligibilityEvalTaskRequest * other)603 void EligibilityEvalTaskRequest::InternalSwap(EligibilityEvalTaskRequest* other) {
604 using std::swap;
605 auto* lhs_arena = GetArenaForAllocation();
606 auto* rhs_arena = other->GetArenaForAllocation();
607 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
608 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
609 &_impl_.population_name_, lhs_arena,
610 &other->_impl_.population_name_, rhs_arena
611 );
612 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
613 PROTOBUF_FIELD_OFFSET(EligibilityEvalTaskRequest, _impl_.eligibility_eval_task_capabilities_)
614 + sizeof(EligibilityEvalTaskRequest::_impl_.eligibility_eval_task_capabilities_) // NOLINT
615 - PROTOBUF_FIELD_OFFSET(EligibilityEvalTaskRequest, _impl_.attestation_measurement_)>(
616 reinterpret_cast<char*>(&_impl_.attestation_measurement_),
617 reinterpret_cast<char*>(&other->_impl_.attestation_measurement_));
618 }
619
GetTypeName() const620 std::string EligibilityEvalTaskRequest::GetTypeName() const {
621 return "google.internal.federatedcompute.v1.EligibilityEvalTaskRequest";
622 }
623
624
625 // ===================================================================
626
627 class EligibilityEvalTaskCapabilities::_Internal {
628 public:
629 };
630
EligibilityEvalTaskCapabilities(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)631 EligibilityEvalTaskCapabilities::EligibilityEvalTaskCapabilities(::PROTOBUF_NAMESPACE_ID::Arena* arena,
632 bool is_message_owned)
633 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
634 SharedCtor(arena, is_message_owned);
635 // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.EligibilityEvalTaskCapabilities)
636 }
EligibilityEvalTaskCapabilities(const EligibilityEvalTaskCapabilities & from)637 EligibilityEvalTaskCapabilities::EligibilityEvalTaskCapabilities(const EligibilityEvalTaskCapabilities& from)
638 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
639 EligibilityEvalTaskCapabilities* const _this = this; (void)_this;
640 new (&_impl_) Impl_{
641 decltype(_impl_.supports_multiple_task_assignment_){}
642 , /*decltype(_impl_._cached_size_)*/{}};
643
644 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
645 _this->_impl_.supports_multiple_task_assignment_ = from._impl_.supports_multiple_task_assignment_;
646 // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.EligibilityEvalTaskCapabilities)
647 }
648
SharedCtor(::_pb::Arena * arena,bool is_message_owned)649 inline void EligibilityEvalTaskCapabilities::SharedCtor(
650 ::_pb::Arena* arena, bool is_message_owned) {
651 (void)arena;
652 (void)is_message_owned;
653 new (&_impl_) Impl_{
654 decltype(_impl_.supports_multiple_task_assignment_){false}
655 , /*decltype(_impl_._cached_size_)*/{}
656 };
657 }
658
~EligibilityEvalTaskCapabilities()659 EligibilityEvalTaskCapabilities::~EligibilityEvalTaskCapabilities() {
660 // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.EligibilityEvalTaskCapabilities)
661 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
662 (void)arena;
663 return;
664 }
665 SharedDtor();
666 }
667
SharedDtor()668 inline void EligibilityEvalTaskCapabilities::SharedDtor() {
669 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
670 }
671
SetCachedSize(int size) const672 void EligibilityEvalTaskCapabilities::SetCachedSize(int size) const {
673 _impl_._cached_size_.Set(size);
674 }
675
Clear()676 void EligibilityEvalTaskCapabilities::Clear() {
677 // @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.EligibilityEvalTaskCapabilities)
678 ::uint32_t cached_has_bits = 0;
679 // Prevent compiler warnings about cached_has_bits being unused
680 (void) cached_has_bits;
681
682 _impl_.supports_multiple_task_assignment_ = false;
683 _internal_metadata_.Clear<std::string>();
684 }
685
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)686 const char* EligibilityEvalTaskCapabilities::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
687 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
688 while (!ctx->Done(&ptr)) {
689 ::uint32_t tag;
690 ptr = ::_pbi::ReadTag(ptr, &tag);
691 switch (tag >> 3) {
692 // bool supports_multiple_task_assignment = 1;
693 case 1:
694 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
695 _impl_.supports_multiple_task_assignment_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
696 CHK_(ptr);
697 } else {
698 goto handle_unusual;
699 }
700 continue;
701 default:
702 goto handle_unusual;
703 } // switch
704 handle_unusual:
705 if ((tag == 0) || ((tag & 7) == 4)) {
706 CHK_(ptr);
707 ctx->SetLastTag(tag);
708 goto message_done;
709 }
710 ptr = UnknownFieldParse(
711 tag,
712 _internal_metadata_.mutable_unknown_fields<std::string>(),
713 ptr, ctx);
714 CHK_(ptr != nullptr);
715 } // while
716 message_done:
717 return ptr;
718 failure:
719 ptr = nullptr;
720 goto message_done;
721 #undef CHK_
722 }
723
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const724 ::uint8_t* EligibilityEvalTaskCapabilities::_InternalSerialize(
725 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
726 // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.EligibilityEvalTaskCapabilities)
727 ::uint32_t cached_has_bits = 0;
728 (void) cached_has_bits;
729
730 // bool supports_multiple_task_assignment = 1;
731 if (this->_internal_supports_multiple_task_assignment() != 0) {
732 target = stream->EnsureSpace(target);
733 target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_supports_multiple_task_assignment(), target);
734 }
735
736 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
737 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
738 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
739 }
740 // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.EligibilityEvalTaskCapabilities)
741 return target;
742 }
743
ByteSizeLong() const744 size_t EligibilityEvalTaskCapabilities::ByteSizeLong() const {
745 // @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.EligibilityEvalTaskCapabilities)
746 size_t total_size = 0;
747
748 ::uint32_t cached_has_bits = 0;
749 // Prevent compiler warnings about cached_has_bits being unused
750 (void) cached_has_bits;
751
752 // bool supports_multiple_task_assignment = 1;
753 if (this->_internal_supports_multiple_task_assignment() != 0) {
754 total_size += 1 + 1;
755 }
756
757 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
758 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
759 }
760 int cached_size = ::_pbi::ToCachedSize(total_size);
761 SetCachedSize(cached_size);
762 return total_size;
763 }
764
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)765 void EligibilityEvalTaskCapabilities::CheckTypeAndMergeFrom(
766 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
767 MergeFrom(*::_pbi::DownCast<const EligibilityEvalTaskCapabilities*>(
768 &from));
769 }
770
MergeFrom(const EligibilityEvalTaskCapabilities & from)771 void EligibilityEvalTaskCapabilities::MergeFrom(const EligibilityEvalTaskCapabilities& from) {
772 EligibilityEvalTaskCapabilities* const _this = this;
773 // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.EligibilityEvalTaskCapabilities)
774 GOOGLE_DCHECK_NE(&from, _this);
775 ::uint32_t cached_has_bits = 0;
776 (void) cached_has_bits;
777
778 if (from._internal_supports_multiple_task_assignment() != 0) {
779 _this->_internal_set_supports_multiple_task_assignment(from._internal_supports_multiple_task_assignment());
780 }
781 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
782 }
783
CopyFrom(const EligibilityEvalTaskCapabilities & from)784 void EligibilityEvalTaskCapabilities::CopyFrom(const EligibilityEvalTaskCapabilities& from) {
785 // @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.EligibilityEvalTaskCapabilities)
786 if (&from == this) return;
787 Clear();
788 MergeFrom(from);
789 }
790
IsInitialized() const791 bool EligibilityEvalTaskCapabilities::IsInitialized() const {
792 return true;
793 }
794
InternalSwap(EligibilityEvalTaskCapabilities * other)795 void EligibilityEvalTaskCapabilities::InternalSwap(EligibilityEvalTaskCapabilities* other) {
796 using std::swap;
797 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
798 swap(_impl_.supports_multiple_task_assignment_, other->_impl_.supports_multiple_task_assignment_);
799 }
800
GetTypeName() const801 std::string EligibilityEvalTaskCapabilities::GetTypeName() const {
802 return "google.internal.federatedcompute.v1.EligibilityEvalTaskCapabilities";
803 }
804
805
806 // ===================================================================
807
808 class EligibilityEvalTaskResponse::_Internal {
809 public:
810 static const ::google::internal::federatedcompute::v1::ForwardingInfo& task_assignment_forwarding_info(const EligibilityEvalTaskResponse* msg);
811 static const ::google::internal::federatedcompute::v1::EligibilityEvalTask& eligibility_eval_task(const EligibilityEvalTaskResponse* msg);
812 static const ::google::internal::federatedcompute::v1::NoEligibilityEvalConfigured& no_eligibility_eval_configured(const EligibilityEvalTaskResponse* msg);
813 static const ::google::internal::federatedcompute::v1::RejectionInfo& rejection_info(const EligibilityEvalTaskResponse* msg);
814 static const ::google::internal::federatedcompute::v1::RetryWindow& retry_window_if_accepted(const EligibilityEvalTaskResponse* msg);
815 static const ::google::internal::federatedcompute::v1::RetryWindow& retry_window_if_rejected(const EligibilityEvalTaskResponse* msg);
816 };
817
818 const ::google::internal::federatedcompute::v1::ForwardingInfo&
task_assignment_forwarding_info(const EligibilityEvalTaskResponse * msg)819 EligibilityEvalTaskResponse::_Internal::task_assignment_forwarding_info(const EligibilityEvalTaskResponse* msg) {
820 return *msg->_impl_.task_assignment_forwarding_info_;
821 }
822 const ::google::internal::federatedcompute::v1::EligibilityEvalTask&
eligibility_eval_task(const EligibilityEvalTaskResponse * msg)823 EligibilityEvalTaskResponse::_Internal::eligibility_eval_task(const EligibilityEvalTaskResponse* msg) {
824 return *msg->_impl_.result_.eligibility_eval_task_;
825 }
826 const ::google::internal::federatedcompute::v1::NoEligibilityEvalConfigured&
no_eligibility_eval_configured(const EligibilityEvalTaskResponse * msg)827 EligibilityEvalTaskResponse::_Internal::no_eligibility_eval_configured(const EligibilityEvalTaskResponse* msg) {
828 return *msg->_impl_.result_.no_eligibility_eval_configured_;
829 }
830 const ::google::internal::federatedcompute::v1::RejectionInfo&
rejection_info(const EligibilityEvalTaskResponse * msg)831 EligibilityEvalTaskResponse::_Internal::rejection_info(const EligibilityEvalTaskResponse* msg) {
832 return *msg->_impl_.result_.rejection_info_;
833 }
834 const ::google::internal::federatedcompute::v1::RetryWindow&
retry_window_if_accepted(const EligibilityEvalTaskResponse * msg)835 EligibilityEvalTaskResponse::_Internal::retry_window_if_accepted(const EligibilityEvalTaskResponse* msg) {
836 return *msg->_impl_.retry_window_if_accepted_;
837 }
838 const ::google::internal::federatedcompute::v1::RetryWindow&
retry_window_if_rejected(const EligibilityEvalTaskResponse * msg)839 EligibilityEvalTaskResponse::_Internal::retry_window_if_rejected(const EligibilityEvalTaskResponse* msg) {
840 return *msg->_impl_.retry_window_if_rejected_;
841 }
clear_task_assignment_forwarding_info()842 void EligibilityEvalTaskResponse::clear_task_assignment_forwarding_info() {
843 if (GetArenaForAllocation() == nullptr && _impl_.task_assignment_forwarding_info_ != nullptr) {
844 delete _impl_.task_assignment_forwarding_info_;
845 }
846 _impl_.task_assignment_forwarding_info_ = nullptr;
847 }
set_allocated_eligibility_eval_task(::google::internal::federatedcompute::v1::EligibilityEvalTask * eligibility_eval_task)848 void EligibilityEvalTaskResponse::set_allocated_eligibility_eval_task(::google::internal::federatedcompute::v1::EligibilityEvalTask* eligibility_eval_task) {
849 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
850 clear_result();
851 if (eligibility_eval_task) {
852 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
853 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(eligibility_eval_task);
854 if (message_arena != submessage_arena) {
855 eligibility_eval_task = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
856 message_arena, eligibility_eval_task, submessage_arena);
857 }
858 set_has_eligibility_eval_task();
859 _impl_.result_.eligibility_eval_task_ = eligibility_eval_task;
860 }
861 // @@protoc_insertion_point(field_set_allocated:google.internal.federatedcompute.v1.EligibilityEvalTaskResponse.eligibility_eval_task)
862 }
set_allocated_no_eligibility_eval_configured(::google::internal::federatedcompute::v1::NoEligibilityEvalConfigured * no_eligibility_eval_configured)863 void EligibilityEvalTaskResponse::set_allocated_no_eligibility_eval_configured(::google::internal::federatedcompute::v1::NoEligibilityEvalConfigured* no_eligibility_eval_configured) {
864 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
865 clear_result();
866 if (no_eligibility_eval_configured) {
867 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
868 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(no_eligibility_eval_configured);
869 if (message_arena != submessage_arena) {
870 no_eligibility_eval_configured = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
871 message_arena, no_eligibility_eval_configured, submessage_arena);
872 }
873 set_has_no_eligibility_eval_configured();
874 _impl_.result_.no_eligibility_eval_configured_ = no_eligibility_eval_configured;
875 }
876 // @@protoc_insertion_point(field_set_allocated:google.internal.federatedcompute.v1.EligibilityEvalTaskResponse.no_eligibility_eval_configured)
877 }
set_allocated_rejection_info(::google::internal::federatedcompute::v1::RejectionInfo * rejection_info)878 void EligibilityEvalTaskResponse::set_allocated_rejection_info(::google::internal::federatedcompute::v1::RejectionInfo* rejection_info) {
879 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
880 clear_result();
881 if (rejection_info) {
882 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
883 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
884 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(rejection_info));
885 if (message_arena != submessage_arena) {
886 rejection_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
887 message_arena, rejection_info, submessage_arena);
888 }
889 set_has_rejection_info();
890 _impl_.result_.rejection_info_ = rejection_info;
891 }
892 // @@protoc_insertion_point(field_set_allocated:google.internal.federatedcompute.v1.EligibilityEvalTaskResponse.rejection_info)
893 }
clear_rejection_info()894 void EligibilityEvalTaskResponse::clear_rejection_info() {
895 if (_internal_has_rejection_info()) {
896 if (GetArenaForAllocation() == nullptr) {
897 delete _impl_.result_.rejection_info_;
898 }
899 clear_has_result();
900 }
901 }
clear_retry_window_if_accepted()902 void EligibilityEvalTaskResponse::clear_retry_window_if_accepted() {
903 if (GetArenaForAllocation() == nullptr && _impl_.retry_window_if_accepted_ != nullptr) {
904 delete _impl_.retry_window_if_accepted_;
905 }
906 _impl_.retry_window_if_accepted_ = nullptr;
907 }
clear_retry_window_if_rejected()908 void EligibilityEvalTaskResponse::clear_retry_window_if_rejected() {
909 if (GetArenaForAllocation() == nullptr && _impl_.retry_window_if_rejected_ != nullptr) {
910 delete _impl_.retry_window_if_rejected_;
911 }
912 _impl_.retry_window_if_rejected_ = nullptr;
913 }
EligibilityEvalTaskResponse(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)914 EligibilityEvalTaskResponse::EligibilityEvalTaskResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
915 bool is_message_owned)
916 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
917 SharedCtor(arena, is_message_owned);
918 // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.EligibilityEvalTaskResponse)
919 }
EligibilityEvalTaskResponse(const EligibilityEvalTaskResponse & from)920 EligibilityEvalTaskResponse::EligibilityEvalTaskResponse(const EligibilityEvalTaskResponse& from)
921 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
922 EligibilityEvalTaskResponse* const _this = this; (void)_this;
923 new (&_impl_) Impl_{
924 decltype(_impl_.session_id_){}
925 , decltype(_impl_.task_assignment_forwarding_info_){nullptr}
926 , decltype(_impl_.retry_window_if_accepted_){nullptr}
927 , decltype(_impl_.retry_window_if_rejected_){nullptr}
928 , decltype(_impl_.result_){}
929 , /*decltype(_impl_._cached_size_)*/{}
930 , /*decltype(_impl_._oneof_case_)*/{}};
931
932 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
933 _impl_.session_id_.InitDefault();
934 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
935 _impl_.session_id_.Set("", GetArenaForAllocation());
936 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
937 if (!from._internal_session_id().empty()) {
938 _this->_impl_.session_id_.Set(from._internal_session_id(),
939 _this->GetArenaForAllocation());
940 }
941 if (from._internal_has_task_assignment_forwarding_info()) {
942 _this->_impl_.task_assignment_forwarding_info_ = new ::google::internal::federatedcompute::v1::ForwardingInfo(*from._impl_.task_assignment_forwarding_info_);
943 }
944 if (from._internal_has_retry_window_if_accepted()) {
945 _this->_impl_.retry_window_if_accepted_ = new ::google::internal::federatedcompute::v1::RetryWindow(*from._impl_.retry_window_if_accepted_);
946 }
947 if (from._internal_has_retry_window_if_rejected()) {
948 _this->_impl_.retry_window_if_rejected_ = new ::google::internal::federatedcompute::v1::RetryWindow(*from._impl_.retry_window_if_rejected_);
949 }
950 clear_has_result();
951 switch (from.result_case()) {
952 case kEligibilityEvalTask: {
953 _this->_internal_mutable_eligibility_eval_task()->::google::internal::federatedcompute::v1::EligibilityEvalTask::MergeFrom(
954 from._internal_eligibility_eval_task());
955 break;
956 }
957 case kNoEligibilityEvalConfigured: {
958 _this->_internal_mutable_no_eligibility_eval_configured()->::google::internal::federatedcompute::v1::NoEligibilityEvalConfigured::MergeFrom(
959 from._internal_no_eligibility_eval_configured());
960 break;
961 }
962 case kRejectionInfo: {
963 _this->_internal_mutable_rejection_info()->::google::internal::federatedcompute::v1::RejectionInfo::MergeFrom(
964 from._internal_rejection_info());
965 break;
966 }
967 case RESULT_NOT_SET: {
968 break;
969 }
970 }
971 // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.EligibilityEvalTaskResponse)
972 }
973
SharedCtor(::_pb::Arena * arena,bool is_message_owned)974 inline void EligibilityEvalTaskResponse::SharedCtor(
975 ::_pb::Arena* arena, bool is_message_owned) {
976 (void)arena;
977 (void)is_message_owned;
978 new (&_impl_) Impl_{
979 decltype(_impl_.session_id_){}
980 , decltype(_impl_.task_assignment_forwarding_info_){nullptr}
981 , decltype(_impl_.retry_window_if_accepted_){nullptr}
982 , decltype(_impl_.retry_window_if_rejected_){nullptr}
983 , decltype(_impl_.result_){}
984 , /*decltype(_impl_._cached_size_)*/{}
985 , /*decltype(_impl_._oneof_case_)*/{}
986 };
987 _impl_.session_id_.InitDefault();
988 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
989 _impl_.session_id_.Set("", GetArenaForAllocation());
990 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
991 clear_has_result();
992 }
993
~EligibilityEvalTaskResponse()994 EligibilityEvalTaskResponse::~EligibilityEvalTaskResponse() {
995 // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.EligibilityEvalTaskResponse)
996 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
997 (void)arena;
998 return;
999 }
1000 SharedDtor();
1001 }
1002
SharedDtor()1003 inline void EligibilityEvalTaskResponse::SharedDtor() {
1004 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1005 _impl_.session_id_.Destroy();
1006 if (this != internal_default_instance()) delete _impl_.task_assignment_forwarding_info_;
1007 if (this != internal_default_instance()) delete _impl_.retry_window_if_accepted_;
1008 if (this != internal_default_instance()) delete _impl_.retry_window_if_rejected_;
1009 if (has_result()) {
1010 clear_result();
1011 }
1012 }
1013
SetCachedSize(int size) const1014 void EligibilityEvalTaskResponse::SetCachedSize(int size) const {
1015 _impl_._cached_size_.Set(size);
1016 }
1017
clear_result()1018 void EligibilityEvalTaskResponse::clear_result() {
1019 // @@protoc_insertion_point(one_of_clear_start:google.internal.federatedcompute.v1.EligibilityEvalTaskResponse)
1020 switch (result_case()) {
1021 case kEligibilityEvalTask: {
1022 if (GetArenaForAllocation() == nullptr) {
1023 delete _impl_.result_.eligibility_eval_task_;
1024 }
1025 break;
1026 }
1027 case kNoEligibilityEvalConfigured: {
1028 if (GetArenaForAllocation() == nullptr) {
1029 delete _impl_.result_.no_eligibility_eval_configured_;
1030 }
1031 break;
1032 }
1033 case kRejectionInfo: {
1034 if (GetArenaForAllocation() == nullptr) {
1035 delete _impl_.result_.rejection_info_;
1036 }
1037 break;
1038 }
1039 case RESULT_NOT_SET: {
1040 break;
1041 }
1042 }
1043 _impl_._oneof_case_[0] = RESULT_NOT_SET;
1044 }
1045
1046
Clear()1047 void EligibilityEvalTaskResponse::Clear() {
1048 // @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.EligibilityEvalTaskResponse)
1049 ::uint32_t cached_has_bits = 0;
1050 // Prevent compiler warnings about cached_has_bits being unused
1051 (void) cached_has_bits;
1052
1053 _impl_.session_id_.ClearToEmpty();
1054 if (GetArenaForAllocation() == nullptr && _impl_.task_assignment_forwarding_info_ != nullptr) {
1055 delete _impl_.task_assignment_forwarding_info_;
1056 }
1057 _impl_.task_assignment_forwarding_info_ = nullptr;
1058 if (GetArenaForAllocation() == nullptr && _impl_.retry_window_if_accepted_ != nullptr) {
1059 delete _impl_.retry_window_if_accepted_;
1060 }
1061 _impl_.retry_window_if_accepted_ = nullptr;
1062 if (GetArenaForAllocation() == nullptr && _impl_.retry_window_if_rejected_ != nullptr) {
1063 delete _impl_.retry_window_if_rejected_;
1064 }
1065 _impl_.retry_window_if_rejected_ = nullptr;
1066 clear_result();
1067 _internal_metadata_.Clear<std::string>();
1068 }
1069
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1070 const char* EligibilityEvalTaskResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1071 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1072 while (!ctx->Done(&ptr)) {
1073 ::uint32_t tag;
1074 ptr = ::_pbi::ReadTag(ptr, &tag);
1075 switch (tag >> 3) {
1076 // .google.internal.federatedcompute.v1.ForwardingInfo task_assignment_forwarding_info = 1;
1077 case 1:
1078 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1079 ptr = ctx->ParseMessage(_internal_mutable_task_assignment_forwarding_info(), ptr);
1080 CHK_(ptr);
1081 } else {
1082 goto handle_unusual;
1083 }
1084 continue;
1085 // string session_id = 2;
1086 case 2:
1087 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1088 auto str = _internal_mutable_session_id();
1089 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1090 CHK_(ptr);
1091 CHK_(::_pbi::VerifyUTF8(str, nullptr));
1092 } else {
1093 goto handle_unusual;
1094 }
1095 continue;
1096 // .google.internal.federatedcompute.v1.EligibilityEvalTask eligibility_eval_task = 3;
1097 case 3:
1098 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
1099 ptr = ctx->ParseMessage(_internal_mutable_eligibility_eval_task(), ptr);
1100 CHK_(ptr);
1101 } else {
1102 goto handle_unusual;
1103 }
1104 continue;
1105 // .google.internal.federatedcompute.v1.NoEligibilityEvalConfigured no_eligibility_eval_configured = 4;
1106 case 4:
1107 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
1108 ptr = ctx->ParseMessage(_internal_mutable_no_eligibility_eval_configured(), ptr);
1109 CHK_(ptr);
1110 } else {
1111 goto handle_unusual;
1112 }
1113 continue;
1114 // .google.internal.federatedcompute.v1.RejectionInfo rejection_info = 5;
1115 case 5:
1116 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
1117 ptr = ctx->ParseMessage(_internal_mutable_rejection_info(), ptr);
1118 CHK_(ptr);
1119 } else {
1120 goto handle_unusual;
1121 }
1122 continue;
1123 // .google.internal.federatedcompute.v1.RetryWindow retry_window_if_accepted = 6;
1124 case 6:
1125 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
1126 ptr = ctx->ParseMessage(_internal_mutable_retry_window_if_accepted(), ptr);
1127 CHK_(ptr);
1128 } else {
1129 goto handle_unusual;
1130 }
1131 continue;
1132 // .google.internal.federatedcompute.v1.RetryWindow retry_window_if_rejected = 7;
1133 case 7:
1134 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 58)) {
1135 ptr = ctx->ParseMessage(_internal_mutable_retry_window_if_rejected(), ptr);
1136 CHK_(ptr);
1137 } else {
1138 goto handle_unusual;
1139 }
1140 continue;
1141 default:
1142 goto handle_unusual;
1143 } // switch
1144 handle_unusual:
1145 if ((tag == 0) || ((tag & 7) == 4)) {
1146 CHK_(ptr);
1147 ctx->SetLastTag(tag);
1148 goto message_done;
1149 }
1150 ptr = UnknownFieldParse(
1151 tag,
1152 _internal_metadata_.mutable_unknown_fields<std::string>(),
1153 ptr, ctx);
1154 CHK_(ptr != nullptr);
1155 } // while
1156 message_done:
1157 return ptr;
1158 failure:
1159 ptr = nullptr;
1160 goto message_done;
1161 #undef CHK_
1162 }
1163
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1164 ::uint8_t* EligibilityEvalTaskResponse::_InternalSerialize(
1165 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1166 // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.EligibilityEvalTaskResponse)
1167 ::uint32_t cached_has_bits = 0;
1168 (void) cached_has_bits;
1169
1170 // .google.internal.federatedcompute.v1.ForwardingInfo task_assignment_forwarding_info = 1;
1171 if (this->_internal_has_task_assignment_forwarding_info()) {
1172 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1173 InternalWriteMessage(1, _Internal::task_assignment_forwarding_info(this),
1174 _Internal::task_assignment_forwarding_info(this).GetCachedSize(), target, stream);
1175 }
1176
1177 // string session_id = 2;
1178 if (!this->_internal_session_id().empty()) {
1179 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1180 this->_internal_session_id().data(), static_cast<int>(this->_internal_session_id().length()),
1181 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1182 "google.internal.federatedcompute.v1.EligibilityEvalTaskResponse.session_id");
1183 target = stream->WriteStringMaybeAliased(
1184 2, this->_internal_session_id(), target);
1185 }
1186
1187 // .google.internal.federatedcompute.v1.EligibilityEvalTask eligibility_eval_task = 3;
1188 if (_internal_has_eligibility_eval_task()) {
1189 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1190 InternalWriteMessage(3, _Internal::eligibility_eval_task(this),
1191 _Internal::eligibility_eval_task(this).GetCachedSize(), target, stream);
1192 }
1193
1194 // .google.internal.federatedcompute.v1.NoEligibilityEvalConfigured no_eligibility_eval_configured = 4;
1195 if (_internal_has_no_eligibility_eval_configured()) {
1196 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1197 InternalWriteMessage(4, _Internal::no_eligibility_eval_configured(this),
1198 _Internal::no_eligibility_eval_configured(this).GetCachedSize(), target, stream);
1199 }
1200
1201 // .google.internal.federatedcompute.v1.RejectionInfo rejection_info = 5;
1202 if (_internal_has_rejection_info()) {
1203 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1204 InternalWriteMessage(5, _Internal::rejection_info(this),
1205 _Internal::rejection_info(this).GetCachedSize(), target, stream);
1206 }
1207
1208 // .google.internal.federatedcompute.v1.RetryWindow retry_window_if_accepted = 6;
1209 if (this->_internal_has_retry_window_if_accepted()) {
1210 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1211 InternalWriteMessage(6, _Internal::retry_window_if_accepted(this),
1212 _Internal::retry_window_if_accepted(this).GetCachedSize(), target, stream);
1213 }
1214
1215 // .google.internal.federatedcompute.v1.RetryWindow retry_window_if_rejected = 7;
1216 if (this->_internal_has_retry_window_if_rejected()) {
1217 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1218 InternalWriteMessage(7, _Internal::retry_window_if_rejected(this),
1219 _Internal::retry_window_if_rejected(this).GetCachedSize(), target, stream);
1220 }
1221
1222 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1223 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1224 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1225 }
1226 // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.EligibilityEvalTaskResponse)
1227 return target;
1228 }
1229
ByteSizeLong() const1230 size_t EligibilityEvalTaskResponse::ByteSizeLong() const {
1231 // @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.EligibilityEvalTaskResponse)
1232 size_t total_size = 0;
1233
1234 ::uint32_t cached_has_bits = 0;
1235 // Prevent compiler warnings about cached_has_bits being unused
1236 (void) cached_has_bits;
1237
1238 // string session_id = 2;
1239 if (!this->_internal_session_id().empty()) {
1240 total_size += 1 +
1241 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1242 this->_internal_session_id());
1243 }
1244
1245 // .google.internal.federatedcompute.v1.ForwardingInfo task_assignment_forwarding_info = 1;
1246 if (this->_internal_has_task_assignment_forwarding_info()) {
1247 total_size += 1 +
1248 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1249 *_impl_.task_assignment_forwarding_info_);
1250 }
1251
1252 // .google.internal.federatedcompute.v1.RetryWindow retry_window_if_accepted = 6;
1253 if (this->_internal_has_retry_window_if_accepted()) {
1254 total_size += 1 +
1255 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1256 *_impl_.retry_window_if_accepted_);
1257 }
1258
1259 // .google.internal.federatedcompute.v1.RetryWindow retry_window_if_rejected = 7;
1260 if (this->_internal_has_retry_window_if_rejected()) {
1261 total_size += 1 +
1262 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1263 *_impl_.retry_window_if_rejected_);
1264 }
1265
1266 switch (result_case()) {
1267 // .google.internal.federatedcompute.v1.EligibilityEvalTask eligibility_eval_task = 3;
1268 case kEligibilityEvalTask: {
1269 total_size += 1 +
1270 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1271 *_impl_.result_.eligibility_eval_task_);
1272 break;
1273 }
1274 // .google.internal.federatedcompute.v1.NoEligibilityEvalConfigured no_eligibility_eval_configured = 4;
1275 case kNoEligibilityEvalConfigured: {
1276 total_size += 1 +
1277 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1278 *_impl_.result_.no_eligibility_eval_configured_);
1279 break;
1280 }
1281 // .google.internal.federatedcompute.v1.RejectionInfo rejection_info = 5;
1282 case kRejectionInfo: {
1283 total_size += 1 +
1284 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1285 *_impl_.result_.rejection_info_);
1286 break;
1287 }
1288 case RESULT_NOT_SET: {
1289 break;
1290 }
1291 }
1292 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1293 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1294 }
1295 int cached_size = ::_pbi::ToCachedSize(total_size);
1296 SetCachedSize(cached_size);
1297 return total_size;
1298 }
1299
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1300 void EligibilityEvalTaskResponse::CheckTypeAndMergeFrom(
1301 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1302 MergeFrom(*::_pbi::DownCast<const EligibilityEvalTaskResponse*>(
1303 &from));
1304 }
1305
MergeFrom(const EligibilityEvalTaskResponse & from)1306 void EligibilityEvalTaskResponse::MergeFrom(const EligibilityEvalTaskResponse& from) {
1307 EligibilityEvalTaskResponse* const _this = this;
1308 // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.EligibilityEvalTaskResponse)
1309 GOOGLE_DCHECK_NE(&from, _this);
1310 ::uint32_t cached_has_bits = 0;
1311 (void) cached_has_bits;
1312
1313 if (!from._internal_session_id().empty()) {
1314 _this->_internal_set_session_id(from._internal_session_id());
1315 }
1316 if (from._internal_has_task_assignment_forwarding_info()) {
1317 _this->_internal_mutable_task_assignment_forwarding_info()->::google::internal::federatedcompute::v1::ForwardingInfo::MergeFrom(
1318 from._internal_task_assignment_forwarding_info());
1319 }
1320 if (from._internal_has_retry_window_if_accepted()) {
1321 _this->_internal_mutable_retry_window_if_accepted()->::google::internal::federatedcompute::v1::RetryWindow::MergeFrom(
1322 from._internal_retry_window_if_accepted());
1323 }
1324 if (from._internal_has_retry_window_if_rejected()) {
1325 _this->_internal_mutable_retry_window_if_rejected()->::google::internal::federatedcompute::v1::RetryWindow::MergeFrom(
1326 from._internal_retry_window_if_rejected());
1327 }
1328 switch (from.result_case()) {
1329 case kEligibilityEvalTask: {
1330 _this->_internal_mutable_eligibility_eval_task()->::google::internal::federatedcompute::v1::EligibilityEvalTask::MergeFrom(
1331 from._internal_eligibility_eval_task());
1332 break;
1333 }
1334 case kNoEligibilityEvalConfigured: {
1335 _this->_internal_mutable_no_eligibility_eval_configured()->::google::internal::federatedcompute::v1::NoEligibilityEvalConfigured::MergeFrom(
1336 from._internal_no_eligibility_eval_configured());
1337 break;
1338 }
1339 case kRejectionInfo: {
1340 _this->_internal_mutable_rejection_info()->::google::internal::federatedcompute::v1::RejectionInfo::MergeFrom(
1341 from._internal_rejection_info());
1342 break;
1343 }
1344 case RESULT_NOT_SET: {
1345 break;
1346 }
1347 }
1348 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1349 }
1350
CopyFrom(const EligibilityEvalTaskResponse & from)1351 void EligibilityEvalTaskResponse::CopyFrom(const EligibilityEvalTaskResponse& from) {
1352 // @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.EligibilityEvalTaskResponse)
1353 if (&from == this) return;
1354 Clear();
1355 MergeFrom(from);
1356 }
1357
IsInitialized() const1358 bool EligibilityEvalTaskResponse::IsInitialized() const {
1359 return true;
1360 }
1361
InternalSwap(EligibilityEvalTaskResponse * other)1362 void EligibilityEvalTaskResponse::InternalSwap(EligibilityEvalTaskResponse* other) {
1363 using std::swap;
1364 auto* lhs_arena = GetArenaForAllocation();
1365 auto* rhs_arena = other->GetArenaForAllocation();
1366 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1367 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1368 &_impl_.session_id_, lhs_arena,
1369 &other->_impl_.session_id_, rhs_arena
1370 );
1371 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1372 PROTOBUF_FIELD_OFFSET(EligibilityEvalTaskResponse, _impl_.retry_window_if_rejected_)
1373 + sizeof(EligibilityEvalTaskResponse::_impl_.retry_window_if_rejected_) // NOLINT
1374 - PROTOBUF_FIELD_OFFSET(EligibilityEvalTaskResponse, _impl_.task_assignment_forwarding_info_)>(
1375 reinterpret_cast<char*>(&_impl_.task_assignment_forwarding_info_),
1376 reinterpret_cast<char*>(&other->_impl_.task_assignment_forwarding_info_));
1377 swap(_impl_.result_, other->_impl_.result_);
1378 swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
1379 }
1380
GetTypeName() const1381 std::string EligibilityEvalTaskResponse::GetTypeName() const {
1382 return "google.internal.federatedcompute.v1.EligibilityEvalTaskResponse";
1383 }
1384
1385
1386 // ===================================================================
1387
1388 class EligibilityEvalTask::_Internal {
1389 public:
1390 static const ::google::internal::federatedcompute::v1::Resource& init_checkpoint(const EligibilityEvalTask* msg);
1391 static const ::google::internal::federatedcompute::v1::Resource& plan(const EligibilityEvalTask* msg);
1392 static const ::google::internal::federatedcompute::v1::Resource& population_eligibility_spec(const EligibilityEvalTask* msg);
1393 };
1394
1395 const ::google::internal::federatedcompute::v1::Resource&
init_checkpoint(const EligibilityEvalTask * msg)1396 EligibilityEvalTask::_Internal::init_checkpoint(const EligibilityEvalTask* msg) {
1397 return *msg->_impl_.init_checkpoint_;
1398 }
1399 const ::google::internal::federatedcompute::v1::Resource&
plan(const EligibilityEvalTask * msg)1400 EligibilityEvalTask::_Internal::plan(const EligibilityEvalTask* msg) {
1401 return *msg->_impl_.plan_;
1402 }
1403 const ::google::internal::federatedcompute::v1::Resource&
population_eligibility_spec(const EligibilityEvalTask * msg)1404 EligibilityEvalTask::_Internal::population_eligibility_spec(const EligibilityEvalTask* msg) {
1405 return *msg->_impl_.population_eligibility_spec_;
1406 }
clear_init_checkpoint()1407 void EligibilityEvalTask::clear_init_checkpoint() {
1408 if (GetArenaForAllocation() == nullptr && _impl_.init_checkpoint_ != nullptr) {
1409 delete _impl_.init_checkpoint_;
1410 }
1411 _impl_.init_checkpoint_ = nullptr;
1412 }
clear_plan()1413 void EligibilityEvalTask::clear_plan() {
1414 if (GetArenaForAllocation() == nullptr && _impl_.plan_ != nullptr) {
1415 delete _impl_.plan_;
1416 }
1417 _impl_.plan_ = nullptr;
1418 }
clear_population_eligibility_spec()1419 void EligibilityEvalTask::clear_population_eligibility_spec() {
1420 if (GetArenaForAllocation() == nullptr && _impl_.population_eligibility_spec_ != nullptr) {
1421 delete _impl_.population_eligibility_spec_;
1422 }
1423 _impl_.population_eligibility_spec_ = nullptr;
1424 }
EligibilityEvalTask(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1425 EligibilityEvalTask::EligibilityEvalTask(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1426 bool is_message_owned)
1427 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1428 SharedCtor(arena, is_message_owned);
1429 // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.EligibilityEvalTask)
1430 }
EligibilityEvalTask(const EligibilityEvalTask & from)1431 EligibilityEvalTask::EligibilityEvalTask(const EligibilityEvalTask& from)
1432 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1433 EligibilityEvalTask* const _this = this; (void)_this;
1434 new (&_impl_) Impl_{
1435 decltype(_impl_.execution_id_){}
1436 , decltype(_impl_.init_checkpoint_){nullptr}
1437 , decltype(_impl_.plan_){nullptr}
1438 , decltype(_impl_.population_eligibility_spec_){nullptr}
1439 , /*decltype(_impl_._cached_size_)*/{}};
1440
1441 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1442 _impl_.execution_id_.InitDefault();
1443 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1444 _impl_.execution_id_.Set("", GetArenaForAllocation());
1445 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1446 if (!from._internal_execution_id().empty()) {
1447 _this->_impl_.execution_id_.Set(from._internal_execution_id(),
1448 _this->GetArenaForAllocation());
1449 }
1450 if (from._internal_has_init_checkpoint()) {
1451 _this->_impl_.init_checkpoint_ = new ::google::internal::federatedcompute::v1::Resource(*from._impl_.init_checkpoint_);
1452 }
1453 if (from._internal_has_plan()) {
1454 _this->_impl_.plan_ = new ::google::internal::federatedcompute::v1::Resource(*from._impl_.plan_);
1455 }
1456 if (from._internal_has_population_eligibility_spec()) {
1457 _this->_impl_.population_eligibility_spec_ = new ::google::internal::federatedcompute::v1::Resource(*from._impl_.population_eligibility_spec_);
1458 }
1459 // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.EligibilityEvalTask)
1460 }
1461
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1462 inline void EligibilityEvalTask::SharedCtor(
1463 ::_pb::Arena* arena, bool is_message_owned) {
1464 (void)arena;
1465 (void)is_message_owned;
1466 new (&_impl_) Impl_{
1467 decltype(_impl_.execution_id_){}
1468 , decltype(_impl_.init_checkpoint_){nullptr}
1469 , decltype(_impl_.plan_){nullptr}
1470 , decltype(_impl_.population_eligibility_spec_){nullptr}
1471 , /*decltype(_impl_._cached_size_)*/{}
1472 };
1473 _impl_.execution_id_.InitDefault();
1474 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1475 _impl_.execution_id_.Set("", GetArenaForAllocation());
1476 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1477 }
1478
~EligibilityEvalTask()1479 EligibilityEvalTask::~EligibilityEvalTask() {
1480 // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.EligibilityEvalTask)
1481 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1482 (void)arena;
1483 return;
1484 }
1485 SharedDtor();
1486 }
1487
SharedDtor()1488 inline void EligibilityEvalTask::SharedDtor() {
1489 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1490 _impl_.execution_id_.Destroy();
1491 if (this != internal_default_instance()) delete _impl_.init_checkpoint_;
1492 if (this != internal_default_instance()) delete _impl_.plan_;
1493 if (this != internal_default_instance()) delete _impl_.population_eligibility_spec_;
1494 }
1495
SetCachedSize(int size) const1496 void EligibilityEvalTask::SetCachedSize(int size) const {
1497 _impl_._cached_size_.Set(size);
1498 }
1499
Clear()1500 void EligibilityEvalTask::Clear() {
1501 // @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.EligibilityEvalTask)
1502 ::uint32_t cached_has_bits = 0;
1503 // Prevent compiler warnings about cached_has_bits being unused
1504 (void) cached_has_bits;
1505
1506 _impl_.execution_id_.ClearToEmpty();
1507 if (GetArenaForAllocation() == nullptr && _impl_.init_checkpoint_ != nullptr) {
1508 delete _impl_.init_checkpoint_;
1509 }
1510 _impl_.init_checkpoint_ = nullptr;
1511 if (GetArenaForAllocation() == nullptr && _impl_.plan_ != nullptr) {
1512 delete _impl_.plan_;
1513 }
1514 _impl_.plan_ = nullptr;
1515 if (GetArenaForAllocation() == nullptr && _impl_.population_eligibility_spec_ != nullptr) {
1516 delete _impl_.population_eligibility_spec_;
1517 }
1518 _impl_.population_eligibility_spec_ = nullptr;
1519 _internal_metadata_.Clear<std::string>();
1520 }
1521
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1522 const char* EligibilityEvalTask::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1523 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1524 while (!ctx->Done(&ptr)) {
1525 ::uint32_t tag;
1526 ptr = ::_pbi::ReadTag(ptr, &tag);
1527 switch (tag >> 3) {
1528 // .google.internal.federatedcompute.v1.Resource init_checkpoint = 1;
1529 case 1:
1530 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1531 ptr = ctx->ParseMessage(_internal_mutable_init_checkpoint(), ptr);
1532 CHK_(ptr);
1533 } else {
1534 goto handle_unusual;
1535 }
1536 continue;
1537 // .google.internal.federatedcompute.v1.Resource plan = 2;
1538 case 2:
1539 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1540 ptr = ctx->ParseMessage(_internal_mutable_plan(), ptr);
1541 CHK_(ptr);
1542 } else {
1543 goto handle_unusual;
1544 }
1545 continue;
1546 // string execution_id = 3;
1547 case 3:
1548 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
1549 auto str = _internal_mutable_execution_id();
1550 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1551 CHK_(ptr);
1552 CHK_(::_pbi::VerifyUTF8(str, nullptr));
1553 } else {
1554 goto handle_unusual;
1555 }
1556 continue;
1557 // .google.internal.federatedcompute.v1.Resource population_eligibility_spec = 4;
1558 case 4:
1559 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
1560 ptr = ctx->ParseMessage(_internal_mutable_population_eligibility_spec(), ptr);
1561 CHK_(ptr);
1562 } else {
1563 goto handle_unusual;
1564 }
1565 continue;
1566 default:
1567 goto handle_unusual;
1568 } // switch
1569 handle_unusual:
1570 if ((tag == 0) || ((tag & 7) == 4)) {
1571 CHK_(ptr);
1572 ctx->SetLastTag(tag);
1573 goto message_done;
1574 }
1575 ptr = UnknownFieldParse(
1576 tag,
1577 _internal_metadata_.mutable_unknown_fields<std::string>(),
1578 ptr, ctx);
1579 CHK_(ptr != nullptr);
1580 } // while
1581 message_done:
1582 return ptr;
1583 failure:
1584 ptr = nullptr;
1585 goto message_done;
1586 #undef CHK_
1587 }
1588
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1589 ::uint8_t* EligibilityEvalTask::_InternalSerialize(
1590 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1591 // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.EligibilityEvalTask)
1592 ::uint32_t cached_has_bits = 0;
1593 (void) cached_has_bits;
1594
1595 // .google.internal.federatedcompute.v1.Resource init_checkpoint = 1;
1596 if (this->_internal_has_init_checkpoint()) {
1597 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1598 InternalWriteMessage(1, _Internal::init_checkpoint(this),
1599 _Internal::init_checkpoint(this).GetCachedSize(), target, stream);
1600 }
1601
1602 // .google.internal.federatedcompute.v1.Resource plan = 2;
1603 if (this->_internal_has_plan()) {
1604 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1605 InternalWriteMessage(2, _Internal::plan(this),
1606 _Internal::plan(this).GetCachedSize(), target, stream);
1607 }
1608
1609 // string execution_id = 3;
1610 if (!this->_internal_execution_id().empty()) {
1611 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1612 this->_internal_execution_id().data(), static_cast<int>(this->_internal_execution_id().length()),
1613 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1614 "google.internal.federatedcompute.v1.EligibilityEvalTask.execution_id");
1615 target = stream->WriteStringMaybeAliased(
1616 3, this->_internal_execution_id(), target);
1617 }
1618
1619 // .google.internal.federatedcompute.v1.Resource population_eligibility_spec = 4;
1620 if (this->_internal_has_population_eligibility_spec()) {
1621 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1622 InternalWriteMessage(4, _Internal::population_eligibility_spec(this),
1623 _Internal::population_eligibility_spec(this).GetCachedSize(), target, stream);
1624 }
1625
1626 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1627 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1628 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1629 }
1630 // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.EligibilityEvalTask)
1631 return target;
1632 }
1633
ByteSizeLong() const1634 size_t EligibilityEvalTask::ByteSizeLong() const {
1635 // @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.EligibilityEvalTask)
1636 size_t total_size = 0;
1637
1638 ::uint32_t cached_has_bits = 0;
1639 // Prevent compiler warnings about cached_has_bits being unused
1640 (void) cached_has_bits;
1641
1642 // string execution_id = 3;
1643 if (!this->_internal_execution_id().empty()) {
1644 total_size += 1 +
1645 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1646 this->_internal_execution_id());
1647 }
1648
1649 // .google.internal.federatedcompute.v1.Resource init_checkpoint = 1;
1650 if (this->_internal_has_init_checkpoint()) {
1651 total_size += 1 +
1652 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1653 *_impl_.init_checkpoint_);
1654 }
1655
1656 // .google.internal.federatedcompute.v1.Resource plan = 2;
1657 if (this->_internal_has_plan()) {
1658 total_size += 1 +
1659 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1660 *_impl_.plan_);
1661 }
1662
1663 // .google.internal.federatedcompute.v1.Resource population_eligibility_spec = 4;
1664 if (this->_internal_has_population_eligibility_spec()) {
1665 total_size += 1 +
1666 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1667 *_impl_.population_eligibility_spec_);
1668 }
1669
1670 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1671 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1672 }
1673 int cached_size = ::_pbi::ToCachedSize(total_size);
1674 SetCachedSize(cached_size);
1675 return total_size;
1676 }
1677
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1678 void EligibilityEvalTask::CheckTypeAndMergeFrom(
1679 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1680 MergeFrom(*::_pbi::DownCast<const EligibilityEvalTask*>(
1681 &from));
1682 }
1683
MergeFrom(const EligibilityEvalTask & from)1684 void EligibilityEvalTask::MergeFrom(const EligibilityEvalTask& from) {
1685 EligibilityEvalTask* const _this = this;
1686 // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.EligibilityEvalTask)
1687 GOOGLE_DCHECK_NE(&from, _this);
1688 ::uint32_t cached_has_bits = 0;
1689 (void) cached_has_bits;
1690
1691 if (!from._internal_execution_id().empty()) {
1692 _this->_internal_set_execution_id(from._internal_execution_id());
1693 }
1694 if (from._internal_has_init_checkpoint()) {
1695 _this->_internal_mutable_init_checkpoint()->::google::internal::federatedcompute::v1::Resource::MergeFrom(
1696 from._internal_init_checkpoint());
1697 }
1698 if (from._internal_has_plan()) {
1699 _this->_internal_mutable_plan()->::google::internal::federatedcompute::v1::Resource::MergeFrom(
1700 from._internal_plan());
1701 }
1702 if (from._internal_has_population_eligibility_spec()) {
1703 _this->_internal_mutable_population_eligibility_spec()->::google::internal::federatedcompute::v1::Resource::MergeFrom(
1704 from._internal_population_eligibility_spec());
1705 }
1706 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1707 }
1708
CopyFrom(const EligibilityEvalTask & from)1709 void EligibilityEvalTask::CopyFrom(const EligibilityEvalTask& from) {
1710 // @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.EligibilityEvalTask)
1711 if (&from == this) return;
1712 Clear();
1713 MergeFrom(from);
1714 }
1715
IsInitialized() const1716 bool EligibilityEvalTask::IsInitialized() const {
1717 return true;
1718 }
1719
InternalSwap(EligibilityEvalTask * other)1720 void EligibilityEvalTask::InternalSwap(EligibilityEvalTask* other) {
1721 using std::swap;
1722 auto* lhs_arena = GetArenaForAllocation();
1723 auto* rhs_arena = other->GetArenaForAllocation();
1724 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1725 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1726 &_impl_.execution_id_, lhs_arena,
1727 &other->_impl_.execution_id_, rhs_arena
1728 );
1729 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1730 PROTOBUF_FIELD_OFFSET(EligibilityEvalTask, _impl_.population_eligibility_spec_)
1731 + sizeof(EligibilityEvalTask::_impl_.population_eligibility_spec_) // NOLINT
1732 - PROTOBUF_FIELD_OFFSET(EligibilityEvalTask, _impl_.init_checkpoint_)>(
1733 reinterpret_cast<char*>(&_impl_.init_checkpoint_),
1734 reinterpret_cast<char*>(&other->_impl_.init_checkpoint_));
1735 }
1736
GetTypeName() const1737 std::string EligibilityEvalTask::GetTypeName() const {
1738 return "google.internal.federatedcompute.v1.EligibilityEvalTask";
1739 }
1740
1741
1742 // ===================================================================
1743
1744 class NoEligibilityEvalConfigured::_Internal {
1745 public:
1746 };
1747
NoEligibilityEvalConfigured(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1748 NoEligibilityEvalConfigured::NoEligibilityEvalConfigured(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1749 bool is_message_owned)
1750 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1751 SharedCtor(arena, is_message_owned);
1752 // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.NoEligibilityEvalConfigured)
1753 }
NoEligibilityEvalConfigured(const NoEligibilityEvalConfigured & from)1754 NoEligibilityEvalConfigured::NoEligibilityEvalConfigured(const NoEligibilityEvalConfigured& from)
1755 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1756 NoEligibilityEvalConfigured* const _this = this; (void)_this;
1757 new (&_impl_) Impl_{
1758 /*decltype(_impl_._cached_size_)*/{}};
1759
1760 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1761 // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.NoEligibilityEvalConfigured)
1762 }
1763
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1764 inline void NoEligibilityEvalConfigured::SharedCtor(
1765 ::_pb::Arena* arena, bool is_message_owned) {
1766 (void)arena;
1767 (void)is_message_owned;
1768 new (&_impl_) Impl_{
1769 /*decltype(_impl_._cached_size_)*/{}
1770 };
1771 }
1772
~NoEligibilityEvalConfigured()1773 NoEligibilityEvalConfigured::~NoEligibilityEvalConfigured() {
1774 // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.NoEligibilityEvalConfigured)
1775 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1776 (void)arena;
1777 return;
1778 }
1779 SharedDtor();
1780 }
1781
SharedDtor()1782 inline void NoEligibilityEvalConfigured::SharedDtor() {
1783 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1784 }
1785
SetCachedSize(int size) const1786 void NoEligibilityEvalConfigured::SetCachedSize(int size) const {
1787 _impl_._cached_size_.Set(size);
1788 }
1789
Clear()1790 void NoEligibilityEvalConfigured::Clear() {
1791 // @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.NoEligibilityEvalConfigured)
1792 ::uint32_t cached_has_bits = 0;
1793 // Prevent compiler warnings about cached_has_bits being unused
1794 (void) cached_has_bits;
1795
1796 _internal_metadata_.Clear<std::string>();
1797 }
1798
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1799 const char* NoEligibilityEvalConfigured::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1800 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1801 while (!ctx->Done(&ptr)) {
1802 ::uint32_t tag;
1803 ptr = ::_pbi::ReadTag(ptr, &tag);
1804 if ((tag == 0) || ((tag & 7) == 4)) {
1805 CHK_(ptr);
1806 ctx->SetLastTag(tag);
1807 goto message_done;
1808 }
1809 ptr = UnknownFieldParse(
1810 tag,
1811 _internal_metadata_.mutable_unknown_fields<std::string>(),
1812 ptr, ctx);
1813 CHK_(ptr != nullptr);
1814 } // while
1815 message_done:
1816 return ptr;
1817 failure:
1818 ptr = nullptr;
1819 goto message_done;
1820 #undef CHK_
1821 }
1822
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1823 ::uint8_t* NoEligibilityEvalConfigured::_InternalSerialize(
1824 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1825 // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.NoEligibilityEvalConfigured)
1826 ::uint32_t cached_has_bits = 0;
1827 (void) cached_has_bits;
1828
1829 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1830 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1831 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1832 }
1833 // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.NoEligibilityEvalConfigured)
1834 return target;
1835 }
1836
ByteSizeLong() const1837 size_t NoEligibilityEvalConfigured::ByteSizeLong() const {
1838 // @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.NoEligibilityEvalConfigured)
1839 size_t total_size = 0;
1840
1841 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1842 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1843 }
1844 int cached_size = ::_pbi::ToCachedSize(total_size);
1845 SetCachedSize(cached_size);
1846 return total_size;
1847 }
1848
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1849 void NoEligibilityEvalConfigured::CheckTypeAndMergeFrom(
1850 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1851 MergeFrom(*::_pbi::DownCast<const NoEligibilityEvalConfigured*>(
1852 &from));
1853 }
1854
MergeFrom(const NoEligibilityEvalConfigured & from)1855 void NoEligibilityEvalConfigured::MergeFrom(const NoEligibilityEvalConfigured& from) {
1856 NoEligibilityEvalConfigured* const _this = this;
1857 // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.NoEligibilityEvalConfigured)
1858 GOOGLE_DCHECK_NE(&from, _this);
1859 ::uint32_t cached_has_bits = 0;
1860 (void) cached_has_bits;
1861
1862 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1863 }
1864
CopyFrom(const NoEligibilityEvalConfigured & from)1865 void NoEligibilityEvalConfigured::CopyFrom(const NoEligibilityEvalConfigured& from) {
1866 // @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.NoEligibilityEvalConfigured)
1867 if (&from == this) return;
1868 Clear();
1869 MergeFrom(from);
1870 }
1871
IsInitialized() const1872 bool NoEligibilityEvalConfigured::IsInitialized() const {
1873 return true;
1874 }
1875
InternalSwap(NoEligibilityEvalConfigured * other)1876 void NoEligibilityEvalConfigured::InternalSwap(NoEligibilityEvalConfigured* other) {
1877 using std::swap;
1878 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1879 }
1880
GetTypeName() const1881 std::string NoEligibilityEvalConfigured::GetTypeName() const {
1882 return "google.internal.federatedcompute.v1.NoEligibilityEvalConfigured";
1883 }
1884
1885
1886 // ===================================================================
1887
1888 class PopulationEligibilitySpec_TaskInfo::_Internal {
1889 public:
1890 };
1891
PopulationEligibilitySpec_TaskInfo(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1892 PopulationEligibilitySpec_TaskInfo::PopulationEligibilitySpec_TaskInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1893 bool is_message_owned)
1894 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1895 SharedCtor(arena, is_message_owned);
1896 // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.PopulationEligibilitySpec.TaskInfo)
1897 }
PopulationEligibilitySpec_TaskInfo(const PopulationEligibilitySpec_TaskInfo & from)1898 PopulationEligibilitySpec_TaskInfo::PopulationEligibilitySpec_TaskInfo(const PopulationEligibilitySpec_TaskInfo& from)
1899 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1900 PopulationEligibilitySpec_TaskInfo* const _this = this; (void)_this;
1901 new (&_impl_) Impl_{
1902 decltype(_impl_.task_name_){}
1903 , decltype(_impl_.task_assignment_mode_){}
1904 , /*decltype(_impl_._cached_size_)*/{}};
1905
1906 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1907 _impl_.task_name_.InitDefault();
1908 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1909 _impl_.task_name_.Set("", GetArenaForAllocation());
1910 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1911 if (!from._internal_task_name().empty()) {
1912 _this->_impl_.task_name_.Set(from._internal_task_name(),
1913 _this->GetArenaForAllocation());
1914 }
1915 _this->_impl_.task_assignment_mode_ = from._impl_.task_assignment_mode_;
1916 // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.PopulationEligibilitySpec.TaskInfo)
1917 }
1918
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1919 inline void PopulationEligibilitySpec_TaskInfo::SharedCtor(
1920 ::_pb::Arena* arena, bool is_message_owned) {
1921 (void)arena;
1922 (void)is_message_owned;
1923 new (&_impl_) Impl_{
1924 decltype(_impl_.task_name_){}
1925 , decltype(_impl_.task_assignment_mode_){0}
1926 , /*decltype(_impl_._cached_size_)*/{}
1927 };
1928 _impl_.task_name_.InitDefault();
1929 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1930 _impl_.task_name_.Set("", GetArenaForAllocation());
1931 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1932 }
1933
~PopulationEligibilitySpec_TaskInfo()1934 PopulationEligibilitySpec_TaskInfo::~PopulationEligibilitySpec_TaskInfo() {
1935 // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.PopulationEligibilitySpec.TaskInfo)
1936 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1937 (void)arena;
1938 return;
1939 }
1940 SharedDtor();
1941 }
1942
SharedDtor()1943 inline void PopulationEligibilitySpec_TaskInfo::SharedDtor() {
1944 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1945 _impl_.task_name_.Destroy();
1946 }
1947
SetCachedSize(int size) const1948 void PopulationEligibilitySpec_TaskInfo::SetCachedSize(int size) const {
1949 _impl_._cached_size_.Set(size);
1950 }
1951
Clear()1952 void PopulationEligibilitySpec_TaskInfo::Clear() {
1953 // @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.PopulationEligibilitySpec.TaskInfo)
1954 ::uint32_t cached_has_bits = 0;
1955 // Prevent compiler warnings about cached_has_bits being unused
1956 (void) cached_has_bits;
1957
1958 _impl_.task_name_.ClearToEmpty();
1959 _impl_.task_assignment_mode_ = 0;
1960 _internal_metadata_.Clear<std::string>();
1961 }
1962
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1963 const char* PopulationEligibilitySpec_TaskInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1964 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1965 while (!ctx->Done(&ptr)) {
1966 ::uint32_t tag;
1967 ptr = ::_pbi::ReadTag(ptr, &tag);
1968 switch (tag >> 3) {
1969 // string task_name = 1;
1970 case 1:
1971 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1972 auto str = _internal_mutable_task_name();
1973 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1974 CHK_(ptr);
1975 CHK_(::_pbi::VerifyUTF8(str, nullptr));
1976 } else {
1977 goto handle_unusual;
1978 }
1979 continue;
1980 // .google.internal.federatedcompute.v1.PopulationEligibilitySpec.TaskInfo.TaskAssignmentMode task_assignment_mode = 2;
1981 case 2:
1982 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1983 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1984 CHK_(ptr);
1985 _internal_set_task_assignment_mode(static_cast<::google::internal::federatedcompute::v1::PopulationEligibilitySpec_TaskInfo_TaskAssignmentMode>(val));
1986 } else {
1987 goto handle_unusual;
1988 }
1989 continue;
1990 default:
1991 goto handle_unusual;
1992 } // switch
1993 handle_unusual:
1994 if ((tag == 0) || ((tag & 7) == 4)) {
1995 CHK_(ptr);
1996 ctx->SetLastTag(tag);
1997 goto message_done;
1998 }
1999 ptr = UnknownFieldParse(
2000 tag,
2001 _internal_metadata_.mutable_unknown_fields<std::string>(),
2002 ptr, ctx);
2003 CHK_(ptr != nullptr);
2004 } // while
2005 message_done:
2006 return ptr;
2007 failure:
2008 ptr = nullptr;
2009 goto message_done;
2010 #undef CHK_
2011 }
2012
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2013 ::uint8_t* PopulationEligibilitySpec_TaskInfo::_InternalSerialize(
2014 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2015 // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.PopulationEligibilitySpec.TaskInfo)
2016 ::uint32_t cached_has_bits = 0;
2017 (void) cached_has_bits;
2018
2019 // string task_name = 1;
2020 if (!this->_internal_task_name().empty()) {
2021 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
2022 this->_internal_task_name().data(), static_cast<int>(this->_internal_task_name().length()),
2023 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
2024 "google.internal.federatedcompute.v1.PopulationEligibilitySpec.TaskInfo.task_name");
2025 target = stream->WriteStringMaybeAliased(
2026 1, this->_internal_task_name(), target);
2027 }
2028
2029 // .google.internal.federatedcompute.v1.PopulationEligibilitySpec.TaskInfo.TaskAssignmentMode task_assignment_mode = 2;
2030 if (this->_internal_task_assignment_mode() != 0) {
2031 target = stream->EnsureSpace(target);
2032 target = ::_pbi::WireFormatLite::WriteEnumToArray(
2033 2, this->_internal_task_assignment_mode(), target);
2034 }
2035
2036 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2037 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2038 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2039 }
2040 // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.PopulationEligibilitySpec.TaskInfo)
2041 return target;
2042 }
2043
ByteSizeLong() const2044 size_t PopulationEligibilitySpec_TaskInfo::ByteSizeLong() const {
2045 // @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.PopulationEligibilitySpec.TaskInfo)
2046 size_t total_size = 0;
2047
2048 ::uint32_t cached_has_bits = 0;
2049 // Prevent compiler warnings about cached_has_bits being unused
2050 (void) cached_has_bits;
2051
2052 // string task_name = 1;
2053 if (!this->_internal_task_name().empty()) {
2054 total_size += 1 +
2055 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2056 this->_internal_task_name());
2057 }
2058
2059 // .google.internal.federatedcompute.v1.PopulationEligibilitySpec.TaskInfo.TaskAssignmentMode task_assignment_mode = 2;
2060 if (this->_internal_task_assignment_mode() != 0) {
2061 total_size += 1 +
2062 ::_pbi::WireFormatLite::EnumSize(this->_internal_task_assignment_mode());
2063 }
2064
2065 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2066 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2067 }
2068 int cached_size = ::_pbi::ToCachedSize(total_size);
2069 SetCachedSize(cached_size);
2070 return total_size;
2071 }
2072
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2073 void PopulationEligibilitySpec_TaskInfo::CheckTypeAndMergeFrom(
2074 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2075 MergeFrom(*::_pbi::DownCast<const PopulationEligibilitySpec_TaskInfo*>(
2076 &from));
2077 }
2078
MergeFrom(const PopulationEligibilitySpec_TaskInfo & from)2079 void PopulationEligibilitySpec_TaskInfo::MergeFrom(const PopulationEligibilitySpec_TaskInfo& from) {
2080 PopulationEligibilitySpec_TaskInfo* const _this = this;
2081 // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.PopulationEligibilitySpec.TaskInfo)
2082 GOOGLE_DCHECK_NE(&from, _this);
2083 ::uint32_t cached_has_bits = 0;
2084 (void) cached_has_bits;
2085
2086 if (!from._internal_task_name().empty()) {
2087 _this->_internal_set_task_name(from._internal_task_name());
2088 }
2089 if (from._internal_task_assignment_mode() != 0) {
2090 _this->_internal_set_task_assignment_mode(from._internal_task_assignment_mode());
2091 }
2092 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2093 }
2094
CopyFrom(const PopulationEligibilitySpec_TaskInfo & from)2095 void PopulationEligibilitySpec_TaskInfo::CopyFrom(const PopulationEligibilitySpec_TaskInfo& from) {
2096 // @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.PopulationEligibilitySpec.TaskInfo)
2097 if (&from == this) return;
2098 Clear();
2099 MergeFrom(from);
2100 }
2101
IsInitialized() const2102 bool PopulationEligibilitySpec_TaskInfo::IsInitialized() const {
2103 return true;
2104 }
2105
InternalSwap(PopulationEligibilitySpec_TaskInfo * other)2106 void PopulationEligibilitySpec_TaskInfo::InternalSwap(PopulationEligibilitySpec_TaskInfo* other) {
2107 using std::swap;
2108 auto* lhs_arena = GetArenaForAllocation();
2109 auto* rhs_arena = other->GetArenaForAllocation();
2110 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2111 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2112 &_impl_.task_name_, lhs_arena,
2113 &other->_impl_.task_name_, rhs_arena
2114 );
2115 swap(_impl_.task_assignment_mode_, other->_impl_.task_assignment_mode_);
2116 }
2117
GetTypeName() const2118 std::string PopulationEligibilitySpec_TaskInfo::GetTypeName() const {
2119 return "google.internal.federatedcompute.v1.PopulationEligibilitySpec.TaskInfo";
2120 }
2121
2122
2123 // ===================================================================
2124
2125 class PopulationEligibilitySpec::_Internal {
2126 public:
2127 };
2128
PopulationEligibilitySpec(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2129 PopulationEligibilitySpec::PopulationEligibilitySpec(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2130 bool is_message_owned)
2131 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2132 SharedCtor(arena, is_message_owned);
2133 // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.PopulationEligibilitySpec)
2134 }
PopulationEligibilitySpec(const PopulationEligibilitySpec & from)2135 PopulationEligibilitySpec::PopulationEligibilitySpec(const PopulationEligibilitySpec& from)
2136 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2137 PopulationEligibilitySpec* const _this = this; (void)_this;
2138 new (&_impl_) Impl_{
2139 decltype(_impl_.task_info_){from._impl_.task_info_}
2140 , /*decltype(_impl_._cached_size_)*/{}};
2141
2142 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2143 // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.PopulationEligibilitySpec)
2144 }
2145
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2146 inline void PopulationEligibilitySpec::SharedCtor(
2147 ::_pb::Arena* arena, bool is_message_owned) {
2148 (void)arena;
2149 (void)is_message_owned;
2150 new (&_impl_) Impl_{
2151 decltype(_impl_.task_info_){arena}
2152 , /*decltype(_impl_._cached_size_)*/{}
2153 };
2154 }
2155
~PopulationEligibilitySpec()2156 PopulationEligibilitySpec::~PopulationEligibilitySpec() {
2157 // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.PopulationEligibilitySpec)
2158 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2159 (void)arena;
2160 return;
2161 }
2162 SharedDtor();
2163 }
2164
SharedDtor()2165 inline void PopulationEligibilitySpec::SharedDtor() {
2166 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2167 _impl_.task_info_.~RepeatedPtrField();
2168 }
2169
SetCachedSize(int size) const2170 void PopulationEligibilitySpec::SetCachedSize(int size) const {
2171 _impl_._cached_size_.Set(size);
2172 }
2173
Clear()2174 void PopulationEligibilitySpec::Clear() {
2175 // @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.PopulationEligibilitySpec)
2176 ::uint32_t cached_has_bits = 0;
2177 // Prevent compiler warnings about cached_has_bits being unused
2178 (void) cached_has_bits;
2179
2180 _impl_.task_info_.Clear();
2181 _internal_metadata_.Clear<std::string>();
2182 }
2183
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2184 const char* PopulationEligibilitySpec::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2185 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2186 while (!ctx->Done(&ptr)) {
2187 ::uint32_t tag;
2188 ptr = ::_pbi::ReadTag(ptr, &tag);
2189 switch (tag >> 3) {
2190 // repeated .google.internal.federatedcompute.v1.PopulationEligibilitySpec.TaskInfo task_info = 1;
2191 case 1:
2192 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
2193 ptr -= 1;
2194 do {
2195 ptr += 1;
2196 ptr = ctx->ParseMessage(_internal_add_task_info(), ptr);
2197 CHK_(ptr);
2198 if (!ctx->DataAvailable(ptr)) break;
2199 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
2200 } else {
2201 goto handle_unusual;
2202 }
2203 continue;
2204 default:
2205 goto handle_unusual;
2206 } // switch
2207 handle_unusual:
2208 if ((tag == 0) || ((tag & 7) == 4)) {
2209 CHK_(ptr);
2210 ctx->SetLastTag(tag);
2211 goto message_done;
2212 }
2213 ptr = UnknownFieldParse(
2214 tag,
2215 _internal_metadata_.mutable_unknown_fields<std::string>(),
2216 ptr, ctx);
2217 CHK_(ptr != nullptr);
2218 } // while
2219 message_done:
2220 return ptr;
2221 failure:
2222 ptr = nullptr;
2223 goto message_done;
2224 #undef CHK_
2225 }
2226
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2227 ::uint8_t* PopulationEligibilitySpec::_InternalSerialize(
2228 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2229 // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.PopulationEligibilitySpec)
2230 ::uint32_t cached_has_bits = 0;
2231 (void) cached_has_bits;
2232
2233 // repeated .google.internal.federatedcompute.v1.PopulationEligibilitySpec.TaskInfo task_info = 1;
2234 for (unsigned i = 0,
2235 n = static_cast<unsigned>(this->_internal_task_info_size()); i < n; i++) {
2236 const auto& repfield = this->_internal_task_info(i);
2237 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
2238 InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
2239 }
2240
2241 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2242 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2243 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2244 }
2245 // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.PopulationEligibilitySpec)
2246 return target;
2247 }
2248
ByteSizeLong() const2249 size_t PopulationEligibilitySpec::ByteSizeLong() const {
2250 // @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.PopulationEligibilitySpec)
2251 size_t total_size = 0;
2252
2253 ::uint32_t cached_has_bits = 0;
2254 // Prevent compiler warnings about cached_has_bits being unused
2255 (void) cached_has_bits;
2256
2257 // repeated .google.internal.federatedcompute.v1.PopulationEligibilitySpec.TaskInfo task_info = 1;
2258 total_size += 1UL * this->_internal_task_info_size();
2259 for (const auto& msg : this->_impl_.task_info_) {
2260 total_size +=
2261 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
2262 }
2263
2264 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2265 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2266 }
2267 int cached_size = ::_pbi::ToCachedSize(total_size);
2268 SetCachedSize(cached_size);
2269 return total_size;
2270 }
2271
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2272 void PopulationEligibilitySpec::CheckTypeAndMergeFrom(
2273 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2274 MergeFrom(*::_pbi::DownCast<const PopulationEligibilitySpec*>(
2275 &from));
2276 }
2277
MergeFrom(const PopulationEligibilitySpec & from)2278 void PopulationEligibilitySpec::MergeFrom(const PopulationEligibilitySpec& from) {
2279 PopulationEligibilitySpec* const _this = this;
2280 // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.PopulationEligibilitySpec)
2281 GOOGLE_DCHECK_NE(&from, _this);
2282 ::uint32_t cached_has_bits = 0;
2283 (void) cached_has_bits;
2284
2285 _this->_impl_.task_info_.MergeFrom(from._impl_.task_info_);
2286 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2287 }
2288
CopyFrom(const PopulationEligibilitySpec & from)2289 void PopulationEligibilitySpec::CopyFrom(const PopulationEligibilitySpec& from) {
2290 // @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.PopulationEligibilitySpec)
2291 if (&from == this) return;
2292 Clear();
2293 MergeFrom(from);
2294 }
2295
IsInitialized() const2296 bool PopulationEligibilitySpec::IsInitialized() const {
2297 return true;
2298 }
2299
InternalSwap(PopulationEligibilitySpec * other)2300 void PopulationEligibilitySpec::InternalSwap(PopulationEligibilitySpec* other) {
2301 using std::swap;
2302 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2303 _impl_.task_info_.InternalSwap(&other->_impl_.task_info_);
2304 }
2305
GetTypeName() const2306 std::string PopulationEligibilitySpec::GetTypeName() const {
2307 return "google.internal.federatedcompute.v1.PopulationEligibilitySpec";
2308 }
2309
2310
2311 // ===================================================================
2312
2313 class ReportEligibilityEvalTaskResultRequest::_Internal {
2314 public:
2315 };
2316
ReportEligibilityEvalTaskResultRequest(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2317 ReportEligibilityEvalTaskResultRequest::ReportEligibilityEvalTaskResultRequest(::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:google.internal.federatedcompute.v1.ReportEligibilityEvalTaskResultRequest)
2322 }
ReportEligibilityEvalTaskResultRequest(const ReportEligibilityEvalTaskResultRequest & from)2323 ReportEligibilityEvalTaskResultRequest::ReportEligibilityEvalTaskResultRequest(const ReportEligibilityEvalTaskResultRequest& from)
2324 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2325 ReportEligibilityEvalTaskResultRequest* const _this = this; (void)_this;
2326 new (&_impl_) Impl_{
2327 decltype(_impl_.population_name_){}
2328 , decltype(_impl_.session_id_){}
2329 , decltype(_impl_.status_code_){}
2330 , /*decltype(_impl_._cached_size_)*/{}};
2331
2332 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2333 _impl_.population_name_.InitDefault();
2334 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2335 _impl_.population_name_.Set("", GetArenaForAllocation());
2336 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2337 if (!from._internal_population_name().empty()) {
2338 _this->_impl_.population_name_.Set(from._internal_population_name(),
2339 _this->GetArenaForAllocation());
2340 }
2341 _impl_.session_id_.InitDefault();
2342 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2343 _impl_.session_id_.Set("", GetArenaForAllocation());
2344 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2345 if (!from._internal_session_id().empty()) {
2346 _this->_impl_.session_id_.Set(from._internal_session_id(),
2347 _this->GetArenaForAllocation());
2348 }
2349 _this->_impl_.status_code_ = from._impl_.status_code_;
2350 // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.ReportEligibilityEvalTaskResultRequest)
2351 }
2352
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2353 inline void ReportEligibilityEvalTaskResultRequest::SharedCtor(
2354 ::_pb::Arena* arena, bool is_message_owned) {
2355 (void)arena;
2356 (void)is_message_owned;
2357 new (&_impl_) Impl_{
2358 decltype(_impl_.population_name_){}
2359 , decltype(_impl_.session_id_){}
2360 , decltype(_impl_.status_code_){0}
2361 , /*decltype(_impl_._cached_size_)*/{}
2362 };
2363 _impl_.population_name_.InitDefault();
2364 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2365 _impl_.population_name_.Set("", GetArenaForAllocation());
2366 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2367 _impl_.session_id_.InitDefault();
2368 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2369 _impl_.session_id_.Set("", GetArenaForAllocation());
2370 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2371 }
2372
~ReportEligibilityEvalTaskResultRequest()2373 ReportEligibilityEvalTaskResultRequest::~ReportEligibilityEvalTaskResultRequest() {
2374 // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.ReportEligibilityEvalTaskResultRequest)
2375 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2376 (void)arena;
2377 return;
2378 }
2379 SharedDtor();
2380 }
2381
SharedDtor()2382 inline void ReportEligibilityEvalTaskResultRequest::SharedDtor() {
2383 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2384 _impl_.population_name_.Destroy();
2385 _impl_.session_id_.Destroy();
2386 }
2387
SetCachedSize(int size) const2388 void ReportEligibilityEvalTaskResultRequest::SetCachedSize(int size) const {
2389 _impl_._cached_size_.Set(size);
2390 }
2391
Clear()2392 void ReportEligibilityEvalTaskResultRequest::Clear() {
2393 // @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.ReportEligibilityEvalTaskResultRequest)
2394 ::uint32_t cached_has_bits = 0;
2395 // Prevent compiler warnings about cached_has_bits being unused
2396 (void) cached_has_bits;
2397
2398 _impl_.population_name_.ClearToEmpty();
2399 _impl_.session_id_.ClearToEmpty();
2400 _impl_.status_code_ = 0;
2401 _internal_metadata_.Clear<std::string>();
2402 }
2403
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2404 const char* ReportEligibilityEvalTaskResultRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2405 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2406 while (!ctx->Done(&ptr)) {
2407 ::uint32_t tag;
2408 ptr = ::_pbi::ReadTag(ptr, &tag);
2409 switch (tag >> 3) {
2410 // string population_name = 1;
2411 case 1:
2412 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
2413 auto str = _internal_mutable_population_name();
2414 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2415 CHK_(ptr);
2416 CHK_(::_pbi::VerifyUTF8(str, nullptr));
2417 } else {
2418 goto handle_unusual;
2419 }
2420 continue;
2421 // string session_id = 2;
2422 case 2:
2423 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
2424 auto str = _internal_mutable_session_id();
2425 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2426 CHK_(ptr);
2427 CHK_(::_pbi::VerifyUTF8(str, nullptr));
2428 } else {
2429 goto handle_unusual;
2430 }
2431 continue;
2432 // int32 status_code = 3;
2433 case 3:
2434 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
2435 _impl_.status_code_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2436 CHK_(ptr);
2437 } else {
2438 goto handle_unusual;
2439 }
2440 continue;
2441 default:
2442 goto handle_unusual;
2443 } // switch
2444 handle_unusual:
2445 if ((tag == 0) || ((tag & 7) == 4)) {
2446 CHK_(ptr);
2447 ctx->SetLastTag(tag);
2448 goto message_done;
2449 }
2450 ptr = UnknownFieldParse(
2451 tag,
2452 _internal_metadata_.mutable_unknown_fields<std::string>(),
2453 ptr, ctx);
2454 CHK_(ptr != nullptr);
2455 } // while
2456 message_done:
2457 return ptr;
2458 failure:
2459 ptr = nullptr;
2460 goto message_done;
2461 #undef CHK_
2462 }
2463
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2464 ::uint8_t* ReportEligibilityEvalTaskResultRequest::_InternalSerialize(
2465 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2466 // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.ReportEligibilityEvalTaskResultRequest)
2467 ::uint32_t cached_has_bits = 0;
2468 (void) cached_has_bits;
2469
2470 // string population_name = 1;
2471 if (!this->_internal_population_name().empty()) {
2472 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
2473 this->_internal_population_name().data(), static_cast<int>(this->_internal_population_name().length()),
2474 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
2475 "google.internal.federatedcompute.v1.ReportEligibilityEvalTaskResultRequest.population_name");
2476 target = stream->WriteStringMaybeAliased(
2477 1, this->_internal_population_name(), target);
2478 }
2479
2480 // string session_id = 2;
2481 if (!this->_internal_session_id().empty()) {
2482 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
2483 this->_internal_session_id().data(), static_cast<int>(this->_internal_session_id().length()),
2484 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
2485 "google.internal.federatedcompute.v1.ReportEligibilityEvalTaskResultRequest.session_id");
2486 target = stream->WriteStringMaybeAliased(
2487 2, this->_internal_session_id(), target);
2488 }
2489
2490 // int32 status_code = 3;
2491 if (this->_internal_status_code() != 0) {
2492 target = stream->EnsureSpace(target);
2493 target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_status_code(), target);
2494 }
2495
2496 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2497 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2498 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2499 }
2500 // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.ReportEligibilityEvalTaskResultRequest)
2501 return target;
2502 }
2503
ByteSizeLong() const2504 size_t ReportEligibilityEvalTaskResultRequest::ByteSizeLong() const {
2505 // @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.ReportEligibilityEvalTaskResultRequest)
2506 size_t total_size = 0;
2507
2508 ::uint32_t cached_has_bits = 0;
2509 // Prevent compiler warnings about cached_has_bits being unused
2510 (void) cached_has_bits;
2511
2512 // string population_name = 1;
2513 if (!this->_internal_population_name().empty()) {
2514 total_size += 1 +
2515 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2516 this->_internal_population_name());
2517 }
2518
2519 // string session_id = 2;
2520 if (!this->_internal_session_id().empty()) {
2521 total_size += 1 +
2522 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2523 this->_internal_session_id());
2524 }
2525
2526 // int32 status_code = 3;
2527 if (this->_internal_status_code() != 0) {
2528 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_status_code());
2529 }
2530
2531 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2532 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2533 }
2534 int cached_size = ::_pbi::ToCachedSize(total_size);
2535 SetCachedSize(cached_size);
2536 return total_size;
2537 }
2538
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2539 void ReportEligibilityEvalTaskResultRequest::CheckTypeAndMergeFrom(
2540 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2541 MergeFrom(*::_pbi::DownCast<const ReportEligibilityEvalTaskResultRequest*>(
2542 &from));
2543 }
2544
MergeFrom(const ReportEligibilityEvalTaskResultRequest & from)2545 void ReportEligibilityEvalTaskResultRequest::MergeFrom(const ReportEligibilityEvalTaskResultRequest& from) {
2546 ReportEligibilityEvalTaskResultRequest* const _this = this;
2547 // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.ReportEligibilityEvalTaskResultRequest)
2548 GOOGLE_DCHECK_NE(&from, _this);
2549 ::uint32_t cached_has_bits = 0;
2550 (void) cached_has_bits;
2551
2552 if (!from._internal_population_name().empty()) {
2553 _this->_internal_set_population_name(from._internal_population_name());
2554 }
2555 if (!from._internal_session_id().empty()) {
2556 _this->_internal_set_session_id(from._internal_session_id());
2557 }
2558 if (from._internal_status_code() != 0) {
2559 _this->_internal_set_status_code(from._internal_status_code());
2560 }
2561 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2562 }
2563
CopyFrom(const ReportEligibilityEvalTaskResultRequest & from)2564 void ReportEligibilityEvalTaskResultRequest::CopyFrom(const ReportEligibilityEvalTaskResultRequest& from) {
2565 // @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.ReportEligibilityEvalTaskResultRequest)
2566 if (&from == this) return;
2567 Clear();
2568 MergeFrom(from);
2569 }
2570
IsInitialized() const2571 bool ReportEligibilityEvalTaskResultRequest::IsInitialized() const {
2572 return true;
2573 }
2574
InternalSwap(ReportEligibilityEvalTaskResultRequest * other)2575 void ReportEligibilityEvalTaskResultRequest::InternalSwap(ReportEligibilityEvalTaskResultRequest* other) {
2576 using std::swap;
2577 auto* lhs_arena = GetArenaForAllocation();
2578 auto* rhs_arena = other->GetArenaForAllocation();
2579 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2580 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2581 &_impl_.population_name_, lhs_arena,
2582 &other->_impl_.population_name_, rhs_arena
2583 );
2584 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2585 &_impl_.session_id_, lhs_arena,
2586 &other->_impl_.session_id_, rhs_arena
2587 );
2588 swap(_impl_.status_code_, other->_impl_.status_code_);
2589 }
2590
GetTypeName() const2591 std::string ReportEligibilityEvalTaskResultRequest::GetTypeName() const {
2592 return "google.internal.federatedcompute.v1.ReportEligibilityEvalTaskResultRequest";
2593 }
2594
2595
2596 // ===================================================================
2597
2598 class ReportEligibilityEvalTaskResultResponse::_Internal {
2599 public:
2600 };
2601
ReportEligibilityEvalTaskResultResponse(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2602 ReportEligibilityEvalTaskResultResponse::ReportEligibilityEvalTaskResultResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2603 bool is_message_owned)
2604 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2605 SharedCtor(arena, is_message_owned);
2606 // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.ReportEligibilityEvalTaskResultResponse)
2607 }
ReportEligibilityEvalTaskResultResponse(const ReportEligibilityEvalTaskResultResponse & from)2608 ReportEligibilityEvalTaskResultResponse::ReportEligibilityEvalTaskResultResponse(const ReportEligibilityEvalTaskResultResponse& from)
2609 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2610 ReportEligibilityEvalTaskResultResponse* const _this = this; (void)_this;
2611 new (&_impl_) Impl_{
2612 /*decltype(_impl_._cached_size_)*/{}};
2613
2614 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2615 // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.ReportEligibilityEvalTaskResultResponse)
2616 }
2617
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2618 inline void ReportEligibilityEvalTaskResultResponse::SharedCtor(
2619 ::_pb::Arena* arena, bool is_message_owned) {
2620 (void)arena;
2621 (void)is_message_owned;
2622 new (&_impl_) Impl_{
2623 /*decltype(_impl_._cached_size_)*/{}
2624 };
2625 }
2626
~ReportEligibilityEvalTaskResultResponse()2627 ReportEligibilityEvalTaskResultResponse::~ReportEligibilityEvalTaskResultResponse() {
2628 // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.ReportEligibilityEvalTaskResultResponse)
2629 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2630 (void)arena;
2631 return;
2632 }
2633 SharedDtor();
2634 }
2635
SharedDtor()2636 inline void ReportEligibilityEvalTaskResultResponse::SharedDtor() {
2637 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2638 }
2639
SetCachedSize(int size) const2640 void ReportEligibilityEvalTaskResultResponse::SetCachedSize(int size) const {
2641 _impl_._cached_size_.Set(size);
2642 }
2643
Clear()2644 void ReportEligibilityEvalTaskResultResponse::Clear() {
2645 // @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.ReportEligibilityEvalTaskResultResponse)
2646 ::uint32_t cached_has_bits = 0;
2647 // Prevent compiler warnings about cached_has_bits being unused
2648 (void) cached_has_bits;
2649
2650 _internal_metadata_.Clear<std::string>();
2651 }
2652
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2653 const char* ReportEligibilityEvalTaskResultResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2654 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2655 while (!ctx->Done(&ptr)) {
2656 ::uint32_t tag;
2657 ptr = ::_pbi::ReadTag(ptr, &tag);
2658 if ((tag == 0) || ((tag & 7) == 4)) {
2659 CHK_(ptr);
2660 ctx->SetLastTag(tag);
2661 goto message_done;
2662 }
2663 ptr = UnknownFieldParse(
2664 tag,
2665 _internal_metadata_.mutable_unknown_fields<std::string>(),
2666 ptr, ctx);
2667 CHK_(ptr != nullptr);
2668 } // while
2669 message_done:
2670 return ptr;
2671 failure:
2672 ptr = nullptr;
2673 goto message_done;
2674 #undef CHK_
2675 }
2676
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2677 ::uint8_t* ReportEligibilityEvalTaskResultResponse::_InternalSerialize(
2678 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2679 // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.ReportEligibilityEvalTaskResultResponse)
2680 ::uint32_t cached_has_bits = 0;
2681 (void) cached_has_bits;
2682
2683 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2684 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2685 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2686 }
2687 // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.ReportEligibilityEvalTaskResultResponse)
2688 return target;
2689 }
2690
ByteSizeLong() const2691 size_t ReportEligibilityEvalTaskResultResponse::ByteSizeLong() const {
2692 // @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.ReportEligibilityEvalTaskResultResponse)
2693 size_t total_size = 0;
2694
2695 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2696 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2697 }
2698 int cached_size = ::_pbi::ToCachedSize(total_size);
2699 SetCachedSize(cached_size);
2700 return total_size;
2701 }
2702
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2703 void ReportEligibilityEvalTaskResultResponse::CheckTypeAndMergeFrom(
2704 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2705 MergeFrom(*::_pbi::DownCast<const ReportEligibilityEvalTaskResultResponse*>(
2706 &from));
2707 }
2708
MergeFrom(const ReportEligibilityEvalTaskResultResponse & from)2709 void ReportEligibilityEvalTaskResultResponse::MergeFrom(const ReportEligibilityEvalTaskResultResponse& from) {
2710 ReportEligibilityEvalTaskResultResponse* const _this = this;
2711 // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.ReportEligibilityEvalTaskResultResponse)
2712 GOOGLE_DCHECK_NE(&from, _this);
2713 ::uint32_t cached_has_bits = 0;
2714 (void) cached_has_bits;
2715
2716 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2717 }
2718
CopyFrom(const ReportEligibilityEvalTaskResultResponse & from)2719 void ReportEligibilityEvalTaskResultResponse::CopyFrom(const ReportEligibilityEvalTaskResultResponse& from) {
2720 // @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.ReportEligibilityEvalTaskResultResponse)
2721 if (&from == this) return;
2722 Clear();
2723 MergeFrom(from);
2724 }
2725
IsInitialized() const2726 bool ReportEligibilityEvalTaskResultResponse::IsInitialized() const {
2727 return true;
2728 }
2729
InternalSwap(ReportEligibilityEvalTaskResultResponse * other)2730 void ReportEligibilityEvalTaskResultResponse::InternalSwap(ReportEligibilityEvalTaskResultResponse* other) {
2731 using std::swap;
2732 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2733 }
2734
GetTypeName() const2735 std::string ReportEligibilityEvalTaskResultResponse::GetTypeName() const {
2736 return "google.internal.federatedcompute.v1.ReportEligibilityEvalTaskResultResponse";
2737 }
2738
2739
2740 // @@protoc_insertion_point(namespace_scope)
2741 } // namespace v1
2742 } // namespace federatedcompute
2743 } // namespace internal
2744 } // namespace google
2745 PROTOBUF_NAMESPACE_OPEN
2746 template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::EligibilityEvalTaskRequest*
CreateMaybeMessage(Arena * arena)2747 Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::EligibilityEvalTaskRequest >(Arena* arena) {
2748 return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::EligibilityEvalTaskRequest >(arena);
2749 }
2750 template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::EligibilityEvalTaskCapabilities*
CreateMaybeMessage(Arena * arena)2751 Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::EligibilityEvalTaskCapabilities >(Arena* arena) {
2752 return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::EligibilityEvalTaskCapabilities >(arena);
2753 }
2754 template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::EligibilityEvalTaskResponse*
CreateMaybeMessage(Arena * arena)2755 Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::EligibilityEvalTaskResponse >(Arena* arena) {
2756 return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::EligibilityEvalTaskResponse >(arena);
2757 }
2758 template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::EligibilityEvalTask*
CreateMaybeMessage(Arena * arena)2759 Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::EligibilityEvalTask >(Arena* arena) {
2760 return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::EligibilityEvalTask >(arena);
2761 }
2762 template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::NoEligibilityEvalConfigured*
CreateMaybeMessage(Arena * arena)2763 Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::NoEligibilityEvalConfigured >(Arena* arena) {
2764 return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::NoEligibilityEvalConfigured >(arena);
2765 }
2766 template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::PopulationEligibilitySpec_TaskInfo*
CreateMaybeMessage(Arena * arena)2767 Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::PopulationEligibilitySpec_TaskInfo >(Arena* arena) {
2768 return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::PopulationEligibilitySpec_TaskInfo >(arena);
2769 }
2770 template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::PopulationEligibilitySpec*
CreateMaybeMessage(Arena * arena)2771 Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::PopulationEligibilitySpec >(Arena* arena) {
2772 return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::PopulationEligibilitySpec >(arena);
2773 }
2774 template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::ReportEligibilityEvalTaskResultRequest*
CreateMaybeMessage(Arena * arena)2775 Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::ReportEligibilityEvalTaskResultRequest >(Arena* arena) {
2776 return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::ReportEligibilityEvalTaskResultRequest >(arena);
2777 }
2778 template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::ReportEligibilityEvalTaskResultResponse*
CreateMaybeMessage(Arena * arena)2779 Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::ReportEligibilityEvalTaskResultResponse >(Arena* arena) {
2780 return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::ReportEligibilityEvalTaskResultResponse >(arena);
2781 }
2782 PROTOBUF_NAMESPACE_CLOSE
2783
2784 // @@protoc_insertion_point(global_scope)
2785 #include <google/protobuf/port_undef.inc>
2786