1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: fcp/protos/federatedcompute/common.proto
3
4 #include "fcp/protos/federatedcompute/common.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 {
ForwardingInfo_ExtraRequestHeadersEntry_DoNotUse(::_pbi::ConstantInitialized)25 PROTOBUF_CONSTEXPR ForwardingInfo_ExtraRequestHeadersEntry_DoNotUse::ForwardingInfo_ExtraRequestHeadersEntry_DoNotUse(
26 ::_pbi::ConstantInitialized) {}
27 struct ForwardingInfo_ExtraRequestHeadersEntry_DoNotUseDefaultTypeInternal {
ForwardingInfo_ExtraRequestHeadersEntry_DoNotUseDefaultTypeInternalgoogle::internal::federatedcompute::v1::ForwardingInfo_ExtraRequestHeadersEntry_DoNotUseDefaultTypeInternal28 PROTOBUF_CONSTEXPR ForwardingInfo_ExtraRequestHeadersEntry_DoNotUseDefaultTypeInternal()
29 : _instance(::_pbi::ConstantInitialized{}) {}
~ForwardingInfo_ExtraRequestHeadersEntry_DoNotUseDefaultTypeInternalgoogle::internal::federatedcompute::v1::ForwardingInfo_ExtraRequestHeadersEntry_DoNotUseDefaultTypeInternal30 ~ForwardingInfo_ExtraRequestHeadersEntry_DoNotUseDefaultTypeInternal() {}
31 union { // NOLINT(misc-non-private-member-variables-in-classes)
32 ForwardingInfo_ExtraRequestHeadersEntry_DoNotUse _instance;
33 };
34 };
35 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ForwardingInfo_ExtraRequestHeadersEntry_DoNotUseDefaultTypeInternal _ForwardingInfo_ExtraRequestHeadersEntry_DoNotUse_default_instance_;
ForwardingInfo(::_pbi::ConstantInitialized)36 PROTOBUF_CONSTEXPR ForwardingInfo::ForwardingInfo(
37 ::_pbi::ConstantInitialized): _impl_{
38 /*decltype(_impl_.extra_request_headers_)*/{}
39 , /*decltype(_impl_.target_uri_prefix_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
40 , /*decltype(_impl_._cached_size_)*/{}} {}
41 struct ForwardingInfoDefaultTypeInternal {
ForwardingInfoDefaultTypeInternalgoogle::internal::federatedcompute::v1::ForwardingInfoDefaultTypeInternal42 PROTOBUF_CONSTEXPR ForwardingInfoDefaultTypeInternal()
43 : _instance(::_pbi::ConstantInitialized{}) {}
~ForwardingInfoDefaultTypeInternalgoogle::internal::federatedcompute::v1::ForwardingInfoDefaultTypeInternal44 ~ForwardingInfoDefaultTypeInternal() {}
45 union { // NOLINT(misc-non-private-member-variables-in-classes)
46 ForwardingInfo _instance;
47 };
48 };
49 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ForwardingInfoDefaultTypeInternal _ForwardingInfo_default_instance_;
AttestationMeasurement(::_pbi::ConstantInitialized)50 PROTOBUF_CONSTEXPR AttestationMeasurement::AttestationMeasurement(
51 ::_pbi::ConstantInitialized): _impl_{
52 /*decltype(_impl_.value_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
53 , /*decltype(_impl_._cached_size_)*/{}} {}
54 struct AttestationMeasurementDefaultTypeInternal {
AttestationMeasurementDefaultTypeInternalgoogle::internal::federatedcompute::v1::AttestationMeasurementDefaultTypeInternal55 PROTOBUF_CONSTEXPR AttestationMeasurementDefaultTypeInternal()
56 : _instance(::_pbi::ConstantInitialized{}) {}
~AttestationMeasurementDefaultTypeInternalgoogle::internal::federatedcompute::v1::AttestationMeasurementDefaultTypeInternal57 ~AttestationMeasurementDefaultTypeInternal() {}
58 union { // NOLINT(misc-non-private-member-variables-in-classes)
59 AttestationMeasurement _instance;
60 };
61 };
62 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AttestationMeasurementDefaultTypeInternal _AttestationMeasurement_default_instance_;
ClientVersion(::_pbi::ConstantInitialized)63 PROTOBUF_CONSTEXPR ClientVersion::ClientVersion(
64 ::_pbi::ConstantInitialized): _impl_{
65 /*decltype(_impl_.version_code_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
66 , /*decltype(_impl_._cached_size_)*/{}} {}
67 struct ClientVersionDefaultTypeInternal {
ClientVersionDefaultTypeInternalgoogle::internal::federatedcompute::v1::ClientVersionDefaultTypeInternal68 PROTOBUF_CONSTEXPR ClientVersionDefaultTypeInternal()
69 : _instance(::_pbi::ConstantInitialized{}) {}
~ClientVersionDefaultTypeInternalgoogle::internal::federatedcompute::v1::ClientVersionDefaultTypeInternal70 ~ClientVersionDefaultTypeInternal() {}
71 union { // NOLINT(misc-non-private-member-variables-in-classes)
72 ClientVersion _instance;
73 };
74 };
75 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientVersionDefaultTypeInternal _ClientVersion_default_instance_;
Resource_InlineResource(::_pbi::ConstantInitialized)76 PROTOBUF_CONSTEXPR Resource_InlineResource::Resource_InlineResource(
77 ::_pbi::ConstantInitialized): _impl_{
78 /*decltype(_impl_._has_bits_)*/{}
79 , /*decltype(_impl_._cached_size_)*/{}
80 , /*decltype(_impl_.data_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
81 , /*decltype(_impl_.compression_format_)*/0} {}
82 struct Resource_InlineResourceDefaultTypeInternal {
Resource_InlineResourceDefaultTypeInternalgoogle::internal::federatedcompute::v1::Resource_InlineResourceDefaultTypeInternal83 PROTOBUF_CONSTEXPR Resource_InlineResourceDefaultTypeInternal()
84 : _instance(::_pbi::ConstantInitialized{}) {}
~Resource_InlineResourceDefaultTypeInternalgoogle::internal::federatedcompute::v1::Resource_InlineResourceDefaultTypeInternal85 ~Resource_InlineResourceDefaultTypeInternal() {}
86 union { // NOLINT(misc-non-private-member-variables-in-classes)
87 Resource_InlineResource _instance;
88 };
89 };
90 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Resource_InlineResourceDefaultTypeInternal _Resource_InlineResource_default_instance_;
Resource(::_pbi::ConstantInitialized)91 PROTOBUF_CONSTEXPR Resource::Resource(
92 ::_pbi::ConstantInitialized): _impl_{
93 /*decltype(_impl_._has_bits_)*/{}
94 , /*decltype(_impl_._cached_size_)*/{}
95 , /*decltype(_impl_.client_cache_id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
96 , /*decltype(_impl_.max_age_)*/nullptr
97 , /*decltype(_impl_.compression_format_)*/0
98 , /*decltype(_impl_.resource_)*/{}
99 , /*decltype(_impl_._oneof_case_)*/{}} {}
100 struct ResourceDefaultTypeInternal {
ResourceDefaultTypeInternalgoogle::internal::federatedcompute::v1::ResourceDefaultTypeInternal101 PROTOBUF_CONSTEXPR ResourceDefaultTypeInternal()
102 : _instance(::_pbi::ConstantInitialized{}) {}
~ResourceDefaultTypeInternalgoogle::internal::federatedcompute::v1::ResourceDefaultTypeInternal103 ~ResourceDefaultTypeInternal() {}
104 union { // NOLINT(misc-non-private-member-variables-in-classes)
105 Resource _instance;
106 };
107 };
108 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ResourceDefaultTypeInternal _Resource_default_instance_;
ResourceCapabilities(::_pbi::ConstantInitialized)109 PROTOBUF_CONSTEXPR ResourceCapabilities::ResourceCapabilities(
110 ::_pbi::ConstantInitialized): _impl_{
111 /*decltype(_impl_.supported_compression_formats_)*/{}
112 , /*decltype(_impl_._supported_compression_formats_cached_byte_size_)*/{0}
113 , /*decltype(_impl_._cached_size_)*/{}} {}
114 struct ResourceCapabilitiesDefaultTypeInternal {
ResourceCapabilitiesDefaultTypeInternalgoogle::internal::federatedcompute::v1::ResourceCapabilitiesDefaultTypeInternal115 PROTOBUF_CONSTEXPR ResourceCapabilitiesDefaultTypeInternal()
116 : _instance(::_pbi::ConstantInitialized{}) {}
~ResourceCapabilitiesDefaultTypeInternalgoogle::internal::federatedcompute::v1::ResourceCapabilitiesDefaultTypeInternal117 ~ResourceCapabilitiesDefaultTypeInternal() {}
118 union { // NOLINT(misc-non-private-member-variables-in-classes)
119 ResourceCapabilities _instance;
120 };
121 };
122 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ResourceCapabilitiesDefaultTypeInternal _ResourceCapabilities_default_instance_;
RejectionInfo(::_pbi::ConstantInitialized)123 PROTOBUF_CONSTEXPR RejectionInfo::RejectionInfo(
124 ::_pbi::ConstantInitialized): _impl_{
125 /*decltype(_impl_.reason_)*/0
126 , /*decltype(_impl_.metadata_)*/{}
127 , /*decltype(_impl_._cached_size_)*/{}
128 , /*decltype(_impl_._oneof_case_)*/{}} {}
129 struct RejectionInfoDefaultTypeInternal {
RejectionInfoDefaultTypeInternalgoogle::internal::federatedcompute::v1::RejectionInfoDefaultTypeInternal130 PROTOBUF_CONSTEXPR RejectionInfoDefaultTypeInternal()
131 : _instance(::_pbi::ConstantInitialized{}) {}
~RejectionInfoDefaultTypeInternalgoogle::internal::federatedcompute::v1::RejectionInfoDefaultTypeInternal132 ~RejectionInfoDefaultTypeInternal() {}
133 union { // NOLINT(misc-non-private-member-variables-in-classes)
134 RejectionInfo _instance;
135 };
136 };
137 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RejectionInfoDefaultTypeInternal _RejectionInfo_default_instance_;
AuthenticationMetadata(::_pbi::ConstantInitialized)138 PROTOBUF_CONSTEXPR AuthenticationMetadata::AuthenticationMetadata(
139 ::_pbi::ConstantInitialized): _impl_{
140 /*decltype(_impl_.key_attestation_metadata_)*/nullptr
141 , /*decltype(_impl_._cached_size_)*/{}} {}
142 struct AuthenticationMetadataDefaultTypeInternal {
AuthenticationMetadataDefaultTypeInternalgoogle::internal::federatedcompute::v1::AuthenticationMetadataDefaultTypeInternal143 PROTOBUF_CONSTEXPR AuthenticationMetadataDefaultTypeInternal()
144 : _instance(::_pbi::ConstantInitialized{}) {}
~AuthenticationMetadataDefaultTypeInternalgoogle::internal::federatedcompute::v1::AuthenticationMetadataDefaultTypeInternal145 ~AuthenticationMetadataDefaultTypeInternal() {}
146 union { // NOLINT(misc-non-private-member-variables-in-classes)
147 AuthenticationMetadata _instance;
148 };
149 };
150 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AuthenticationMetadataDefaultTypeInternal _AuthenticationMetadata_default_instance_;
KeyAttestationAuthMetadata(::_pbi::ConstantInitialized)151 PROTOBUF_CONSTEXPR KeyAttestationAuthMetadata::KeyAttestationAuthMetadata(
152 ::_pbi::ConstantInitialized): _impl_{
153 /*decltype(_impl_.challenge_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
154 , /*decltype(_impl_._cached_size_)*/{}} {}
155 struct KeyAttestationAuthMetadataDefaultTypeInternal {
KeyAttestationAuthMetadataDefaultTypeInternalgoogle::internal::federatedcompute::v1::KeyAttestationAuthMetadataDefaultTypeInternal156 PROTOBUF_CONSTEXPR KeyAttestationAuthMetadataDefaultTypeInternal()
157 : _instance(::_pbi::ConstantInitialized{}) {}
~KeyAttestationAuthMetadataDefaultTypeInternalgoogle::internal::federatedcompute::v1::KeyAttestationAuthMetadataDefaultTypeInternal158 ~KeyAttestationAuthMetadataDefaultTypeInternal() {}
159 union { // NOLINT(misc-non-private-member-variables-in-classes)
160 KeyAttestationAuthMetadata _instance;
161 };
162 };
163 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 KeyAttestationAuthMetadataDefaultTypeInternal _KeyAttestationAuthMetadata_default_instance_;
RejectionReason(::_pbi::ConstantInitialized)164 PROTOBUF_CONSTEXPR RejectionReason::RejectionReason(
165 ::_pbi::ConstantInitialized): _impl_{
166 /*decltype(_impl_._cached_size_)*/{}} {}
167 struct RejectionReasonDefaultTypeInternal {
RejectionReasonDefaultTypeInternalgoogle::internal::federatedcompute::v1::RejectionReasonDefaultTypeInternal168 PROTOBUF_CONSTEXPR RejectionReasonDefaultTypeInternal()
169 : _instance(::_pbi::ConstantInitialized{}) {}
~RejectionReasonDefaultTypeInternalgoogle::internal::federatedcompute::v1::RejectionReasonDefaultTypeInternal170 ~RejectionReasonDefaultTypeInternal() {}
171 union { // NOLINT(misc-non-private-member-variables-in-classes)
172 RejectionReason _instance;
173 };
174 };
175 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RejectionReasonDefaultTypeInternal _RejectionReason_default_instance_;
RetryWindow(::_pbi::ConstantInitialized)176 PROTOBUF_CONSTEXPR RetryWindow::RetryWindow(
177 ::_pbi::ConstantInitialized): _impl_{
178 /*decltype(_impl_.delay_min_)*/nullptr
179 , /*decltype(_impl_.delay_max_)*/nullptr
180 , /*decltype(_impl_._cached_size_)*/{}} {}
181 struct RetryWindowDefaultTypeInternal {
RetryWindowDefaultTypeInternalgoogle::internal::federatedcompute::v1::RetryWindowDefaultTypeInternal182 PROTOBUF_CONSTEXPR RetryWindowDefaultTypeInternal()
183 : _instance(::_pbi::ConstantInitialized{}) {}
~RetryWindowDefaultTypeInternalgoogle::internal::federatedcompute::v1::RetryWindowDefaultTypeInternal184 ~RetryWindowDefaultTypeInternal() {}
185 union { // NOLINT(misc-non-private-member-variables-in-classes)
186 RetryWindow _instance;
187 };
188 };
189 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RetryWindowDefaultTypeInternal _RetryWindow_default_instance_;
ByteStreamResource(::_pbi::ConstantInitialized)190 PROTOBUF_CONSTEXPR ByteStreamResource::ByteStreamResource(
191 ::_pbi::ConstantInitialized): _impl_{
192 /*decltype(_impl_.resource_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
193 , /*decltype(_impl_.data_upload_forwarding_info_)*/nullptr
194 , /*decltype(_impl_._cached_size_)*/{}} {}
195 struct ByteStreamResourceDefaultTypeInternal {
ByteStreamResourceDefaultTypeInternalgoogle::internal::federatedcompute::v1::ByteStreamResourceDefaultTypeInternal196 PROTOBUF_CONSTEXPR ByteStreamResourceDefaultTypeInternal()
197 : _instance(::_pbi::ConstantInitialized{}) {}
~ByteStreamResourceDefaultTypeInternalgoogle::internal::federatedcompute::v1::ByteStreamResourceDefaultTypeInternal198 ~ByteStreamResourceDefaultTypeInternal() {}
199 union { // NOLINT(misc-non-private-member-variables-in-classes)
200 ByteStreamResource _instance;
201 };
202 };
203 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ByteStreamResourceDefaultTypeInternal _ByteStreamResource_default_instance_;
Status(::_pbi::ConstantInitialized)204 PROTOBUF_CONSTEXPR Status::Status(
205 ::_pbi::ConstantInitialized): _impl_{
206 /*decltype(_impl_.message_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
207 , /*decltype(_impl_.code_)*/0
208 , /*decltype(_impl_._cached_size_)*/{}} {}
209 struct StatusDefaultTypeInternal {
StatusDefaultTypeInternalgoogle::internal::federatedcompute::v1::StatusDefaultTypeInternal210 PROTOBUF_CONSTEXPR StatusDefaultTypeInternal()
211 : _instance(::_pbi::ConstantInitialized{}) {}
~StatusDefaultTypeInternalgoogle::internal::federatedcompute::v1::StatusDefaultTypeInternal212 ~StatusDefaultTypeInternal() {}
213 union { // NOLINT(misc-non-private-member-variables-in-classes)
214 Status _instance;
215 };
216 };
217 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StatusDefaultTypeInternal _Status_default_instance_;
218 } // namespace v1
219 } // namespace federatedcompute
220 } // namespace internal
221 } // namespace google
222 namespace google {
223 namespace internal {
224 namespace federatedcompute {
225 namespace v1 {
RejectionReason_Enum_IsValid(int value)226 bool RejectionReason_Enum_IsValid(int value) {
227 switch (value) {
228 case 0:
229 case 1:
230 case 2:
231 case 3:
232 return true;
233 default:
234 return false;
235 }
236 }
237
238 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> RejectionReason_Enum_strings[4] = {};
239
240 static const char RejectionReason_Enum_names[] =
241 "NO_TASK_AVAILABLE"
242 "UNAUTHENTICATED"
243 "UNAUTHORIZED"
244 "UNKNOWN";
245
246 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry RejectionReason_Enum_entries[] = {
247 { {RejectionReason_Enum_names + 0, 17}, 1 },
248 { {RejectionReason_Enum_names + 17, 15}, 3 },
249 { {RejectionReason_Enum_names + 32, 12}, 2 },
250 { {RejectionReason_Enum_names + 44, 7}, 0 },
251 };
252
253 static const int RejectionReason_Enum_entries_by_number[] = {
254 3, // 0 -> UNKNOWN
255 0, // 1 -> NO_TASK_AVAILABLE
256 2, // 2 -> UNAUTHORIZED
257 1, // 3 -> UNAUTHENTICATED
258 };
259
RejectionReason_Enum_Name(RejectionReason_Enum value)260 const std::string& RejectionReason_Enum_Name(
261 RejectionReason_Enum value) {
262 static const bool dummy =
263 ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
264 RejectionReason_Enum_entries,
265 RejectionReason_Enum_entries_by_number,
266 4, RejectionReason_Enum_strings);
267 (void) dummy;
268 int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
269 RejectionReason_Enum_entries,
270 RejectionReason_Enum_entries_by_number,
271 4, value);
272 return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
273 RejectionReason_Enum_strings[idx].get();
274 }
RejectionReason_Enum_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,RejectionReason_Enum * value)275 bool RejectionReason_Enum_Parse(
276 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, RejectionReason_Enum* value) {
277 int int_value;
278 bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
279 RejectionReason_Enum_entries, 4, name, &int_value);
280 if (success) {
281 *value = static_cast<RejectionReason_Enum>(int_value);
282 }
283 return success;
284 }
285 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
286 constexpr RejectionReason_Enum RejectionReason::UNKNOWN;
287 constexpr RejectionReason_Enum RejectionReason::NO_TASK_AVAILABLE;
288 constexpr RejectionReason_Enum RejectionReason::UNAUTHORIZED;
289 constexpr RejectionReason_Enum RejectionReason::UNAUTHENTICATED;
290 constexpr RejectionReason_Enum RejectionReason::Enum_MIN;
291 constexpr RejectionReason_Enum RejectionReason::Enum_MAX;
292 constexpr int RejectionReason::Enum_ARRAYSIZE;
293 #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
ResourceCompressionFormat_IsValid(int value)294 bool ResourceCompressionFormat_IsValid(int value) {
295 switch (value) {
296 case 0:
297 case 1:
298 return true;
299 default:
300 return false;
301 }
302 }
303
304 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ResourceCompressionFormat_strings[2] = {};
305
306 static const char ResourceCompressionFormat_names[] =
307 "RESOURCE_COMPRESSION_FORMAT_GZIP"
308 "RESOURCE_COMPRESSION_FORMAT_UNSPECIFIED";
309
310 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ResourceCompressionFormat_entries[] = {
311 { {ResourceCompressionFormat_names + 0, 32}, 1 },
312 { {ResourceCompressionFormat_names + 32, 39}, 0 },
313 };
314
315 static const int ResourceCompressionFormat_entries_by_number[] = {
316 1, // 0 -> RESOURCE_COMPRESSION_FORMAT_UNSPECIFIED
317 0, // 1 -> RESOURCE_COMPRESSION_FORMAT_GZIP
318 };
319
ResourceCompressionFormat_Name(ResourceCompressionFormat value)320 const std::string& ResourceCompressionFormat_Name(
321 ResourceCompressionFormat value) {
322 static const bool dummy =
323 ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
324 ResourceCompressionFormat_entries,
325 ResourceCompressionFormat_entries_by_number,
326 2, ResourceCompressionFormat_strings);
327 (void) dummy;
328 int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
329 ResourceCompressionFormat_entries,
330 ResourceCompressionFormat_entries_by_number,
331 2, value);
332 return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
333 ResourceCompressionFormat_strings[idx].get();
334 }
ResourceCompressionFormat_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,ResourceCompressionFormat * value)335 bool ResourceCompressionFormat_Parse(
336 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ResourceCompressionFormat* value) {
337 int int_value;
338 bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
339 ResourceCompressionFormat_entries, 2, name, &int_value);
340 if (success) {
341 *value = static_cast<ResourceCompressionFormat>(int_value);
342 }
343 return success;
344 }
Code_IsValid(int value)345 bool Code_IsValid(int value) {
346 switch (value) {
347 case 0:
348 case 1:
349 case 2:
350 case 3:
351 case 4:
352 case 5:
353 case 6:
354 case 7:
355 case 8:
356 case 9:
357 case 10:
358 case 11:
359 case 12:
360 case 13:
361 case 14:
362 case 15:
363 case 16:
364 return true;
365 default:
366 return false;
367 }
368 }
369
370 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> Code_strings[17] = {};
371
372 static const char Code_names[] =
373 "ABORTED"
374 "ALREADY_EXISTS"
375 "CANCELLED"
376 "DATA_LOSS"
377 "DEADLINE_EXCEEDED"
378 "FAILED_PRECONDITION"
379 "INTERNAL"
380 "INVALID_ARGUMENT"
381 "NOT_FOUND"
382 "OK"
383 "OUT_OF_RANGE"
384 "PERMISSION_DENIED"
385 "RESOURCE_EXHAUSTED"
386 "UNAUTHENTICATED"
387 "UNAVAILABLE"
388 "UNIMPLEMENTED"
389 "UNKNOWN";
390
391 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry Code_entries[] = {
392 { {Code_names + 0, 7}, 10 },
393 { {Code_names + 7, 14}, 6 },
394 { {Code_names + 21, 9}, 1 },
395 { {Code_names + 30, 9}, 15 },
396 { {Code_names + 39, 17}, 4 },
397 { {Code_names + 56, 19}, 9 },
398 { {Code_names + 75, 8}, 13 },
399 { {Code_names + 83, 16}, 3 },
400 { {Code_names + 99, 9}, 5 },
401 { {Code_names + 108, 2}, 0 },
402 { {Code_names + 110, 12}, 11 },
403 { {Code_names + 122, 17}, 7 },
404 { {Code_names + 139, 18}, 8 },
405 { {Code_names + 157, 15}, 16 },
406 { {Code_names + 172, 11}, 14 },
407 { {Code_names + 183, 13}, 12 },
408 { {Code_names + 196, 7}, 2 },
409 };
410
411 static const int Code_entries_by_number[] = {
412 9, // 0 -> OK
413 2, // 1 -> CANCELLED
414 16, // 2 -> UNKNOWN
415 7, // 3 -> INVALID_ARGUMENT
416 4, // 4 -> DEADLINE_EXCEEDED
417 8, // 5 -> NOT_FOUND
418 1, // 6 -> ALREADY_EXISTS
419 11, // 7 -> PERMISSION_DENIED
420 12, // 8 -> RESOURCE_EXHAUSTED
421 5, // 9 -> FAILED_PRECONDITION
422 0, // 10 -> ABORTED
423 10, // 11 -> OUT_OF_RANGE
424 15, // 12 -> UNIMPLEMENTED
425 6, // 13 -> INTERNAL
426 14, // 14 -> UNAVAILABLE
427 3, // 15 -> DATA_LOSS
428 13, // 16 -> UNAUTHENTICATED
429 };
430
Code_Name(Code value)431 const std::string& Code_Name(
432 Code value) {
433 static const bool dummy =
434 ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
435 Code_entries,
436 Code_entries_by_number,
437 17, Code_strings);
438 (void) dummy;
439 int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
440 Code_entries,
441 Code_entries_by_number,
442 17, value);
443 return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
444 Code_strings[idx].get();
445 }
Code_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,Code * value)446 bool Code_Parse(
447 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Code* value) {
448 int int_value;
449 bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
450 Code_entries, 17, name, &int_value);
451 if (success) {
452 *value = static_cast<Code>(int_value);
453 }
454 return success;
455 }
456
457 // ===================================================================
458
ForwardingInfo_ExtraRequestHeadersEntry_DoNotUse()459 ForwardingInfo_ExtraRequestHeadersEntry_DoNotUse::ForwardingInfo_ExtraRequestHeadersEntry_DoNotUse() {}
ForwardingInfo_ExtraRequestHeadersEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena * arena)460 ForwardingInfo_ExtraRequestHeadersEntry_DoNotUse::ForwardingInfo_ExtraRequestHeadersEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
461 : SuperType(arena) {}
MergeFrom(const ForwardingInfo_ExtraRequestHeadersEntry_DoNotUse & other)462 void ForwardingInfo_ExtraRequestHeadersEntry_DoNotUse::MergeFrom(const ForwardingInfo_ExtraRequestHeadersEntry_DoNotUse& other) {
463 MergeFromInternal(other);
464 }
465
466 // ===================================================================
467
468 class ForwardingInfo::_Internal {
469 public:
470 };
471
ForwardingInfo(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)472 ForwardingInfo::ForwardingInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
473 bool is_message_owned)
474 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
475 SharedCtor(arena, is_message_owned);
476 // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.ForwardingInfo)
477 }
ForwardingInfo(const ForwardingInfo & from)478 ForwardingInfo::ForwardingInfo(const ForwardingInfo& from)
479 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
480 ForwardingInfo* const _this = this; (void)_this;
481 new (&_impl_) Impl_{
482 /*decltype(_impl_.extra_request_headers_)*/{}
483 , decltype(_impl_.target_uri_prefix_){}
484 , /*decltype(_impl_._cached_size_)*/{}};
485
486 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
487 _this->_impl_.extra_request_headers_.MergeFrom(from._impl_.extra_request_headers_);
488 _impl_.target_uri_prefix_.InitDefault();
489 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
490 _impl_.target_uri_prefix_.Set("", GetArenaForAllocation());
491 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
492 if (!from._internal_target_uri_prefix().empty()) {
493 _this->_impl_.target_uri_prefix_.Set(from._internal_target_uri_prefix(),
494 _this->GetArenaForAllocation());
495 }
496 // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.ForwardingInfo)
497 }
498
SharedCtor(::_pb::Arena * arena,bool is_message_owned)499 inline void ForwardingInfo::SharedCtor(
500 ::_pb::Arena* arena, bool is_message_owned) {
501 (void)arena;
502 (void)is_message_owned;
503 new (&_impl_) Impl_{
504 /*decltype(_impl_.extra_request_headers_)*/{::_pbi::ArenaInitialized(), arena}
505 , decltype(_impl_.target_uri_prefix_){}
506 , /*decltype(_impl_._cached_size_)*/{}
507 };
508 _impl_.target_uri_prefix_.InitDefault();
509 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
510 _impl_.target_uri_prefix_.Set("", GetArenaForAllocation());
511 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
512 }
513
~ForwardingInfo()514 ForwardingInfo::~ForwardingInfo() {
515 // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.ForwardingInfo)
516 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
517 (void)arena;
518 return;
519 }
520 SharedDtor();
521 }
522
SharedDtor()523 inline void ForwardingInfo::SharedDtor() {
524 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
525 _impl_.extra_request_headers_.Destruct();
526 _impl_.extra_request_headers_.~MapFieldLite();
527 _impl_.target_uri_prefix_.Destroy();
528 }
529
SetCachedSize(int size) const530 void ForwardingInfo::SetCachedSize(int size) const {
531 _impl_._cached_size_.Set(size);
532 }
533
Clear()534 void ForwardingInfo::Clear() {
535 // @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.ForwardingInfo)
536 ::uint32_t cached_has_bits = 0;
537 // Prevent compiler warnings about cached_has_bits being unused
538 (void) cached_has_bits;
539
540 _impl_.extra_request_headers_.Clear();
541 _impl_.target_uri_prefix_.ClearToEmpty();
542 _internal_metadata_.Clear<std::string>();
543 }
544
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)545 const char* ForwardingInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
546 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
547 while (!ctx->Done(&ptr)) {
548 ::uint32_t tag;
549 ptr = ::_pbi::ReadTag(ptr, &tag);
550 switch (tag >> 3) {
551 // string target_uri_prefix = 1;
552 case 1:
553 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
554 auto str = _internal_mutable_target_uri_prefix();
555 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
556 CHK_(ptr);
557 CHK_(::_pbi::VerifyUTF8(str, nullptr));
558 } else {
559 goto handle_unusual;
560 }
561 continue;
562 // map<string, string> extra_request_headers = 2;
563 case 2:
564 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
565 ptr -= 1;
566 do {
567 ptr += 1;
568 ptr = ctx->ParseMessage(&_impl_.extra_request_headers_, ptr);
569 CHK_(ptr);
570 if (!ctx->DataAvailable(ptr)) break;
571 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
572 } else {
573 goto handle_unusual;
574 }
575 continue;
576 default:
577 goto handle_unusual;
578 } // switch
579 handle_unusual:
580 if ((tag == 0) || ((tag & 7) == 4)) {
581 CHK_(ptr);
582 ctx->SetLastTag(tag);
583 goto message_done;
584 }
585 ptr = UnknownFieldParse(
586 tag,
587 _internal_metadata_.mutable_unknown_fields<std::string>(),
588 ptr, ctx);
589 CHK_(ptr != nullptr);
590 } // while
591 message_done:
592 return ptr;
593 failure:
594 ptr = nullptr;
595 goto message_done;
596 #undef CHK_
597 }
598
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const599 ::uint8_t* ForwardingInfo::_InternalSerialize(
600 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
601 // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.ForwardingInfo)
602 ::uint32_t cached_has_bits = 0;
603 (void) cached_has_bits;
604
605 // string target_uri_prefix = 1;
606 if (!this->_internal_target_uri_prefix().empty()) {
607 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
608 this->_internal_target_uri_prefix().data(), static_cast<int>(this->_internal_target_uri_prefix().length()),
609 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
610 "google.internal.federatedcompute.v1.ForwardingInfo.target_uri_prefix");
611 target = stream->WriteStringMaybeAliased(
612 1, this->_internal_target_uri_prefix(), target);
613 }
614
615 // map<string, string> extra_request_headers = 2;
616 if (!this->_internal_extra_request_headers().empty()) {
617 using MapType = ::_pb::Map<std::string, std::string>;
618 using WireHelper = ForwardingInfo_ExtraRequestHeadersEntry_DoNotUse::Funcs;
619 const auto& map_field = this->_internal_extra_request_headers();
620 auto check_utf8 = [](const MapType::value_type& entry) {
621 (void)entry;
622 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
623 entry.first.data(), static_cast<int>(entry.first.length()),
624 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
625 "google.internal.federatedcompute.v1.ForwardingInfo.ExtraRequestHeadersEntry.key");
626 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
627 entry.second.data(), static_cast<int>(entry.second.length()),
628 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
629 "google.internal.federatedcompute.v1.ForwardingInfo.ExtraRequestHeadersEntry.value");
630 };
631
632 if (stream->IsSerializationDeterministic() && map_field.size() > 1) {
633 for (const auto& entry : ::_pbi::MapSorterPtr<MapType>(map_field)) {
634 target = WireHelper::InternalSerialize(2, entry.first, entry.second, target, stream);
635 check_utf8(entry);
636 }
637 } else {
638 for (const auto& entry : map_field) {
639 target = WireHelper::InternalSerialize(2, entry.first, entry.second, target, stream);
640 check_utf8(entry);
641 }
642 }
643 }
644
645 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
646 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
647 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
648 }
649 // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.ForwardingInfo)
650 return target;
651 }
652
ByteSizeLong() const653 size_t ForwardingInfo::ByteSizeLong() const {
654 // @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.ForwardingInfo)
655 size_t total_size = 0;
656
657 ::uint32_t cached_has_bits = 0;
658 // Prevent compiler warnings about cached_has_bits being unused
659 (void) cached_has_bits;
660
661 // map<string, string> extra_request_headers = 2;
662 total_size += 1 *
663 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_extra_request_headers_size());
664 for (::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::const_iterator
665 it = this->_internal_extra_request_headers().begin();
666 it != this->_internal_extra_request_headers().end(); ++it) {
667 total_size += ForwardingInfo_ExtraRequestHeadersEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
668 }
669
670 // string target_uri_prefix = 1;
671 if (!this->_internal_target_uri_prefix().empty()) {
672 total_size += 1 +
673 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
674 this->_internal_target_uri_prefix());
675 }
676
677 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
678 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
679 }
680 int cached_size = ::_pbi::ToCachedSize(total_size);
681 SetCachedSize(cached_size);
682 return total_size;
683 }
684
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)685 void ForwardingInfo::CheckTypeAndMergeFrom(
686 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
687 MergeFrom(*::_pbi::DownCast<const ForwardingInfo*>(
688 &from));
689 }
690
MergeFrom(const ForwardingInfo & from)691 void ForwardingInfo::MergeFrom(const ForwardingInfo& from) {
692 ForwardingInfo* const _this = this;
693 // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.ForwardingInfo)
694 GOOGLE_DCHECK_NE(&from, _this);
695 ::uint32_t cached_has_bits = 0;
696 (void) cached_has_bits;
697
698 _this->_impl_.extra_request_headers_.MergeFrom(from._impl_.extra_request_headers_);
699 if (!from._internal_target_uri_prefix().empty()) {
700 _this->_internal_set_target_uri_prefix(from._internal_target_uri_prefix());
701 }
702 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
703 }
704
CopyFrom(const ForwardingInfo & from)705 void ForwardingInfo::CopyFrom(const ForwardingInfo& from) {
706 // @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.ForwardingInfo)
707 if (&from == this) return;
708 Clear();
709 MergeFrom(from);
710 }
711
IsInitialized() const712 bool ForwardingInfo::IsInitialized() const {
713 return true;
714 }
715
InternalSwap(ForwardingInfo * other)716 void ForwardingInfo::InternalSwap(ForwardingInfo* other) {
717 using std::swap;
718 auto* lhs_arena = GetArenaForAllocation();
719 auto* rhs_arena = other->GetArenaForAllocation();
720 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
721 _impl_.extra_request_headers_.InternalSwap(&other->_impl_.extra_request_headers_);
722 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
723 &_impl_.target_uri_prefix_, lhs_arena,
724 &other->_impl_.target_uri_prefix_, rhs_arena
725 );
726 }
727
GetTypeName() const728 std::string ForwardingInfo::GetTypeName() const {
729 return "google.internal.federatedcompute.v1.ForwardingInfo";
730 }
731
732
733 // ===================================================================
734
735 class AttestationMeasurement::_Internal {
736 public:
737 };
738
AttestationMeasurement(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)739 AttestationMeasurement::AttestationMeasurement(::PROTOBUF_NAMESPACE_ID::Arena* arena,
740 bool is_message_owned)
741 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
742 SharedCtor(arena, is_message_owned);
743 // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.AttestationMeasurement)
744 }
AttestationMeasurement(const AttestationMeasurement & from)745 AttestationMeasurement::AttestationMeasurement(const AttestationMeasurement& from)
746 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
747 AttestationMeasurement* const _this = this; (void)_this;
748 new (&_impl_) Impl_{
749 decltype(_impl_.value_){}
750 , /*decltype(_impl_._cached_size_)*/{}};
751
752 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
753 _impl_.value_.InitDefault();
754 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
755 _impl_.value_.Set("", GetArenaForAllocation());
756 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
757 if (!from._internal_value().empty()) {
758 _this->_impl_.value_.Set(from._internal_value(),
759 _this->GetArenaForAllocation());
760 }
761 // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.AttestationMeasurement)
762 }
763
SharedCtor(::_pb::Arena * arena,bool is_message_owned)764 inline void AttestationMeasurement::SharedCtor(
765 ::_pb::Arena* arena, bool is_message_owned) {
766 (void)arena;
767 (void)is_message_owned;
768 new (&_impl_) Impl_{
769 decltype(_impl_.value_){}
770 , /*decltype(_impl_._cached_size_)*/{}
771 };
772 _impl_.value_.InitDefault();
773 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
774 _impl_.value_.Set("", GetArenaForAllocation());
775 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
776 }
777
~AttestationMeasurement()778 AttestationMeasurement::~AttestationMeasurement() {
779 // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.AttestationMeasurement)
780 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
781 (void)arena;
782 return;
783 }
784 SharedDtor();
785 }
786
SharedDtor()787 inline void AttestationMeasurement::SharedDtor() {
788 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
789 _impl_.value_.Destroy();
790 }
791
SetCachedSize(int size) const792 void AttestationMeasurement::SetCachedSize(int size) const {
793 _impl_._cached_size_.Set(size);
794 }
795
Clear()796 void AttestationMeasurement::Clear() {
797 // @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.AttestationMeasurement)
798 ::uint32_t cached_has_bits = 0;
799 // Prevent compiler warnings about cached_has_bits being unused
800 (void) cached_has_bits;
801
802 _impl_.value_.ClearToEmpty();
803 _internal_metadata_.Clear<std::string>();
804 }
805
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)806 const char* AttestationMeasurement::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
807 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
808 while (!ctx->Done(&ptr)) {
809 ::uint32_t tag;
810 ptr = ::_pbi::ReadTag(ptr, &tag);
811 switch (tag >> 3) {
812 // string value = 1;
813 case 1:
814 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
815 auto str = _internal_mutable_value();
816 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
817 CHK_(ptr);
818 CHK_(::_pbi::VerifyUTF8(str, nullptr));
819 } else {
820 goto handle_unusual;
821 }
822 continue;
823 default:
824 goto handle_unusual;
825 } // switch
826 handle_unusual:
827 if ((tag == 0) || ((tag & 7) == 4)) {
828 CHK_(ptr);
829 ctx->SetLastTag(tag);
830 goto message_done;
831 }
832 ptr = UnknownFieldParse(
833 tag,
834 _internal_metadata_.mutable_unknown_fields<std::string>(),
835 ptr, ctx);
836 CHK_(ptr != nullptr);
837 } // while
838 message_done:
839 return ptr;
840 failure:
841 ptr = nullptr;
842 goto message_done;
843 #undef CHK_
844 }
845
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const846 ::uint8_t* AttestationMeasurement::_InternalSerialize(
847 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
848 // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.AttestationMeasurement)
849 ::uint32_t cached_has_bits = 0;
850 (void) cached_has_bits;
851
852 // string value = 1;
853 if (!this->_internal_value().empty()) {
854 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
855 this->_internal_value().data(), static_cast<int>(this->_internal_value().length()),
856 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
857 "google.internal.federatedcompute.v1.AttestationMeasurement.value");
858 target = stream->WriteStringMaybeAliased(
859 1, this->_internal_value(), target);
860 }
861
862 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
863 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
864 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
865 }
866 // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.AttestationMeasurement)
867 return target;
868 }
869
ByteSizeLong() const870 size_t AttestationMeasurement::ByteSizeLong() const {
871 // @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.AttestationMeasurement)
872 size_t total_size = 0;
873
874 ::uint32_t cached_has_bits = 0;
875 // Prevent compiler warnings about cached_has_bits being unused
876 (void) cached_has_bits;
877
878 // string value = 1;
879 if (!this->_internal_value().empty()) {
880 total_size += 1 +
881 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
882 this->_internal_value());
883 }
884
885 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
886 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
887 }
888 int cached_size = ::_pbi::ToCachedSize(total_size);
889 SetCachedSize(cached_size);
890 return total_size;
891 }
892
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)893 void AttestationMeasurement::CheckTypeAndMergeFrom(
894 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
895 MergeFrom(*::_pbi::DownCast<const AttestationMeasurement*>(
896 &from));
897 }
898
MergeFrom(const AttestationMeasurement & from)899 void AttestationMeasurement::MergeFrom(const AttestationMeasurement& from) {
900 AttestationMeasurement* const _this = this;
901 // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.AttestationMeasurement)
902 GOOGLE_DCHECK_NE(&from, _this);
903 ::uint32_t cached_has_bits = 0;
904 (void) cached_has_bits;
905
906 if (!from._internal_value().empty()) {
907 _this->_internal_set_value(from._internal_value());
908 }
909 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
910 }
911
CopyFrom(const AttestationMeasurement & from)912 void AttestationMeasurement::CopyFrom(const AttestationMeasurement& from) {
913 // @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.AttestationMeasurement)
914 if (&from == this) return;
915 Clear();
916 MergeFrom(from);
917 }
918
IsInitialized() const919 bool AttestationMeasurement::IsInitialized() const {
920 return true;
921 }
922
InternalSwap(AttestationMeasurement * other)923 void AttestationMeasurement::InternalSwap(AttestationMeasurement* other) {
924 using std::swap;
925 auto* lhs_arena = GetArenaForAllocation();
926 auto* rhs_arena = other->GetArenaForAllocation();
927 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
928 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
929 &_impl_.value_, lhs_arena,
930 &other->_impl_.value_, rhs_arena
931 );
932 }
933
GetTypeName() const934 std::string AttestationMeasurement::GetTypeName() const {
935 return "google.internal.federatedcompute.v1.AttestationMeasurement";
936 }
937
938
939 // ===================================================================
940
941 class ClientVersion::_Internal {
942 public:
943 };
944
ClientVersion(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)945 ClientVersion::ClientVersion(::PROTOBUF_NAMESPACE_ID::Arena* arena,
946 bool is_message_owned)
947 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
948 SharedCtor(arena, is_message_owned);
949 // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.ClientVersion)
950 }
ClientVersion(const ClientVersion & from)951 ClientVersion::ClientVersion(const ClientVersion& from)
952 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
953 ClientVersion* const _this = this; (void)_this;
954 new (&_impl_) Impl_{
955 decltype(_impl_.version_code_){}
956 , /*decltype(_impl_._cached_size_)*/{}};
957
958 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
959 _impl_.version_code_.InitDefault();
960 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
961 _impl_.version_code_.Set("", GetArenaForAllocation());
962 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
963 if (!from._internal_version_code().empty()) {
964 _this->_impl_.version_code_.Set(from._internal_version_code(),
965 _this->GetArenaForAllocation());
966 }
967 // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.ClientVersion)
968 }
969
SharedCtor(::_pb::Arena * arena,bool is_message_owned)970 inline void ClientVersion::SharedCtor(
971 ::_pb::Arena* arena, bool is_message_owned) {
972 (void)arena;
973 (void)is_message_owned;
974 new (&_impl_) Impl_{
975 decltype(_impl_.version_code_){}
976 , /*decltype(_impl_._cached_size_)*/{}
977 };
978 _impl_.version_code_.InitDefault();
979 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
980 _impl_.version_code_.Set("", GetArenaForAllocation());
981 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
982 }
983
~ClientVersion()984 ClientVersion::~ClientVersion() {
985 // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.ClientVersion)
986 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
987 (void)arena;
988 return;
989 }
990 SharedDtor();
991 }
992
SharedDtor()993 inline void ClientVersion::SharedDtor() {
994 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
995 _impl_.version_code_.Destroy();
996 }
997
SetCachedSize(int size) const998 void ClientVersion::SetCachedSize(int size) const {
999 _impl_._cached_size_.Set(size);
1000 }
1001
Clear()1002 void ClientVersion::Clear() {
1003 // @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.ClientVersion)
1004 ::uint32_t cached_has_bits = 0;
1005 // Prevent compiler warnings about cached_has_bits being unused
1006 (void) cached_has_bits;
1007
1008 _impl_.version_code_.ClearToEmpty();
1009 _internal_metadata_.Clear<std::string>();
1010 }
1011
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1012 const char* ClientVersion::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1013 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1014 while (!ctx->Done(&ptr)) {
1015 ::uint32_t tag;
1016 ptr = ::_pbi::ReadTag(ptr, &tag);
1017 switch (tag >> 3) {
1018 // string version_code = 1;
1019 case 1:
1020 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1021 auto str = _internal_mutable_version_code();
1022 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1023 CHK_(ptr);
1024 CHK_(::_pbi::VerifyUTF8(str, nullptr));
1025 } else {
1026 goto handle_unusual;
1027 }
1028 continue;
1029 default:
1030 goto handle_unusual;
1031 } // switch
1032 handle_unusual:
1033 if ((tag == 0) || ((tag & 7) == 4)) {
1034 CHK_(ptr);
1035 ctx->SetLastTag(tag);
1036 goto message_done;
1037 }
1038 ptr = UnknownFieldParse(
1039 tag,
1040 _internal_metadata_.mutable_unknown_fields<std::string>(),
1041 ptr, ctx);
1042 CHK_(ptr != nullptr);
1043 } // while
1044 message_done:
1045 return ptr;
1046 failure:
1047 ptr = nullptr;
1048 goto message_done;
1049 #undef CHK_
1050 }
1051
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1052 ::uint8_t* ClientVersion::_InternalSerialize(
1053 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1054 // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.ClientVersion)
1055 ::uint32_t cached_has_bits = 0;
1056 (void) cached_has_bits;
1057
1058 // string version_code = 1;
1059 if (!this->_internal_version_code().empty()) {
1060 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1061 this->_internal_version_code().data(), static_cast<int>(this->_internal_version_code().length()),
1062 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1063 "google.internal.federatedcompute.v1.ClientVersion.version_code");
1064 target = stream->WriteStringMaybeAliased(
1065 1, this->_internal_version_code(), target);
1066 }
1067
1068 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1069 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1070 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1071 }
1072 // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.ClientVersion)
1073 return target;
1074 }
1075
ByteSizeLong() const1076 size_t ClientVersion::ByteSizeLong() const {
1077 // @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.ClientVersion)
1078 size_t total_size = 0;
1079
1080 ::uint32_t cached_has_bits = 0;
1081 // Prevent compiler warnings about cached_has_bits being unused
1082 (void) cached_has_bits;
1083
1084 // string version_code = 1;
1085 if (!this->_internal_version_code().empty()) {
1086 total_size += 1 +
1087 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1088 this->_internal_version_code());
1089 }
1090
1091 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1092 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1093 }
1094 int cached_size = ::_pbi::ToCachedSize(total_size);
1095 SetCachedSize(cached_size);
1096 return total_size;
1097 }
1098
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1099 void ClientVersion::CheckTypeAndMergeFrom(
1100 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1101 MergeFrom(*::_pbi::DownCast<const ClientVersion*>(
1102 &from));
1103 }
1104
MergeFrom(const ClientVersion & from)1105 void ClientVersion::MergeFrom(const ClientVersion& from) {
1106 ClientVersion* const _this = this;
1107 // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.ClientVersion)
1108 GOOGLE_DCHECK_NE(&from, _this);
1109 ::uint32_t cached_has_bits = 0;
1110 (void) cached_has_bits;
1111
1112 if (!from._internal_version_code().empty()) {
1113 _this->_internal_set_version_code(from._internal_version_code());
1114 }
1115 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1116 }
1117
CopyFrom(const ClientVersion & from)1118 void ClientVersion::CopyFrom(const ClientVersion& from) {
1119 // @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.ClientVersion)
1120 if (&from == this) return;
1121 Clear();
1122 MergeFrom(from);
1123 }
1124
IsInitialized() const1125 bool ClientVersion::IsInitialized() const {
1126 return true;
1127 }
1128
InternalSwap(ClientVersion * other)1129 void ClientVersion::InternalSwap(ClientVersion* other) {
1130 using std::swap;
1131 auto* lhs_arena = GetArenaForAllocation();
1132 auto* rhs_arena = other->GetArenaForAllocation();
1133 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1134 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1135 &_impl_.version_code_, lhs_arena,
1136 &other->_impl_.version_code_, rhs_arena
1137 );
1138 }
1139
GetTypeName() const1140 std::string ClientVersion::GetTypeName() const {
1141 return "google.internal.federatedcompute.v1.ClientVersion";
1142 }
1143
1144
1145 // ===================================================================
1146
1147 class Resource_InlineResource::_Internal {
1148 public:
1149 using HasBits = decltype(std::declval<Resource_InlineResource>()._impl_._has_bits_);
set_has_compression_format(HasBits * has_bits)1150 static void set_has_compression_format(HasBits* has_bits) {
1151 (*has_bits)[0] |= 1u;
1152 }
1153 };
1154
Resource_InlineResource(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1155 Resource_InlineResource::Resource_InlineResource(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1156 bool is_message_owned)
1157 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1158 SharedCtor(arena, is_message_owned);
1159 // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.Resource.InlineResource)
1160 }
Resource_InlineResource(const Resource_InlineResource & from)1161 Resource_InlineResource::Resource_InlineResource(const Resource_InlineResource& from)
1162 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1163 Resource_InlineResource* const _this = this; (void)_this;
1164 new (&_impl_) Impl_{
1165 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1166 , /*decltype(_impl_._cached_size_)*/{}
1167 , decltype(_impl_.data_){}
1168 , decltype(_impl_.compression_format_){}};
1169
1170 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1171 _impl_.data_.InitDefault();
1172 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1173 _impl_.data_.Set("", GetArenaForAllocation());
1174 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1175 if (!from._internal_data().empty()) {
1176 _this->_impl_.data_.Set(from._internal_data(),
1177 _this->GetArenaForAllocation());
1178 }
1179 _this->_impl_.compression_format_ = from._impl_.compression_format_;
1180 // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.Resource.InlineResource)
1181 }
1182
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1183 inline void Resource_InlineResource::SharedCtor(
1184 ::_pb::Arena* arena, bool is_message_owned) {
1185 (void)arena;
1186 (void)is_message_owned;
1187 new (&_impl_) Impl_{
1188 decltype(_impl_._has_bits_){}
1189 , /*decltype(_impl_._cached_size_)*/{}
1190 , decltype(_impl_.data_){}
1191 , decltype(_impl_.compression_format_){0}
1192 };
1193 _impl_.data_.InitDefault();
1194 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1195 _impl_.data_.Set("", GetArenaForAllocation());
1196 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1197 }
1198
~Resource_InlineResource()1199 Resource_InlineResource::~Resource_InlineResource() {
1200 // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.Resource.InlineResource)
1201 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1202 (void)arena;
1203 return;
1204 }
1205 SharedDtor();
1206 }
1207
SharedDtor()1208 inline void Resource_InlineResource::SharedDtor() {
1209 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1210 _impl_.data_.Destroy();
1211 }
1212
SetCachedSize(int size) const1213 void Resource_InlineResource::SetCachedSize(int size) const {
1214 _impl_._cached_size_.Set(size);
1215 }
1216
Clear()1217 void Resource_InlineResource::Clear() {
1218 // @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.Resource.InlineResource)
1219 ::uint32_t cached_has_bits = 0;
1220 // Prevent compiler warnings about cached_has_bits being unused
1221 (void) cached_has_bits;
1222
1223 _impl_.data_.ClearToEmpty();
1224 _impl_.compression_format_ = 0;
1225 _impl_._has_bits_.Clear();
1226 _internal_metadata_.Clear<std::string>();
1227 }
1228
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1229 const char* Resource_InlineResource::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1230 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1231 _Internal::HasBits has_bits{};
1232 while (!ctx->Done(&ptr)) {
1233 ::uint32_t tag;
1234 ptr = ::_pbi::ReadTag(ptr, &tag);
1235 switch (tag >> 3) {
1236 // bytes data = 1;
1237 case 1:
1238 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1239 auto str = _internal_mutable_data();
1240 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1241 CHK_(ptr);
1242 } else {
1243 goto handle_unusual;
1244 }
1245 continue;
1246 // optional .google.internal.federatedcompute.v1.ResourceCompressionFormat compression_format = 2;
1247 case 2:
1248 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1249 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1250 CHK_(ptr);
1251 _internal_set_compression_format(static_cast<::google::internal::federatedcompute::v1::ResourceCompressionFormat>(val));
1252 } else {
1253 goto handle_unusual;
1254 }
1255 continue;
1256 default:
1257 goto handle_unusual;
1258 } // switch
1259 handle_unusual:
1260 if ((tag == 0) || ((tag & 7) == 4)) {
1261 CHK_(ptr);
1262 ctx->SetLastTag(tag);
1263 goto message_done;
1264 }
1265 ptr = UnknownFieldParse(
1266 tag,
1267 _internal_metadata_.mutable_unknown_fields<std::string>(),
1268 ptr, ctx);
1269 CHK_(ptr != nullptr);
1270 } // while
1271 message_done:
1272 _impl_._has_bits_.Or(has_bits);
1273 return ptr;
1274 failure:
1275 ptr = nullptr;
1276 goto message_done;
1277 #undef CHK_
1278 }
1279
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1280 ::uint8_t* Resource_InlineResource::_InternalSerialize(
1281 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1282 // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.Resource.InlineResource)
1283 ::uint32_t cached_has_bits = 0;
1284 (void) cached_has_bits;
1285
1286 // bytes data = 1;
1287 if (!this->_internal_data().empty()) {
1288 target = stream->WriteBytesMaybeAliased(
1289 1, this->_internal_data(), target);
1290 }
1291
1292 // optional .google.internal.federatedcompute.v1.ResourceCompressionFormat compression_format = 2;
1293 if (_internal_has_compression_format()) {
1294 target = stream->EnsureSpace(target);
1295 target = ::_pbi::WireFormatLite::WriteEnumToArray(
1296 2, this->_internal_compression_format(), target);
1297 }
1298
1299 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1300 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1301 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1302 }
1303 // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.Resource.InlineResource)
1304 return target;
1305 }
1306
ByteSizeLong() const1307 size_t Resource_InlineResource::ByteSizeLong() const {
1308 // @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.Resource.InlineResource)
1309 size_t total_size = 0;
1310
1311 ::uint32_t cached_has_bits = 0;
1312 // Prevent compiler warnings about cached_has_bits being unused
1313 (void) cached_has_bits;
1314
1315 // bytes data = 1;
1316 if (!this->_internal_data().empty()) {
1317 total_size += 1 +
1318 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
1319 this->_internal_data());
1320 }
1321
1322 // optional .google.internal.federatedcompute.v1.ResourceCompressionFormat compression_format = 2;
1323 cached_has_bits = _impl_._has_bits_[0];
1324 if (cached_has_bits & 0x00000001u) {
1325 total_size += 1 +
1326 ::_pbi::WireFormatLite::EnumSize(this->_internal_compression_format());
1327 }
1328
1329 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1330 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1331 }
1332 int cached_size = ::_pbi::ToCachedSize(total_size);
1333 SetCachedSize(cached_size);
1334 return total_size;
1335 }
1336
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1337 void Resource_InlineResource::CheckTypeAndMergeFrom(
1338 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1339 MergeFrom(*::_pbi::DownCast<const Resource_InlineResource*>(
1340 &from));
1341 }
1342
MergeFrom(const Resource_InlineResource & from)1343 void Resource_InlineResource::MergeFrom(const Resource_InlineResource& from) {
1344 Resource_InlineResource* const _this = this;
1345 // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.Resource.InlineResource)
1346 GOOGLE_DCHECK_NE(&from, _this);
1347 ::uint32_t cached_has_bits = 0;
1348 (void) cached_has_bits;
1349
1350 if (!from._internal_data().empty()) {
1351 _this->_internal_set_data(from._internal_data());
1352 }
1353 if (from._internal_has_compression_format()) {
1354 _this->_internal_set_compression_format(from._internal_compression_format());
1355 }
1356 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1357 }
1358
CopyFrom(const Resource_InlineResource & from)1359 void Resource_InlineResource::CopyFrom(const Resource_InlineResource& from) {
1360 // @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.Resource.InlineResource)
1361 if (&from == this) return;
1362 Clear();
1363 MergeFrom(from);
1364 }
1365
IsInitialized() const1366 bool Resource_InlineResource::IsInitialized() const {
1367 return true;
1368 }
1369
InternalSwap(Resource_InlineResource * other)1370 void Resource_InlineResource::InternalSwap(Resource_InlineResource* other) {
1371 using std::swap;
1372 auto* lhs_arena = GetArenaForAllocation();
1373 auto* rhs_arena = other->GetArenaForAllocation();
1374 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1375 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1376 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1377 &_impl_.data_, lhs_arena,
1378 &other->_impl_.data_, rhs_arena
1379 );
1380 swap(_impl_.compression_format_, other->_impl_.compression_format_);
1381 }
1382
GetTypeName() const1383 std::string Resource_InlineResource::GetTypeName() const {
1384 return "google.internal.federatedcompute.v1.Resource.InlineResource";
1385 }
1386
1387
1388 // ===================================================================
1389
1390 class Resource::_Internal {
1391 public:
1392 using HasBits = decltype(std::declval<Resource>()._impl_._has_bits_);
1393 static const ::google::internal::federatedcompute::v1::Resource_InlineResource& inline_resource(const Resource* msg);
1394 static const ::PROTOBUF_NAMESPACE_ID::Duration& max_age(const Resource* msg);
set_has_compression_format(HasBits * has_bits)1395 static void set_has_compression_format(HasBits* has_bits) {
1396 (*has_bits)[0] |= 1u;
1397 }
1398 };
1399
1400 const ::google::internal::federatedcompute::v1::Resource_InlineResource&
inline_resource(const Resource * msg)1401 Resource::_Internal::inline_resource(const Resource* msg) {
1402 return *msg->_impl_.resource_.inline_resource_;
1403 }
1404 const ::PROTOBUF_NAMESPACE_ID::Duration&
max_age(const Resource * msg)1405 Resource::_Internal::max_age(const Resource* msg) {
1406 return *msg->_impl_.max_age_;
1407 }
set_allocated_inline_resource(::google::internal::federatedcompute::v1::Resource_InlineResource * inline_resource)1408 void Resource::set_allocated_inline_resource(::google::internal::federatedcompute::v1::Resource_InlineResource* inline_resource) {
1409 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
1410 clear_resource();
1411 if (inline_resource) {
1412 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1413 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(inline_resource);
1414 if (message_arena != submessage_arena) {
1415 inline_resource = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1416 message_arena, inline_resource, submessage_arena);
1417 }
1418 set_has_inline_resource();
1419 _impl_.resource_.inline_resource_ = inline_resource;
1420 }
1421 // @@protoc_insertion_point(field_set_allocated:google.internal.federatedcompute.v1.Resource.inline_resource)
1422 }
clear_max_age()1423 void Resource::clear_max_age() {
1424 if (GetArenaForAllocation() == nullptr && _impl_.max_age_ != nullptr) {
1425 delete _impl_.max_age_;
1426 }
1427 _impl_.max_age_ = nullptr;
1428 }
Resource(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1429 Resource::Resource(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1430 bool is_message_owned)
1431 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1432 SharedCtor(arena, is_message_owned);
1433 // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.Resource)
1434 }
Resource(const Resource & from)1435 Resource::Resource(const Resource& from)
1436 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1437 Resource* const _this = this; (void)_this;
1438 new (&_impl_) Impl_{
1439 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1440 , /*decltype(_impl_._cached_size_)*/{}
1441 , decltype(_impl_.client_cache_id_){}
1442 , decltype(_impl_.max_age_){nullptr}
1443 , decltype(_impl_.compression_format_){}
1444 , decltype(_impl_.resource_){}
1445 , /*decltype(_impl_._oneof_case_)*/{}};
1446
1447 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1448 _impl_.client_cache_id_.InitDefault();
1449 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1450 _impl_.client_cache_id_.Set("", GetArenaForAllocation());
1451 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1452 if (!from._internal_client_cache_id().empty()) {
1453 _this->_impl_.client_cache_id_.Set(from._internal_client_cache_id(),
1454 _this->GetArenaForAllocation());
1455 }
1456 if (from._internal_has_max_age()) {
1457 _this->_impl_.max_age_ = new ::PROTOBUF_NAMESPACE_ID::Duration(*from._impl_.max_age_);
1458 }
1459 _this->_impl_.compression_format_ = from._impl_.compression_format_;
1460 clear_has_resource();
1461 switch (from.resource_case()) {
1462 case kUri: {
1463 _this->_internal_set_uri(from._internal_uri());
1464 break;
1465 }
1466 case kInlineResource: {
1467 _this->_internal_mutable_inline_resource()->::google::internal::federatedcompute::v1::Resource_InlineResource::MergeFrom(
1468 from._internal_inline_resource());
1469 break;
1470 }
1471 case RESOURCE_NOT_SET: {
1472 break;
1473 }
1474 }
1475 // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.Resource)
1476 }
1477
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1478 inline void Resource::SharedCtor(
1479 ::_pb::Arena* arena, bool is_message_owned) {
1480 (void)arena;
1481 (void)is_message_owned;
1482 new (&_impl_) Impl_{
1483 decltype(_impl_._has_bits_){}
1484 , /*decltype(_impl_._cached_size_)*/{}
1485 , decltype(_impl_.client_cache_id_){}
1486 , decltype(_impl_.max_age_){nullptr}
1487 , decltype(_impl_.compression_format_){0}
1488 , decltype(_impl_.resource_){}
1489 , /*decltype(_impl_._oneof_case_)*/{}
1490 };
1491 _impl_.client_cache_id_.InitDefault();
1492 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1493 _impl_.client_cache_id_.Set("", GetArenaForAllocation());
1494 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1495 clear_has_resource();
1496 }
1497
~Resource()1498 Resource::~Resource() {
1499 // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.Resource)
1500 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1501 (void)arena;
1502 return;
1503 }
1504 SharedDtor();
1505 }
1506
SharedDtor()1507 inline void Resource::SharedDtor() {
1508 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1509 _impl_.client_cache_id_.Destroy();
1510 if (this != internal_default_instance()) delete _impl_.max_age_;
1511 if (has_resource()) {
1512 clear_resource();
1513 }
1514 }
1515
SetCachedSize(int size) const1516 void Resource::SetCachedSize(int size) const {
1517 _impl_._cached_size_.Set(size);
1518 }
1519
clear_resource()1520 void Resource::clear_resource() {
1521 // @@protoc_insertion_point(one_of_clear_start:google.internal.federatedcompute.v1.Resource)
1522 switch (resource_case()) {
1523 case kUri: {
1524 _impl_.resource_.uri_.Destroy();
1525 break;
1526 }
1527 case kInlineResource: {
1528 if (GetArenaForAllocation() == nullptr) {
1529 delete _impl_.resource_.inline_resource_;
1530 }
1531 break;
1532 }
1533 case RESOURCE_NOT_SET: {
1534 break;
1535 }
1536 }
1537 _impl_._oneof_case_[0] = RESOURCE_NOT_SET;
1538 }
1539
1540
Clear()1541 void Resource::Clear() {
1542 // @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.Resource)
1543 ::uint32_t cached_has_bits = 0;
1544 // Prevent compiler warnings about cached_has_bits being unused
1545 (void) cached_has_bits;
1546
1547 _impl_.client_cache_id_.ClearToEmpty();
1548 if (GetArenaForAllocation() == nullptr && _impl_.max_age_ != nullptr) {
1549 delete _impl_.max_age_;
1550 }
1551 _impl_.max_age_ = nullptr;
1552 _impl_.compression_format_ = 0;
1553 clear_resource();
1554 _impl_._has_bits_.Clear();
1555 _internal_metadata_.Clear<std::string>();
1556 }
1557
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1558 const char* Resource::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1559 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1560 _Internal::HasBits has_bits{};
1561 while (!ctx->Done(&ptr)) {
1562 ::uint32_t tag;
1563 ptr = ::_pbi::ReadTag(ptr, &tag);
1564 switch (tag >> 3) {
1565 // string uri = 1;
1566 case 1:
1567 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1568 auto str = _internal_mutable_uri();
1569 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1570 CHK_(ptr);
1571 CHK_(::_pbi::VerifyUTF8(str, nullptr));
1572 } else {
1573 goto handle_unusual;
1574 }
1575 continue;
1576 // .google.internal.federatedcompute.v1.Resource.InlineResource inline_resource = 3;
1577 case 3:
1578 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
1579 ptr = ctx->ParseMessage(_internal_mutable_inline_resource(), ptr);
1580 CHK_(ptr);
1581 } else {
1582 goto handle_unusual;
1583 }
1584 continue;
1585 // string client_cache_id = 4;
1586 case 4:
1587 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
1588 auto str = _internal_mutable_client_cache_id();
1589 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1590 CHK_(ptr);
1591 CHK_(::_pbi::VerifyUTF8(str, nullptr));
1592 } else {
1593 goto handle_unusual;
1594 }
1595 continue;
1596 // .google.protobuf.Duration max_age = 5;
1597 case 5:
1598 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
1599 ptr = ctx->ParseMessage(_internal_mutable_max_age(), ptr);
1600 CHK_(ptr);
1601 } else {
1602 goto handle_unusual;
1603 }
1604 continue;
1605 // optional .google.internal.federatedcompute.v1.ResourceCompressionFormat compression_format = 999;
1606 case 999:
1607 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
1608 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1609 CHK_(ptr);
1610 _internal_set_compression_format(static_cast<::google::internal::federatedcompute::v1::ResourceCompressionFormat>(val));
1611 } else {
1612 goto handle_unusual;
1613 }
1614 continue;
1615 default:
1616 goto handle_unusual;
1617 } // switch
1618 handle_unusual:
1619 if ((tag == 0) || ((tag & 7) == 4)) {
1620 CHK_(ptr);
1621 ctx->SetLastTag(tag);
1622 goto message_done;
1623 }
1624 ptr = UnknownFieldParse(
1625 tag,
1626 _internal_metadata_.mutable_unknown_fields<std::string>(),
1627 ptr, ctx);
1628 CHK_(ptr != nullptr);
1629 } // while
1630 message_done:
1631 _impl_._has_bits_.Or(has_bits);
1632 return ptr;
1633 failure:
1634 ptr = nullptr;
1635 goto message_done;
1636 #undef CHK_
1637 }
1638
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1639 ::uint8_t* Resource::_InternalSerialize(
1640 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1641 // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.Resource)
1642 ::uint32_t cached_has_bits = 0;
1643 (void) cached_has_bits;
1644
1645 // string uri = 1;
1646 if (_internal_has_uri()) {
1647 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1648 this->_internal_uri().data(), static_cast<int>(this->_internal_uri().length()),
1649 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1650 "google.internal.federatedcompute.v1.Resource.uri");
1651 target = stream->WriteStringMaybeAliased(
1652 1, this->_internal_uri(), target);
1653 }
1654
1655 // .google.internal.federatedcompute.v1.Resource.InlineResource inline_resource = 3;
1656 if (_internal_has_inline_resource()) {
1657 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1658 InternalWriteMessage(3, _Internal::inline_resource(this),
1659 _Internal::inline_resource(this).GetCachedSize(), target, stream);
1660 }
1661
1662 // string client_cache_id = 4;
1663 if (!this->_internal_client_cache_id().empty()) {
1664 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1665 this->_internal_client_cache_id().data(), static_cast<int>(this->_internal_client_cache_id().length()),
1666 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1667 "google.internal.federatedcompute.v1.Resource.client_cache_id");
1668 target = stream->WriteStringMaybeAliased(
1669 4, this->_internal_client_cache_id(), target);
1670 }
1671
1672 // .google.protobuf.Duration max_age = 5;
1673 if (this->_internal_has_max_age()) {
1674 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1675 InternalWriteMessage(5, _Internal::max_age(this),
1676 _Internal::max_age(this).GetCachedSize(), target, stream);
1677 }
1678
1679 // optional .google.internal.federatedcompute.v1.ResourceCompressionFormat compression_format = 999;
1680 if (_internal_has_compression_format()) {
1681 target = stream->EnsureSpace(target);
1682 target = ::_pbi::WireFormatLite::WriteEnumToArray(
1683 999, this->_internal_compression_format(), target);
1684 }
1685
1686 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1687 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1688 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1689 }
1690 // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.Resource)
1691 return target;
1692 }
1693
ByteSizeLong() const1694 size_t Resource::ByteSizeLong() const {
1695 // @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.Resource)
1696 size_t total_size = 0;
1697
1698 ::uint32_t cached_has_bits = 0;
1699 // Prevent compiler warnings about cached_has_bits being unused
1700 (void) cached_has_bits;
1701
1702 // string client_cache_id = 4;
1703 if (!this->_internal_client_cache_id().empty()) {
1704 total_size += 1 +
1705 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1706 this->_internal_client_cache_id());
1707 }
1708
1709 // .google.protobuf.Duration max_age = 5;
1710 if (this->_internal_has_max_age()) {
1711 total_size += 1 +
1712 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1713 *_impl_.max_age_);
1714 }
1715
1716 // optional .google.internal.federatedcompute.v1.ResourceCompressionFormat compression_format = 999;
1717 cached_has_bits = _impl_._has_bits_[0];
1718 if (cached_has_bits & 0x00000001u) {
1719 total_size += 2 +
1720 ::_pbi::WireFormatLite::EnumSize(this->_internal_compression_format());
1721 }
1722
1723 switch (resource_case()) {
1724 // string uri = 1;
1725 case kUri: {
1726 total_size += 1 +
1727 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1728 this->_internal_uri());
1729 break;
1730 }
1731 // .google.internal.federatedcompute.v1.Resource.InlineResource inline_resource = 3;
1732 case kInlineResource: {
1733 total_size += 1 +
1734 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1735 *_impl_.resource_.inline_resource_);
1736 break;
1737 }
1738 case RESOURCE_NOT_SET: {
1739 break;
1740 }
1741 }
1742 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1743 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1744 }
1745 int cached_size = ::_pbi::ToCachedSize(total_size);
1746 SetCachedSize(cached_size);
1747 return total_size;
1748 }
1749
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1750 void Resource::CheckTypeAndMergeFrom(
1751 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1752 MergeFrom(*::_pbi::DownCast<const Resource*>(
1753 &from));
1754 }
1755
MergeFrom(const Resource & from)1756 void Resource::MergeFrom(const Resource& from) {
1757 Resource* const _this = this;
1758 // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.Resource)
1759 GOOGLE_DCHECK_NE(&from, _this);
1760 ::uint32_t cached_has_bits = 0;
1761 (void) cached_has_bits;
1762
1763 if (!from._internal_client_cache_id().empty()) {
1764 _this->_internal_set_client_cache_id(from._internal_client_cache_id());
1765 }
1766 if (from._internal_has_max_age()) {
1767 _this->_internal_mutable_max_age()->::PROTOBUF_NAMESPACE_ID::Duration::MergeFrom(
1768 from._internal_max_age());
1769 }
1770 if (from._internal_has_compression_format()) {
1771 _this->_internal_set_compression_format(from._internal_compression_format());
1772 }
1773 switch (from.resource_case()) {
1774 case kUri: {
1775 _this->_internal_set_uri(from._internal_uri());
1776 break;
1777 }
1778 case kInlineResource: {
1779 _this->_internal_mutable_inline_resource()->::google::internal::federatedcompute::v1::Resource_InlineResource::MergeFrom(
1780 from._internal_inline_resource());
1781 break;
1782 }
1783 case RESOURCE_NOT_SET: {
1784 break;
1785 }
1786 }
1787 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1788 }
1789
CopyFrom(const Resource & from)1790 void Resource::CopyFrom(const Resource& from) {
1791 // @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.Resource)
1792 if (&from == this) return;
1793 Clear();
1794 MergeFrom(from);
1795 }
1796
IsInitialized() const1797 bool Resource::IsInitialized() const {
1798 return true;
1799 }
1800
InternalSwap(Resource * other)1801 void Resource::InternalSwap(Resource* other) {
1802 using std::swap;
1803 auto* lhs_arena = GetArenaForAllocation();
1804 auto* rhs_arena = other->GetArenaForAllocation();
1805 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1806 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1807 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1808 &_impl_.client_cache_id_, lhs_arena,
1809 &other->_impl_.client_cache_id_, rhs_arena
1810 );
1811 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1812 PROTOBUF_FIELD_OFFSET(Resource, _impl_.compression_format_)
1813 + sizeof(Resource::_impl_.compression_format_) // NOLINT
1814 - PROTOBUF_FIELD_OFFSET(Resource, _impl_.max_age_)>(
1815 reinterpret_cast<char*>(&_impl_.max_age_),
1816 reinterpret_cast<char*>(&other->_impl_.max_age_));
1817 swap(_impl_.resource_, other->_impl_.resource_);
1818 swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
1819 }
1820
GetTypeName() const1821 std::string Resource::GetTypeName() const {
1822 return "google.internal.federatedcompute.v1.Resource";
1823 }
1824
1825
1826 // ===================================================================
1827
1828 class ResourceCapabilities::_Internal {
1829 public:
1830 };
1831
ResourceCapabilities(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1832 ResourceCapabilities::ResourceCapabilities(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1833 bool is_message_owned)
1834 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1835 SharedCtor(arena, is_message_owned);
1836 // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.ResourceCapabilities)
1837 }
ResourceCapabilities(const ResourceCapabilities & from)1838 ResourceCapabilities::ResourceCapabilities(const ResourceCapabilities& from)
1839 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1840 ResourceCapabilities* const _this = this; (void)_this;
1841 new (&_impl_) Impl_{
1842 decltype(_impl_.supported_compression_formats_){from._impl_.supported_compression_formats_}
1843 , /*decltype(_impl_._supported_compression_formats_cached_byte_size_)*/{0}
1844 , /*decltype(_impl_._cached_size_)*/{}};
1845
1846 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1847 // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.ResourceCapabilities)
1848 }
1849
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1850 inline void ResourceCapabilities::SharedCtor(
1851 ::_pb::Arena* arena, bool is_message_owned) {
1852 (void)arena;
1853 (void)is_message_owned;
1854 new (&_impl_) Impl_{
1855 decltype(_impl_.supported_compression_formats_){arena}
1856 , /*decltype(_impl_._supported_compression_formats_cached_byte_size_)*/{0}
1857 , /*decltype(_impl_._cached_size_)*/{}
1858 };
1859 }
1860
~ResourceCapabilities()1861 ResourceCapabilities::~ResourceCapabilities() {
1862 // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.ResourceCapabilities)
1863 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1864 (void)arena;
1865 return;
1866 }
1867 SharedDtor();
1868 }
1869
SharedDtor()1870 inline void ResourceCapabilities::SharedDtor() {
1871 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1872 _impl_.supported_compression_formats_.~RepeatedField();
1873 }
1874
SetCachedSize(int size) const1875 void ResourceCapabilities::SetCachedSize(int size) const {
1876 _impl_._cached_size_.Set(size);
1877 }
1878
Clear()1879 void ResourceCapabilities::Clear() {
1880 // @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.ResourceCapabilities)
1881 ::uint32_t cached_has_bits = 0;
1882 // Prevent compiler warnings about cached_has_bits being unused
1883 (void) cached_has_bits;
1884
1885 _impl_.supported_compression_formats_.Clear();
1886 _internal_metadata_.Clear<std::string>();
1887 }
1888
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1889 const char* ResourceCapabilities::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1890 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1891 while (!ctx->Done(&ptr)) {
1892 ::uint32_t tag;
1893 ptr = ::_pbi::ReadTag(ptr, &tag);
1894 switch (tag >> 3) {
1895 // repeated .google.internal.federatedcompute.v1.ResourceCompressionFormat supported_compression_formats = 1;
1896 case 1:
1897 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1898 ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser(_internal_mutable_supported_compression_formats(), ptr, ctx);
1899 CHK_(ptr);
1900 } else if (static_cast<::uint8_t>(tag) == 8) {
1901 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1902 CHK_(ptr);
1903 _internal_add_supported_compression_formats(static_cast<::google::internal::federatedcompute::v1::ResourceCompressionFormat>(val));
1904 } else {
1905 goto handle_unusual;
1906 }
1907 continue;
1908 default:
1909 goto handle_unusual;
1910 } // switch
1911 handle_unusual:
1912 if ((tag == 0) || ((tag & 7) == 4)) {
1913 CHK_(ptr);
1914 ctx->SetLastTag(tag);
1915 goto message_done;
1916 }
1917 ptr = UnknownFieldParse(
1918 tag,
1919 _internal_metadata_.mutable_unknown_fields<std::string>(),
1920 ptr, ctx);
1921 CHK_(ptr != nullptr);
1922 } // while
1923 message_done:
1924 return ptr;
1925 failure:
1926 ptr = nullptr;
1927 goto message_done;
1928 #undef CHK_
1929 }
1930
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1931 ::uint8_t* ResourceCapabilities::_InternalSerialize(
1932 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1933 // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.ResourceCapabilities)
1934 ::uint32_t cached_has_bits = 0;
1935 (void) cached_has_bits;
1936
1937 // repeated .google.internal.federatedcompute.v1.ResourceCompressionFormat supported_compression_formats = 1;
1938 {
1939 int byte_size = _impl_._supported_compression_formats_cached_byte_size_.load(std::memory_order_relaxed);
1940 if (byte_size > 0) {
1941 target = stream->WriteEnumPacked(
1942 1, _impl_.supported_compression_formats_, byte_size, target);
1943 }
1944 }
1945
1946 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1947 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1948 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1949 }
1950 // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.ResourceCapabilities)
1951 return target;
1952 }
1953
ByteSizeLong() const1954 size_t ResourceCapabilities::ByteSizeLong() const {
1955 // @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.ResourceCapabilities)
1956 size_t total_size = 0;
1957
1958 ::uint32_t cached_has_bits = 0;
1959 // Prevent compiler warnings about cached_has_bits being unused
1960 (void) cached_has_bits;
1961
1962 // repeated .google.internal.federatedcompute.v1.ResourceCompressionFormat supported_compression_formats = 1;
1963 {
1964 size_t data_size = 0;
1965 unsigned int count = static_cast<unsigned int>(this->_internal_supported_compression_formats_size());for (unsigned int i = 0; i < count; i++) {
1966 data_size += ::_pbi::WireFormatLite::EnumSize(
1967 this->_internal_supported_compression_formats(static_cast<int>(i)));
1968 }
1969 if (data_size > 0) {
1970 total_size += 1 +
1971 ::_pbi::WireFormatLite::Int32Size(static_cast<::int32_t>(data_size));
1972 }
1973 int cached_size = ::_pbi::ToCachedSize(data_size);
1974 _impl_._supported_compression_formats_cached_byte_size_.store(cached_size,
1975 std::memory_order_relaxed);
1976 total_size += data_size;
1977 }
1978
1979 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1980 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1981 }
1982 int cached_size = ::_pbi::ToCachedSize(total_size);
1983 SetCachedSize(cached_size);
1984 return total_size;
1985 }
1986
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1987 void ResourceCapabilities::CheckTypeAndMergeFrom(
1988 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1989 MergeFrom(*::_pbi::DownCast<const ResourceCapabilities*>(
1990 &from));
1991 }
1992
MergeFrom(const ResourceCapabilities & from)1993 void ResourceCapabilities::MergeFrom(const ResourceCapabilities& from) {
1994 ResourceCapabilities* const _this = this;
1995 // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.ResourceCapabilities)
1996 GOOGLE_DCHECK_NE(&from, _this);
1997 ::uint32_t cached_has_bits = 0;
1998 (void) cached_has_bits;
1999
2000 _this->_impl_.supported_compression_formats_.MergeFrom(from._impl_.supported_compression_formats_);
2001 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2002 }
2003
CopyFrom(const ResourceCapabilities & from)2004 void ResourceCapabilities::CopyFrom(const ResourceCapabilities& from) {
2005 // @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.ResourceCapabilities)
2006 if (&from == this) return;
2007 Clear();
2008 MergeFrom(from);
2009 }
2010
IsInitialized() const2011 bool ResourceCapabilities::IsInitialized() const {
2012 return true;
2013 }
2014
InternalSwap(ResourceCapabilities * other)2015 void ResourceCapabilities::InternalSwap(ResourceCapabilities* other) {
2016 using std::swap;
2017 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2018 _impl_.supported_compression_formats_.InternalSwap(&other->_impl_.supported_compression_formats_);
2019 }
2020
GetTypeName() const2021 std::string ResourceCapabilities::GetTypeName() const {
2022 return "google.internal.federatedcompute.v1.ResourceCapabilities";
2023 }
2024
2025
2026 // ===================================================================
2027
2028 class RejectionInfo::_Internal {
2029 public:
2030 static const ::google::internal::federatedcompute::v1::RetryWindow& retry_window(const RejectionInfo* msg);
2031 static const ::google::internal::federatedcompute::v1::AuthenticationMetadata& auth_metadata(const RejectionInfo* msg);
2032 };
2033
2034 const ::google::internal::federatedcompute::v1::RetryWindow&
retry_window(const RejectionInfo * msg)2035 RejectionInfo::_Internal::retry_window(const RejectionInfo* msg) {
2036 return *msg->_impl_.metadata_.retry_window_;
2037 }
2038 const ::google::internal::federatedcompute::v1::AuthenticationMetadata&
auth_metadata(const RejectionInfo * msg)2039 RejectionInfo::_Internal::auth_metadata(const RejectionInfo* msg) {
2040 return *msg->_impl_.metadata_.auth_metadata_;
2041 }
set_allocated_retry_window(::google::internal::federatedcompute::v1::RetryWindow * retry_window)2042 void RejectionInfo::set_allocated_retry_window(::google::internal::federatedcompute::v1::RetryWindow* retry_window) {
2043 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
2044 clear_metadata();
2045 if (retry_window) {
2046 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
2047 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(retry_window);
2048 if (message_arena != submessage_arena) {
2049 retry_window = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2050 message_arena, retry_window, submessage_arena);
2051 }
2052 set_has_retry_window();
2053 _impl_.metadata_.retry_window_ = retry_window;
2054 }
2055 // @@protoc_insertion_point(field_set_allocated:google.internal.federatedcompute.v1.RejectionInfo.retry_window)
2056 }
set_allocated_auth_metadata(::google::internal::federatedcompute::v1::AuthenticationMetadata * auth_metadata)2057 void RejectionInfo::set_allocated_auth_metadata(::google::internal::federatedcompute::v1::AuthenticationMetadata* auth_metadata) {
2058 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
2059 clear_metadata();
2060 if (auth_metadata) {
2061 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
2062 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(auth_metadata);
2063 if (message_arena != submessage_arena) {
2064 auth_metadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2065 message_arena, auth_metadata, submessage_arena);
2066 }
2067 set_has_auth_metadata();
2068 _impl_.metadata_.auth_metadata_ = auth_metadata;
2069 }
2070 // @@protoc_insertion_point(field_set_allocated:google.internal.federatedcompute.v1.RejectionInfo.auth_metadata)
2071 }
RejectionInfo(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2072 RejectionInfo::RejectionInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2073 bool is_message_owned)
2074 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2075 SharedCtor(arena, is_message_owned);
2076 // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.RejectionInfo)
2077 }
RejectionInfo(const RejectionInfo & from)2078 RejectionInfo::RejectionInfo(const RejectionInfo& from)
2079 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2080 RejectionInfo* const _this = this; (void)_this;
2081 new (&_impl_) Impl_{
2082 decltype(_impl_.reason_){}
2083 , decltype(_impl_.metadata_){}
2084 , /*decltype(_impl_._cached_size_)*/{}
2085 , /*decltype(_impl_._oneof_case_)*/{}};
2086
2087 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2088 _this->_impl_.reason_ = from._impl_.reason_;
2089 clear_has_metadata();
2090 switch (from.metadata_case()) {
2091 case kRetryWindow: {
2092 _this->_internal_mutable_retry_window()->::google::internal::federatedcompute::v1::RetryWindow::MergeFrom(
2093 from._internal_retry_window());
2094 break;
2095 }
2096 case kAuthMetadata: {
2097 _this->_internal_mutable_auth_metadata()->::google::internal::federatedcompute::v1::AuthenticationMetadata::MergeFrom(
2098 from._internal_auth_metadata());
2099 break;
2100 }
2101 case METADATA_NOT_SET: {
2102 break;
2103 }
2104 }
2105 // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.RejectionInfo)
2106 }
2107
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2108 inline void RejectionInfo::SharedCtor(
2109 ::_pb::Arena* arena, bool is_message_owned) {
2110 (void)arena;
2111 (void)is_message_owned;
2112 new (&_impl_) Impl_{
2113 decltype(_impl_.reason_){0}
2114 , decltype(_impl_.metadata_){}
2115 , /*decltype(_impl_._cached_size_)*/{}
2116 , /*decltype(_impl_._oneof_case_)*/{}
2117 };
2118 clear_has_metadata();
2119 }
2120
~RejectionInfo()2121 RejectionInfo::~RejectionInfo() {
2122 // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.RejectionInfo)
2123 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2124 (void)arena;
2125 return;
2126 }
2127 SharedDtor();
2128 }
2129
SharedDtor()2130 inline void RejectionInfo::SharedDtor() {
2131 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2132 if (has_metadata()) {
2133 clear_metadata();
2134 }
2135 }
2136
SetCachedSize(int size) const2137 void RejectionInfo::SetCachedSize(int size) const {
2138 _impl_._cached_size_.Set(size);
2139 }
2140
clear_metadata()2141 void RejectionInfo::clear_metadata() {
2142 // @@protoc_insertion_point(one_of_clear_start:google.internal.federatedcompute.v1.RejectionInfo)
2143 switch (metadata_case()) {
2144 case kRetryWindow: {
2145 if (GetArenaForAllocation() == nullptr) {
2146 delete _impl_.metadata_.retry_window_;
2147 }
2148 break;
2149 }
2150 case kAuthMetadata: {
2151 if (GetArenaForAllocation() == nullptr) {
2152 delete _impl_.metadata_.auth_metadata_;
2153 }
2154 break;
2155 }
2156 case METADATA_NOT_SET: {
2157 break;
2158 }
2159 }
2160 _impl_._oneof_case_[0] = METADATA_NOT_SET;
2161 }
2162
2163
Clear()2164 void RejectionInfo::Clear() {
2165 // @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.RejectionInfo)
2166 ::uint32_t cached_has_bits = 0;
2167 // Prevent compiler warnings about cached_has_bits being unused
2168 (void) cached_has_bits;
2169
2170 _impl_.reason_ = 0;
2171 clear_metadata();
2172 _internal_metadata_.Clear<std::string>();
2173 }
2174
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2175 const char* RejectionInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2176 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2177 while (!ctx->Done(&ptr)) {
2178 ::uint32_t tag;
2179 ptr = ::_pbi::ReadTag(ptr, &tag);
2180 switch (tag >> 3) {
2181 // .google.internal.federatedcompute.v1.RejectionReason.Enum reason = 1001;
2182 case 1001:
2183 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 72)) {
2184 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2185 CHK_(ptr);
2186 _internal_set_reason(static_cast<::google::internal::federatedcompute::v1::RejectionReason_Enum>(val));
2187 } else {
2188 goto handle_unusual;
2189 }
2190 continue;
2191 // .google.internal.federatedcompute.v1.RetryWindow retry_window = 1002;
2192 case 1002:
2193 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 82)) {
2194 ptr = ctx->ParseMessage(_internal_mutable_retry_window(), ptr);
2195 CHK_(ptr);
2196 } else {
2197 goto handle_unusual;
2198 }
2199 continue;
2200 // .google.internal.federatedcompute.v1.AuthenticationMetadata auth_metadata = 1003;
2201 case 1003:
2202 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 90)) {
2203 ptr = ctx->ParseMessage(_internal_mutable_auth_metadata(), ptr);
2204 CHK_(ptr);
2205 } else {
2206 goto handle_unusual;
2207 }
2208 continue;
2209 default:
2210 goto handle_unusual;
2211 } // switch
2212 handle_unusual:
2213 if ((tag == 0) || ((tag & 7) == 4)) {
2214 CHK_(ptr);
2215 ctx->SetLastTag(tag);
2216 goto message_done;
2217 }
2218 ptr = UnknownFieldParse(
2219 tag,
2220 _internal_metadata_.mutable_unknown_fields<std::string>(),
2221 ptr, ctx);
2222 CHK_(ptr != nullptr);
2223 } // while
2224 message_done:
2225 return ptr;
2226 failure:
2227 ptr = nullptr;
2228 goto message_done;
2229 #undef CHK_
2230 }
2231
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2232 ::uint8_t* RejectionInfo::_InternalSerialize(
2233 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2234 // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.RejectionInfo)
2235 ::uint32_t cached_has_bits = 0;
2236 (void) cached_has_bits;
2237
2238 // .google.internal.federatedcompute.v1.RejectionReason.Enum reason = 1001;
2239 if (this->_internal_reason() != 0) {
2240 target = stream->EnsureSpace(target);
2241 target = ::_pbi::WireFormatLite::WriteEnumToArray(
2242 1001, this->_internal_reason(), target);
2243 }
2244
2245 // .google.internal.federatedcompute.v1.RetryWindow retry_window = 1002;
2246 if (_internal_has_retry_window()) {
2247 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
2248 InternalWriteMessage(1002, _Internal::retry_window(this),
2249 _Internal::retry_window(this).GetCachedSize(), target, stream);
2250 }
2251
2252 // .google.internal.federatedcompute.v1.AuthenticationMetadata auth_metadata = 1003;
2253 if (_internal_has_auth_metadata()) {
2254 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
2255 InternalWriteMessage(1003, _Internal::auth_metadata(this),
2256 _Internal::auth_metadata(this).GetCachedSize(), target, stream);
2257 }
2258
2259 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2260 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2261 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2262 }
2263 // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.RejectionInfo)
2264 return target;
2265 }
2266
ByteSizeLong() const2267 size_t RejectionInfo::ByteSizeLong() const {
2268 // @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.RejectionInfo)
2269 size_t total_size = 0;
2270
2271 ::uint32_t cached_has_bits = 0;
2272 // Prevent compiler warnings about cached_has_bits being unused
2273 (void) cached_has_bits;
2274
2275 // .google.internal.federatedcompute.v1.RejectionReason.Enum reason = 1001;
2276 if (this->_internal_reason() != 0) {
2277 total_size += 2 +
2278 ::_pbi::WireFormatLite::EnumSize(this->_internal_reason());
2279 }
2280
2281 switch (metadata_case()) {
2282 // .google.internal.federatedcompute.v1.RetryWindow retry_window = 1002;
2283 case kRetryWindow: {
2284 total_size += 2 +
2285 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
2286 *_impl_.metadata_.retry_window_);
2287 break;
2288 }
2289 // .google.internal.federatedcompute.v1.AuthenticationMetadata auth_metadata = 1003;
2290 case kAuthMetadata: {
2291 total_size += 2 +
2292 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
2293 *_impl_.metadata_.auth_metadata_);
2294 break;
2295 }
2296 case METADATA_NOT_SET: {
2297 break;
2298 }
2299 }
2300 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2301 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2302 }
2303 int cached_size = ::_pbi::ToCachedSize(total_size);
2304 SetCachedSize(cached_size);
2305 return total_size;
2306 }
2307
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2308 void RejectionInfo::CheckTypeAndMergeFrom(
2309 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2310 MergeFrom(*::_pbi::DownCast<const RejectionInfo*>(
2311 &from));
2312 }
2313
MergeFrom(const RejectionInfo & from)2314 void RejectionInfo::MergeFrom(const RejectionInfo& from) {
2315 RejectionInfo* const _this = this;
2316 // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.RejectionInfo)
2317 GOOGLE_DCHECK_NE(&from, _this);
2318 ::uint32_t cached_has_bits = 0;
2319 (void) cached_has_bits;
2320
2321 if (from._internal_reason() != 0) {
2322 _this->_internal_set_reason(from._internal_reason());
2323 }
2324 switch (from.metadata_case()) {
2325 case kRetryWindow: {
2326 _this->_internal_mutable_retry_window()->::google::internal::federatedcompute::v1::RetryWindow::MergeFrom(
2327 from._internal_retry_window());
2328 break;
2329 }
2330 case kAuthMetadata: {
2331 _this->_internal_mutable_auth_metadata()->::google::internal::federatedcompute::v1::AuthenticationMetadata::MergeFrom(
2332 from._internal_auth_metadata());
2333 break;
2334 }
2335 case METADATA_NOT_SET: {
2336 break;
2337 }
2338 }
2339 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2340 }
2341
CopyFrom(const RejectionInfo & from)2342 void RejectionInfo::CopyFrom(const RejectionInfo& from) {
2343 // @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.RejectionInfo)
2344 if (&from == this) return;
2345 Clear();
2346 MergeFrom(from);
2347 }
2348
IsInitialized() const2349 bool RejectionInfo::IsInitialized() const {
2350 return true;
2351 }
2352
InternalSwap(RejectionInfo * other)2353 void RejectionInfo::InternalSwap(RejectionInfo* other) {
2354 using std::swap;
2355 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2356 swap(_impl_.reason_, other->_impl_.reason_);
2357 swap(_impl_.metadata_, other->_impl_.metadata_);
2358 swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
2359 }
2360
GetTypeName() const2361 std::string RejectionInfo::GetTypeName() const {
2362 return "google.internal.federatedcompute.v1.RejectionInfo";
2363 }
2364
2365
2366 // ===================================================================
2367
2368 class AuthenticationMetadata::_Internal {
2369 public:
2370 static const ::google::internal::federatedcompute::v1::KeyAttestationAuthMetadata& key_attestation_metadata(const AuthenticationMetadata* msg);
2371 };
2372
2373 const ::google::internal::federatedcompute::v1::KeyAttestationAuthMetadata&
key_attestation_metadata(const AuthenticationMetadata * msg)2374 AuthenticationMetadata::_Internal::key_attestation_metadata(const AuthenticationMetadata* msg) {
2375 return *msg->_impl_.key_attestation_metadata_;
2376 }
AuthenticationMetadata(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2377 AuthenticationMetadata::AuthenticationMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2378 bool is_message_owned)
2379 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2380 SharedCtor(arena, is_message_owned);
2381 // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.AuthenticationMetadata)
2382 }
AuthenticationMetadata(const AuthenticationMetadata & from)2383 AuthenticationMetadata::AuthenticationMetadata(const AuthenticationMetadata& from)
2384 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2385 AuthenticationMetadata* const _this = this; (void)_this;
2386 new (&_impl_) Impl_{
2387 decltype(_impl_.key_attestation_metadata_){nullptr}
2388 , /*decltype(_impl_._cached_size_)*/{}};
2389
2390 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2391 if (from._internal_has_key_attestation_metadata()) {
2392 _this->_impl_.key_attestation_metadata_ = new ::google::internal::federatedcompute::v1::KeyAttestationAuthMetadata(*from._impl_.key_attestation_metadata_);
2393 }
2394 // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.AuthenticationMetadata)
2395 }
2396
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2397 inline void AuthenticationMetadata::SharedCtor(
2398 ::_pb::Arena* arena, bool is_message_owned) {
2399 (void)arena;
2400 (void)is_message_owned;
2401 new (&_impl_) Impl_{
2402 decltype(_impl_.key_attestation_metadata_){nullptr}
2403 , /*decltype(_impl_._cached_size_)*/{}
2404 };
2405 }
2406
~AuthenticationMetadata()2407 AuthenticationMetadata::~AuthenticationMetadata() {
2408 // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.AuthenticationMetadata)
2409 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2410 (void)arena;
2411 return;
2412 }
2413 SharedDtor();
2414 }
2415
SharedDtor()2416 inline void AuthenticationMetadata::SharedDtor() {
2417 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2418 if (this != internal_default_instance()) delete _impl_.key_attestation_metadata_;
2419 }
2420
SetCachedSize(int size) const2421 void AuthenticationMetadata::SetCachedSize(int size) const {
2422 _impl_._cached_size_.Set(size);
2423 }
2424
Clear()2425 void AuthenticationMetadata::Clear() {
2426 // @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.AuthenticationMetadata)
2427 ::uint32_t cached_has_bits = 0;
2428 // Prevent compiler warnings about cached_has_bits being unused
2429 (void) cached_has_bits;
2430
2431 if (GetArenaForAllocation() == nullptr && _impl_.key_attestation_metadata_ != nullptr) {
2432 delete _impl_.key_attestation_metadata_;
2433 }
2434 _impl_.key_attestation_metadata_ = nullptr;
2435 _internal_metadata_.Clear<std::string>();
2436 }
2437
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2438 const char* AuthenticationMetadata::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2439 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2440 while (!ctx->Done(&ptr)) {
2441 ::uint32_t tag;
2442 ptr = ::_pbi::ReadTag(ptr, &tag);
2443 switch (tag >> 3) {
2444 // .google.internal.federatedcompute.v1.KeyAttestationAuthMetadata key_attestation_metadata = 1;
2445 case 1:
2446 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
2447 ptr = ctx->ParseMessage(_internal_mutable_key_attestation_metadata(), ptr);
2448 CHK_(ptr);
2449 } else {
2450 goto handle_unusual;
2451 }
2452 continue;
2453 default:
2454 goto handle_unusual;
2455 } // switch
2456 handle_unusual:
2457 if ((tag == 0) || ((tag & 7) == 4)) {
2458 CHK_(ptr);
2459 ctx->SetLastTag(tag);
2460 goto message_done;
2461 }
2462 ptr = UnknownFieldParse(
2463 tag,
2464 _internal_metadata_.mutable_unknown_fields<std::string>(),
2465 ptr, ctx);
2466 CHK_(ptr != nullptr);
2467 } // while
2468 message_done:
2469 return ptr;
2470 failure:
2471 ptr = nullptr;
2472 goto message_done;
2473 #undef CHK_
2474 }
2475
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2476 ::uint8_t* AuthenticationMetadata::_InternalSerialize(
2477 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2478 // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.AuthenticationMetadata)
2479 ::uint32_t cached_has_bits = 0;
2480 (void) cached_has_bits;
2481
2482 // .google.internal.federatedcompute.v1.KeyAttestationAuthMetadata key_attestation_metadata = 1;
2483 if (this->_internal_has_key_attestation_metadata()) {
2484 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
2485 InternalWriteMessage(1, _Internal::key_attestation_metadata(this),
2486 _Internal::key_attestation_metadata(this).GetCachedSize(), target, stream);
2487 }
2488
2489 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2490 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2491 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2492 }
2493 // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.AuthenticationMetadata)
2494 return target;
2495 }
2496
ByteSizeLong() const2497 size_t AuthenticationMetadata::ByteSizeLong() const {
2498 // @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.AuthenticationMetadata)
2499 size_t total_size = 0;
2500
2501 ::uint32_t cached_has_bits = 0;
2502 // Prevent compiler warnings about cached_has_bits being unused
2503 (void) cached_has_bits;
2504
2505 // .google.internal.federatedcompute.v1.KeyAttestationAuthMetadata key_attestation_metadata = 1;
2506 if (this->_internal_has_key_attestation_metadata()) {
2507 total_size += 1 +
2508 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
2509 *_impl_.key_attestation_metadata_);
2510 }
2511
2512 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2513 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2514 }
2515 int cached_size = ::_pbi::ToCachedSize(total_size);
2516 SetCachedSize(cached_size);
2517 return total_size;
2518 }
2519
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2520 void AuthenticationMetadata::CheckTypeAndMergeFrom(
2521 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2522 MergeFrom(*::_pbi::DownCast<const AuthenticationMetadata*>(
2523 &from));
2524 }
2525
MergeFrom(const AuthenticationMetadata & from)2526 void AuthenticationMetadata::MergeFrom(const AuthenticationMetadata& from) {
2527 AuthenticationMetadata* const _this = this;
2528 // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.AuthenticationMetadata)
2529 GOOGLE_DCHECK_NE(&from, _this);
2530 ::uint32_t cached_has_bits = 0;
2531 (void) cached_has_bits;
2532
2533 if (from._internal_has_key_attestation_metadata()) {
2534 _this->_internal_mutable_key_attestation_metadata()->::google::internal::federatedcompute::v1::KeyAttestationAuthMetadata::MergeFrom(
2535 from._internal_key_attestation_metadata());
2536 }
2537 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2538 }
2539
CopyFrom(const AuthenticationMetadata & from)2540 void AuthenticationMetadata::CopyFrom(const AuthenticationMetadata& from) {
2541 // @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.AuthenticationMetadata)
2542 if (&from == this) return;
2543 Clear();
2544 MergeFrom(from);
2545 }
2546
IsInitialized() const2547 bool AuthenticationMetadata::IsInitialized() const {
2548 return true;
2549 }
2550
InternalSwap(AuthenticationMetadata * other)2551 void AuthenticationMetadata::InternalSwap(AuthenticationMetadata* other) {
2552 using std::swap;
2553 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2554 swap(_impl_.key_attestation_metadata_, other->_impl_.key_attestation_metadata_);
2555 }
2556
GetTypeName() const2557 std::string AuthenticationMetadata::GetTypeName() const {
2558 return "google.internal.federatedcompute.v1.AuthenticationMetadata";
2559 }
2560
2561
2562 // ===================================================================
2563
2564 class KeyAttestationAuthMetadata::_Internal {
2565 public:
2566 };
2567
KeyAttestationAuthMetadata(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2568 KeyAttestationAuthMetadata::KeyAttestationAuthMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2569 bool is_message_owned)
2570 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2571 SharedCtor(arena, is_message_owned);
2572 // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.KeyAttestationAuthMetadata)
2573 }
KeyAttestationAuthMetadata(const KeyAttestationAuthMetadata & from)2574 KeyAttestationAuthMetadata::KeyAttestationAuthMetadata(const KeyAttestationAuthMetadata& from)
2575 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2576 KeyAttestationAuthMetadata* const _this = this; (void)_this;
2577 new (&_impl_) Impl_{
2578 decltype(_impl_.challenge_){}
2579 , /*decltype(_impl_._cached_size_)*/{}};
2580
2581 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2582 _impl_.challenge_.InitDefault();
2583 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2584 _impl_.challenge_.Set("", GetArenaForAllocation());
2585 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2586 if (!from._internal_challenge().empty()) {
2587 _this->_impl_.challenge_.Set(from._internal_challenge(),
2588 _this->GetArenaForAllocation());
2589 }
2590 // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.KeyAttestationAuthMetadata)
2591 }
2592
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2593 inline void KeyAttestationAuthMetadata::SharedCtor(
2594 ::_pb::Arena* arena, bool is_message_owned) {
2595 (void)arena;
2596 (void)is_message_owned;
2597 new (&_impl_) Impl_{
2598 decltype(_impl_.challenge_){}
2599 , /*decltype(_impl_._cached_size_)*/{}
2600 };
2601 _impl_.challenge_.InitDefault();
2602 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2603 _impl_.challenge_.Set("", GetArenaForAllocation());
2604 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2605 }
2606
~KeyAttestationAuthMetadata()2607 KeyAttestationAuthMetadata::~KeyAttestationAuthMetadata() {
2608 // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.KeyAttestationAuthMetadata)
2609 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2610 (void)arena;
2611 return;
2612 }
2613 SharedDtor();
2614 }
2615
SharedDtor()2616 inline void KeyAttestationAuthMetadata::SharedDtor() {
2617 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2618 _impl_.challenge_.Destroy();
2619 }
2620
SetCachedSize(int size) const2621 void KeyAttestationAuthMetadata::SetCachedSize(int size) const {
2622 _impl_._cached_size_.Set(size);
2623 }
2624
Clear()2625 void KeyAttestationAuthMetadata::Clear() {
2626 // @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.KeyAttestationAuthMetadata)
2627 ::uint32_t cached_has_bits = 0;
2628 // Prevent compiler warnings about cached_has_bits being unused
2629 (void) cached_has_bits;
2630
2631 _impl_.challenge_.ClearToEmpty();
2632 _internal_metadata_.Clear<std::string>();
2633 }
2634
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2635 const char* KeyAttestationAuthMetadata::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2636 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2637 while (!ctx->Done(&ptr)) {
2638 ::uint32_t tag;
2639 ptr = ::_pbi::ReadTag(ptr, &tag);
2640 switch (tag >> 3) {
2641 // bytes challenge = 1;
2642 case 1:
2643 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
2644 auto str = _internal_mutable_challenge();
2645 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2646 CHK_(ptr);
2647 } else {
2648 goto handle_unusual;
2649 }
2650 continue;
2651 default:
2652 goto handle_unusual;
2653 } // switch
2654 handle_unusual:
2655 if ((tag == 0) || ((tag & 7) == 4)) {
2656 CHK_(ptr);
2657 ctx->SetLastTag(tag);
2658 goto message_done;
2659 }
2660 ptr = UnknownFieldParse(
2661 tag,
2662 _internal_metadata_.mutable_unknown_fields<std::string>(),
2663 ptr, ctx);
2664 CHK_(ptr != nullptr);
2665 } // while
2666 message_done:
2667 return ptr;
2668 failure:
2669 ptr = nullptr;
2670 goto message_done;
2671 #undef CHK_
2672 }
2673
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2674 ::uint8_t* KeyAttestationAuthMetadata::_InternalSerialize(
2675 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2676 // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.KeyAttestationAuthMetadata)
2677 ::uint32_t cached_has_bits = 0;
2678 (void) cached_has_bits;
2679
2680 // bytes challenge = 1;
2681 if (!this->_internal_challenge().empty()) {
2682 target = stream->WriteBytesMaybeAliased(
2683 1, this->_internal_challenge(), target);
2684 }
2685
2686 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2687 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2688 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2689 }
2690 // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.KeyAttestationAuthMetadata)
2691 return target;
2692 }
2693
ByteSizeLong() const2694 size_t KeyAttestationAuthMetadata::ByteSizeLong() const {
2695 // @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.KeyAttestationAuthMetadata)
2696 size_t total_size = 0;
2697
2698 ::uint32_t cached_has_bits = 0;
2699 // Prevent compiler warnings about cached_has_bits being unused
2700 (void) cached_has_bits;
2701
2702 // bytes challenge = 1;
2703 if (!this->_internal_challenge().empty()) {
2704 total_size += 1 +
2705 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
2706 this->_internal_challenge());
2707 }
2708
2709 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2710 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2711 }
2712 int cached_size = ::_pbi::ToCachedSize(total_size);
2713 SetCachedSize(cached_size);
2714 return total_size;
2715 }
2716
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2717 void KeyAttestationAuthMetadata::CheckTypeAndMergeFrom(
2718 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2719 MergeFrom(*::_pbi::DownCast<const KeyAttestationAuthMetadata*>(
2720 &from));
2721 }
2722
MergeFrom(const KeyAttestationAuthMetadata & from)2723 void KeyAttestationAuthMetadata::MergeFrom(const KeyAttestationAuthMetadata& from) {
2724 KeyAttestationAuthMetadata* const _this = this;
2725 // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.KeyAttestationAuthMetadata)
2726 GOOGLE_DCHECK_NE(&from, _this);
2727 ::uint32_t cached_has_bits = 0;
2728 (void) cached_has_bits;
2729
2730 if (!from._internal_challenge().empty()) {
2731 _this->_internal_set_challenge(from._internal_challenge());
2732 }
2733 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2734 }
2735
CopyFrom(const KeyAttestationAuthMetadata & from)2736 void KeyAttestationAuthMetadata::CopyFrom(const KeyAttestationAuthMetadata& from) {
2737 // @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.KeyAttestationAuthMetadata)
2738 if (&from == this) return;
2739 Clear();
2740 MergeFrom(from);
2741 }
2742
IsInitialized() const2743 bool KeyAttestationAuthMetadata::IsInitialized() const {
2744 return true;
2745 }
2746
InternalSwap(KeyAttestationAuthMetadata * other)2747 void KeyAttestationAuthMetadata::InternalSwap(KeyAttestationAuthMetadata* other) {
2748 using std::swap;
2749 auto* lhs_arena = GetArenaForAllocation();
2750 auto* rhs_arena = other->GetArenaForAllocation();
2751 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2752 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2753 &_impl_.challenge_, lhs_arena,
2754 &other->_impl_.challenge_, rhs_arena
2755 );
2756 }
2757
GetTypeName() const2758 std::string KeyAttestationAuthMetadata::GetTypeName() const {
2759 return "google.internal.federatedcompute.v1.KeyAttestationAuthMetadata";
2760 }
2761
2762
2763 // ===================================================================
2764
2765 class RejectionReason::_Internal {
2766 public:
2767 };
2768
RejectionReason(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2769 RejectionReason::RejectionReason(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2770 bool is_message_owned)
2771 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2772 SharedCtor(arena, is_message_owned);
2773 // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.RejectionReason)
2774 }
RejectionReason(const RejectionReason & from)2775 RejectionReason::RejectionReason(const RejectionReason& from)
2776 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2777 RejectionReason* const _this = this; (void)_this;
2778 new (&_impl_) Impl_{
2779 /*decltype(_impl_._cached_size_)*/{}};
2780
2781 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2782 // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.RejectionReason)
2783 }
2784
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2785 inline void RejectionReason::SharedCtor(
2786 ::_pb::Arena* arena, bool is_message_owned) {
2787 (void)arena;
2788 (void)is_message_owned;
2789 new (&_impl_) Impl_{
2790 /*decltype(_impl_._cached_size_)*/{}
2791 };
2792 }
2793
~RejectionReason()2794 RejectionReason::~RejectionReason() {
2795 // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.RejectionReason)
2796 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2797 (void)arena;
2798 return;
2799 }
2800 SharedDtor();
2801 }
2802
SharedDtor()2803 inline void RejectionReason::SharedDtor() {
2804 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2805 }
2806
SetCachedSize(int size) const2807 void RejectionReason::SetCachedSize(int size) const {
2808 _impl_._cached_size_.Set(size);
2809 }
2810
Clear()2811 void RejectionReason::Clear() {
2812 // @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.RejectionReason)
2813 ::uint32_t cached_has_bits = 0;
2814 // Prevent compiler warnings about cached_has_bits being unused
2815 (void) cached_has_bits;
2816
2817 _internal_metadata_.Clear<std::string>();
2818 }
2819
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2820 const char* RejectionReason::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2821 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2822 while (!ctx->Done(&ptr)) {
2823 ::uint32_t tag;
2824 ptr = ::_pbi::ReadTag(ptr, &tag);
2825 if ((tag == 0) || ((tag & 7) == 4)) {
2826 CHK_(ptr);
2827 ctx->SetLastTag(tag);
2828 goto message_done;
2829 }
2830 ptr = UnknownFieldParse(
2831 tag,
2832 _internal_metadata_.mutable_unknown_fields<std::string>(),
2833 ptr, ctx);
2834 CHK_(ptr != nullptr);
2835 } // while
2836 message_done:
2837 return ptr;
2838 failure:
2839 ptr = nullptr;
2840 goto message_done;
2841 #undef CHK_
2842 }
2843
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2844 ::uint8_t* RejectionReason::_InternalSerialize(
2845 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2846 // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.RejectionReason)
2847 ::uint32_t cached_has_bits = 0;
2848 (void) cached_has_bits;
2849
2850 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2851 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2852 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2853 }
2854 // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.RejectionReason)
2855 return target;
2856 }
2857
ByteSizeLong() const2858 size_t RejectionReason::ByteSizeLong() const {
2859 // @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.RejectionReason)
2860 size_t total_size = 0;
2861
2862 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2863 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2864 }
2865 int cached_size = ::_pbi::ToCachedSize(total_size);
2866 SetCachedSize(cached_size);
2867 return total_size;
2868 }
2869
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2870 void RejectionReason::CheckTypeAndMergeFrom(
2871 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2872 MergeFrom(*::_pbi::DownCast<const RejectionReason*>(
2873 &from));
2874 }
2875
MergeFrom(const RejectionReason & from)2876 void RejectionReason::MergeFrom(const RejectionReason& from) {
2877 RejectionReason* const _this = this;
2878 // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.RejectionReason)
2879 GOOGLE_DCHECK_NE(&from, _this);
2880 ::uint32_t cached_has_bits = 0;
2881 (void) cached_has_bits;
2882
2883 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2884 }
2885
CopyFrom(const RejectionReason & from)2886 void RejectionReason::CopyFrom(const RejectionReason& from) {
2887 // @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.RejectionReason)
2888 if (&from == this) return;
2889 Clear();
2890 MergeFrom(from);
2891 }
2892
IsInitialized() const2893 bool RejectionReason::IsInitialized() const {
2894 return true;
2895 }
2896
InternalSwap(RejectionReason * other)2897 void RejectionReason::InternalSwap(RejectionReason* other) {
2898 using std::swap;
2899 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2900 }
2901
GetTypeName() const2902 std::string RejectionReason::GetTypeName() const {
2903 return "google.internal.federatedcompute.v1.RejectionReason";
2904 }
2905
2906
2907 // ===================================================================
2908
2909 class RetryWindow::_Internal {
2910 public:
2911 static const ::PROTOBUF_NAMESPACE_ID::Duration& delay_min(const RetryWindow* msg);
2912 static const ::PROTOBUF_NAMESPACE_ID::Duration& delay_max(const RetryWindow* msg);
2913 };
2914
2915 const ::PROTOBUF_NAMESPACE_ID::Duration&
delay_min(const RetryWindow * msg)2916 RetryWindow::_Internal::delay_min(const RetryWindow* msg) {
2917 return *msg->_impl_.delay_min_;
2918 }
2919 const ::PROTOBUF_NAMESPACE_ID::Duration&
delay_max(const RetryWindow * msg)2920 RetryWindow::_Internal::delay_max(const RetryWindow* msg) {
2921 return *msg->_impl_.delay_max_;
2922 }
clear_delay_min()2923 void RetryWindow::clear_delay_min() {
2924 if (GetArenaForAllocation() == nullptr && _impl_.delay_min_ != nullptr) {
2925 delete _impl_.delay_min_;
2926 }
2927 _impl_.delay_min_ = nullptr;
2928 }
clear_delay_max()2929 void RetryWindow::clear_delay_max() {
2930 if (GetArenaForAllocation() == nullptr && _impl_.delay_max_ != nullptr) {
2931 delete _impl_.delay_max_;
2932 }
2933 _impl_.delay_max_ = nullptr;
2934 }
RetryWindow(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2935 RetryWindow::RetryWindow(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2936 bool is_message_owned)
2937 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2938 SharedCtor(arena, is_message_owned);
2939 // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.RetryWindow)
2940 }
RetryWindow(const RetryWindow & from)2941 RetryWindow::RetryWindow(const RetryWindow& from)
2942 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2943 RetryWindow* const _this = this; (void)_this;
2944 new (&_impl_) Impl_{
2945 decltype(_impl_.delay_min_){nullptr}
2946 , decltype(_impl_.delay_max_){nullptr}
2947 , /*decltype(_impl_._cached_size_)*/{}};
2948
2949 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2950 if (from._internal_has_delay_min()) {
2951 _this->_impl_.delay_min_ = new ::PROTOBUF_NAMESPACE_ID::Duration(*from._impl_.delay_min_);
2952 }
2953 if (from._internal_has_delay_max()) {
2954 _this->_impl_.delay_max_ = new ::PROTOBUF_NAMESPACE_ID::Duration(*from._impl_.delay_max_);
2955 }
2956 // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.RetryWindow)
2957 }
2958
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2959 inline void RetryWindow::SharedCtor(
2960 ::_pb::Arena* arena, bool is_message_owned) {
2961 (void)arena;
2962 (void)is_message_owned;
2963 new (&_impl_) Impl_{
2964 decltype(_impl_.delay_min_){nullptr}
2965 , decltype(_impl_.delay_max_){nullptr}
2966 , /*decltype(_impl_._cached_size_)*/{}
2967 };
2968 }
2969
~RetryWindow()2970 RetryWindow::~RetryWindow() {
2971 // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.RetryWindow)
2972 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2973 (void)arena;
2974 return;
2975 }
2976 SharedDtor();
2977 }
2978
SharedDtor()2979 inline void RetryWindow::SharedDtor() {
2980 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2981 if (this != internal_default_instance()) delete _impl_.delay_min_;
2982 if (this != internal_default_instance()) delete _impl_.delay_max_;
2983 }
2984
SetCachedSize(int size) const2985 void RetryWindow::SetCachedSize(int size) const {
2986 _impl_._cached_size_.Set(size);
2987 }
2988
Clear()2989 void RetryWindow::Clear() {
2990 // @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.RetryWindow)
2991 ::uint32_t cached_has_bits = 0;
2992 // Prevent compiler warnings about cached_has_bits being unused
2993 (void) cached_has_bits;
2994
2995 if (GetArenaForAllocation() == nullptr && _impl_.delay_min_ != nullptr) {
2996 delete _impl_.delay_min_;
2997 }
2998 _impl_.delay_min_ = nullptr;
2999 if (GetArenaForAllocation() == nullptr && _impl_.delay_max_ != nullptr) {
3000 delete _impl_.delay_max_;
3001 }
3002 _impl_.delay_max_ = nullptr;
3003 _internal_metadata_.Clear<std::string>();
3004 }
3005
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3006 const char* RetryWindow::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3007 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3008 while (!ctx->Done(&ptr)) {
3009 ::uint32_t tag;
3010 ptr = ::_pbi::ReadTag(ptr, &tag);
3011 switch (tag >> 3) {
3012 // .google.protobuf.Duration delay_min = 1;
3013 case 1:
3014 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
3015 ptr = ctx->ParseMessage(_internal_mutable_delay_min(), ptr);
3016 CHK_(ptr);
3017 } else {
3018 goto handle_unusual;
3019 }
3020 continue;
3021 // .google.protobuf.Duration delay_max = 2;
3022 case 2:
3023 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
3024 ptr = ctx->ParseMessage(_internal_mutable_delay_max(), ptr);
3025 CHK_(ptr);
3026 } else {
3027 goto handle_unusual;
3028 }
3029 continue;
3030 default:
3031 goto handle_unusual;
3032 } // switch
3033 handle_unusual:
3034 if ((tag == 0) || ((tag & 7) == 4)) {
3035 CHK_(ptr);
3036 ctx->SetLastTag(tag);
3037 goto message_done;
3038 }
3039 ptr = UnknownFieldParse(
3040 tag,
3041 _internal_metadata_.mutable_unknown_fields<std::string>(),
3042 ptr, ctx);
3043 CHK_(ptr != nullptr);
3044 } // while
3045 message_done:
3046 return ptr;
3047 failure:
3048 ptr = nullptr;
3049 goto message_done;
3050 #undef CHK_
3051 }
3052
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3053 ::uint8_t* RetryWindow::_InternalSerialize(
3054 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3055 // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.RetryWindow)
3056 ::uint32_t cached_has_bits = 0;
3057 (void) cached_has_bits;
3058
3059 // .google.protobuf.Duration delay_min = 1;
3060 if (this->_internal_has_delay_min()) {
3061 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
3062 InternalWriteMessage(1, _Internal::delay_min(this),
3063 _Internal::delay_min(this).GetCachedSize(), target, stream);
3064 }
3065
3066 // .google.protobuf.Duration delay_max = 2;
3067 if (this->_internal_has_delay_max()) {
3068 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
3069 InternalWriteMessage(2, _Internal::delay_max(this),
3070 _Internal::delay_max(this).GetCachedSize(), target, stream);
3071 }
3072
3073 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3074 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3075 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3076 }
3077 // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.RetryWindow)
3078 return target;
3079 }
3080
ByteSizeLong() const3081 size_t RetryWindow::ByteSizeLong() const {
3082 // @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.RetryWindow)
3083 size_t total_size = 0;
3084
3085 ::uint32_t cached_has_bits = 0;
3086 // Prevent compiler warnings about cached_has_bits being unused
3087 (void) cached_has_bits;
3088
3089 // .google.protobuf.Duration delay_min = 1;
3090 if (this->_internal_has_delay_min()) {
3091 total_size += 1 +
3092 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
3093 *_impl_.delay_min_);
3094 }
3095
3096 // .google.protobuf.Duration delay_max = 2;
3097 if (this->_internal_has_delay_max()) {
3098 total_size += 1 +
3099 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
3100 *_impl_.delay_max_);
3101 }
3102
3103 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3104 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3105 }
3106 int cached_size = ::_pbi::ToCachedSize(total_size);
3107 SetCachedSize(cached_size);
3108 return total_size;
3109 }
3110
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3111 void RetryWindow::CheckTypeAndMergeFrom(
3112 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3113 MergeFrom(*::_pbi::DownCast<const RetryWindow*>(
3114 &from));
3115 }
3116
MergeFrom(const RetryWindow & from)3117 void RetryWindow::MergeFrom(const RetryWindow& from) {
3118 RetryWindow* const _this = this;
3119 // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.RetryWindow)
3120 GOOGLE_DCHECK_NE(&from, _this);
3121 ::uint32_t cached_has_bits = 0;
3122 (void) cached_has_bits;
3123
3124 if (from._internal_has_delay_min()) {
3125 _this->_internal_mutable_delay_min()->::PROTOBUF_NAMESPACE_ID::Duration::MergeFrom(
3126 from._internal_delay_min());
3127 }
3128 if (from._internal_has_delay_max()) {
3129 _this->_internal_mutable_delay_max()->::PROTOBUF_NAMESPACE_ID::Duration::MergeFrom(
3130 from._internal_delay_max());
3131 }
3132 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3133 }
3134
CopyFrom(const RetryWindow & from)3135 void RetryWindow::CopyFrom(const RetryWindow& from) {
3136 // @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.RetryWindow)
3137 if (&from == this) return;
3138 Clear();
3139 MergeFrom(from);
3140 }
3141
IsInitialized() const3142 bool RetryWindow::IsInitialized() const {
3143 return true;
3144 }
3145
InternalSwap(RetryWindow * other)3146 void RetryWindow::InternalSwap(RetryWindow* other) {
3147 using std::swap;
3148 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3149 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
3150 PROTOBUF_FIELD_OFFSET(RetryWindow, _impl_.delay_max_)
3151 + sizeof(RetryWindow::_impl_.delay_max_) // NOLINT
3152 - PROTOBUF_FIELD_OFFSET(RetryWindow, _impl_.delay_min_)>(
3153 reinterpret_cast<char*>(&_impl_.delay_min_),
3154 reinterpret_cast<char*>(&other->_impl_.delay_min_));
3155 }
3156
GetTypeName() const3157 std::string RetryWindow::GetTypeName() const {
3158 return "google.internal.federatedcompute.v1.RetryWindow";
3159 }
3160
3161
3162 // ===================================================================
3163
3164 class ByteStreamResource::_Internal {
3165 public:
3166 static const ::google::internal::federatedcompute::v1::ForwardingInfo& data_upload_forwarding_info(const ByteStreamResource* msg);
3167 };
3168
3169 const ::google::internal::federatedcompute::v1::ForwardingInfo&
data_upload_forwarding_info(const ByteStreamResource * msg)3170 ByteStreamResource::_Internal::data_upload_forwarding_info(const ByteStreamResource* msg) {
3171 return *msg->_impl_.data_upload_forwarding_info_;
3172 }
ByteStreamResource(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3173 ByteStreamResource::ByteStreamResource(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3174 bool is_message_owned)
3175 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3176 SharedCtor(arena, is_message_owned);
3177 // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.ByteStreamResource)
3178 }
ByteStreamResource(const ByteStreamResource & from)3179 ByteStreamResource::ByteStreamResource(const ByteStreamResource& from)
3180 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3181 ByteStreamResource* const _this = this; (void)_this;
3182 new (&_impl_) Impl_{
3183 decltype(_impl_.resource_name_){}
3184 , decltype(_impl_.data_upload_forwarding_info_){nullptr}
3185 , /*decltype(_impl_._cached_size_)*/{}};
3186
3187 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3188 _impl_.resource_name_.InitDefault();
3189 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3190 _impl_.resource_name_.Set("", GetArenaForAllocation());
3191 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3192 if (!from._internal_resource_name().empty()) {
3193 _this->_impl_.resource_name_.Set(from._internal_resource_name(),
3194 _this->GetArenaForAllocation());
3195 }
3196 if (from._internal_has_data_upload_forwarding_info()) {
3197 _this->_impl_.data_upload_forwarding_info_ = new ::google::internal::federatedcompute::v1::ForwardingInfo(*from._impl_.data_upload_forwarding_info_);
3198 }
3199 // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.ByteStreamResource)
3200 }
3201
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3202 inline void ByteStreamResource::SharedCtor(
3203 ::_pb::Arena* arena, bool is_message_owned) {
3204 (void)arena;
3205 (void)is_message_owned;
3206 new (&_impl_) Impl_{
3207 decltype(_impl_.resource_name_){}
3208 , decltype(_impl_.data_upload_forwarding_info_){nullptr}
3209 , /*decltype(_impl_._cached_size_)*/{}
3210 };
3211 _impl_.resource_name_.InitDefault();
3212 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3213 _impl_.resource_name_.Set("", GetArenaForAllocation());
3214 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3215 }
3216
~ByteStreamResource()3217 ByteStreamResource::~ByteStreamResource() {
3218 // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.ByteStreamResource)
3219 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3220 (void)arena;
3221 return;
3222 }
3223 SharedDtor();
3224 }
3225
SharedDtor()3226 inline void ByteStreamResource::SharedDtor() {
3227 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3228 _impl_.resource_name_.Destroy();
3229 if (this != internal_default_instance()) delete _impl_.data_upload_forwarding_info_;
3230 }
3231
SetCachedSize(int size) const3232 void ByteStreamResource::SetCachedSize(int size) const {
3233 _impl_._cached_size_.Set(size);
3234 }
3235
Clear()3236 void ByteStreamResource::Clear() {
3237 // @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.ByteStreamResource)
3238 ::uint32_t cached_has_bits = 0;
3239 // Prevent compiler warnings about cached_has_bits being unused
3240 (void) cached_has_bits;
3241
3242 _impl_.resource_name_.ClearToEmpty();
3243 if (GetArenaForAllocation() == nullptr && _impl_.data_upload_forwarding_info_ != nullptr) {
3244 delete _impl_.data_upload_forwarding_info_;
3245 }
3246 _impl_.data_upload_forwarding_info_ = nullptr;
3247 _internal_metadata_.Clear<std::string>();
3248 }
3249
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3250 const char* ByteStreamResource::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3251 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3252 while (!ctx->Done(&ptr)) {
3253 ::uint32_t tag;
3254 ptr = ::_pbi::ReadTag(ptr, &tag);
3255 switch (tag >> 3) {
3256 // .google.internal.federatedcompute.v1.ForwardingInfo data_upload_forwarding_info = 1;
3257 case 1:
3258 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
3259 ptr = ctx->ParseMessage(_internal_mutable_data_upload_forwarding_info(), ptr);
3260 CHK_(ptr);
3261 } else {
3262 goto handle_unusual;
3263 }
3264 continue;
3265 // string resource_name = 2;
3266 case 2:
3267 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
3268 auto str = _internal_mutable_resource_name();
3269 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
3270 CHK_(ptr);
3271 CHK_(::_pbi::VerifyUTF8(str, nullptr));
3272 } else {
3273 goto handle_unusual;
3274 }
3275 continue;
3276 default:
3277 goto handle_unusual;
3278 } // switch
3279 handle_unusual:
3280 if ((tag == 0) || ((tag & 7) == 4)) {
3281 CHK_(ptr);
3282 ctx->SetLastTag(tag);
3283 goto message_done;
3284 }
3285 ptr = UnknownFieldParse(
3286 tag,
3287 _internal_metadata_.mutable_unknown_fields<std::string>(),
3288 ptr, ctx);
3289 CHK_(ptr != nullptr);
3290 } // while
3291 message_done:
3292 return ptr;
3293 failure:
3294 ptr = nullptr;
3295 goto message_done;
3296 #undef CHK_
3297 }
3298
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3299 ::uint8_t* ByteStreamResource::_InternalSerialize(
3300 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3301 // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.ByteStreamResource)
3302 ::uint32_t cached_has_bits = 0;
3303 (void) cached_has_bits;
3304
3305 // .google.internal.federatedcompute.v1.ForwardingInfo data_upload_forwarding_info = 1;
3306 if (this->_internal_has_data_upload_forwarding_info()) {
3307 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
3308 InternalWriteMessage(1, _Internal::data_upload_forwarding_info(this),
3309 _Internal::data_upload_forwarding_info(this).GetCachedSize(), target, stream);
3310 }
3311
3312 // string resource_name = 2;
3313 if (!this->_internal_resource_name().empty()) {
3314 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
3315 this->_internal_resource_name().data(), static_cast<int>(this->_internal_resource_name().length()),
3316 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
3317 "google.internal.federatedcompute.v1.ByteStreamResource.resource_name");
3318 target = stream->WriteStringMaybeAliased(
3319 2, this->_internal_resource_name(), target);
3320 }
3321
3322 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3323 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3324 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3325 }
3326 // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.ByteStreamResource)
3327 return target;
3328 }
3329
ByteSizeLong() const3330 size_t ByteStreamResource::ByteSizeLong() const {
3331 // @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.ByteStreamResource)
3332 size_t total_size = 0;
3333
3334 ::uint32_t cached_has_bits = 0;
3335 // Prevent compiler warnings about cached_has_bits being unused
3336 (void) cached_has_bits;
3337
3338 // string resource_name = 2;
3339 if (!this->_internal_resource_name().empty()) {
3340 total_size += 1 +
3341 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
3342 this->_internal_resource_name());
3343 }
3344
3345 // .google.internal.federatedcompute.v1.ForwardingInfo data_upload_forwarding_info = 1;
3346 if (this->_internal_has_data_upload_forwarding_info()) {
3347 total_size += 1 +
3348 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
3349 *_impl_.data_upload_forwarding_info_);
3350 }
3351
3352 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3353 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3354 }
3355 int cached_size = ::_pbi::ToCachedSize(total_size);
3356 SetCachedSize(cached_size);
3357 return total_size;
3358 }
3359
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3360 void ByteStreamResource::CheckTypeAndMergeFrom(
3361 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3362 MergeFrom(*::_pbi::DownCast<const ByteStreamResource*>(
3363 &from));
3364 }
3365
MergeFrom(const ByteStreamResource & from)3366 void ByteStreamResource::MergeFrom(const ByteStreamResource& from) {
3367 ByteStreamResource* const _this = this;
3368 // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.ByteStreamResource)
3369 GOOGLE_DCHECK_NE(&from, _this);
3370 ::uint32_t cached_has_bits = 0;
3371 (void) cached_has_bits;
3372
3373 if (!from._internal_resource_name().empty()) {
3374 _this->_internal_set_resource_name(from._internal_resource_name());
3375 }
3376 if (from._internal_has_data_upload_forwarding_info()) {
3377 _this->_internal_mutable_data_upload_forwarding_info()->::google::internal::federatedcompute::v1::ForwardingInfo::MergeFrom(
3378 from._internal_data_upload_forwarding_info());
3379 }
3380 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3381 }
3382
CopyFrom(const ByteStreamResource & from)3383 void ByteStreamResource::CopyFrom(const ByteStreamResource& from) {
3384 // @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.ByteStreamResource)
3385 if (&from == this) return;
3386 Clear();
3387 MergeFrom(from);
3388 }
3389
IsInitialized() const3390 bool ByteStreamResource::IsInitialized() const {
3391 return true;
3392 }
3393
InternalSwap(ByteStreamResource * other)3394 void ByteStreamResource::InternalSwap(ByteStreamResource* other) {
3395 using std::swap;
3396 auto* lhs_arena = GetArenaForAllocation();
3397 auto* rhs_arena = other->GetArenaForAllocation();
3398 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3399 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
3400 &_impl_.resource_name_, lhs_arena,
3401 &other->_impl_.resource_name_, rhs_arena
3402 );
3403 swap(_impl_.data_upload_forwarding_info_, other->_impl_.data_upload_forwarding_info_);
3404 }
3405
GetTypeName() const3406 std::string ByteStreamResource::GetTypeName() const {
3407 return "google.internal.federatedcompute.v1.ByteStreamResource";
3408 }
3409
3410
3411 // ===================================================================
3412
3413 class Status::_Internal {
3414 public:
3415 };
3416
Status(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3417 Status::Status(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3418 bool is_message_owned)
3419 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3420 SharedCtor(arena, is_message_owned);
3421 // @@protoc_insertion_point(arena_constructor:google.internal.federatedcompute.v1.Status)
3422 }
Status(const Status & from)3423 Status::Status(const Status& from)
3424 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3425 Status* const _this = this; (void)_this;
3426 new (&_impl_) Impl_{
3427 decltype(_impl_.message_){}
3428 , decltype(_impl_.code_){}
3429 , /*decltype(_impl_._cached_size_)*/{}};
3430
3431 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3432 _impl_.message_.InitDefault();
3433 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3434 _impl_.message_.Set("", GetArenaForAllocation());
3435 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3436 if (!from._internal_message().empty()) {
3437 _this->_impl_.message_.Set(from._internal_message(),
3438 _this->GetArenaForAllocation());
3439 }
3440 _this->_impl_.code_ = from._impl_.code_;
3441 // @@protoc_insertion_point(copy_constructor:google.internal.federatedcompute.v1.Status)
3442 }
3443
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3444 inline void Status::SharedCtor(
3445 ::_pb::Arena* arena, bool is_message_owned) {
3446 (void)arena;
3447 (void)is_message_owned;
3448 new (&_impl_) Impl_{
3449 decltype(_impl_.message_){}
3450 , decltype(_impl_.code_){0}
3451 , /*decltype(_impl_._cached_size_)*/{}
3452 };
3453 _impl_.message_.InitDefault();
3454 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3455 _impl_.message_.Set("", GetArenaForAllocation());
3456 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3457 }
3458
~Status()3459 Status::~Status() {
3460 // @@protoc_insertion_point(destructor:google.internal.federatedcompute.v1.Status)
3461 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3462 (void)arena;
3463 return;
3464 }
3465 SharedDtor();
3466 }
3467
SharedDtor()3468 inline void Status::SharedDtor() {
3469 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3470 _impl_.message_.Destroy();
3471 }
3472
SetCachedSize(int size) const3473 void Status::SetCachedSize(int size) const {
3474 _impl_._cached_size_.Set(size);
3475 }
3476
Clear()3477 void Status::Clear() {
3478 // @@protoc_insertion_point(message_clear_start:google.internal.federatedcompute.v1.Status)
3479 ::uint32_t cached_has_bits = 0;
3480 // Prevent compiler warnings about cached_has_bits being unused
3481 (void) cached_has_bits;
3482
3483 _impl_.message_.ClearToEmpty();
3484 _impl_.code_ = 0;
3485 _internal_metadata_.Clear<std::string>();
3486 }
3487
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3488 const char* Status::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3489 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3490 while (!ctx->Done(&ptr)) {
3491 ::uint32_t tag;
3492 ptr = ::_pbi::ReadTag(ptr, &tag);
3493 switch (tag >> 3) {
3494 // int32 code = 1;
3495 case 1:
3496 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
3497 _impl_.code_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3498 CHK_(ptr);
3499 } else {
3500 goto handle_unusual;
3501 }
3502 continue;
3503 // string message = 2;
3504 case 2:
3505 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
3506 auto str = _internal_mutable_message();
3507 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
3508 CHK_(ptr);
3509 CHK_(::_pbi::VerifyUTF8(str, nullptr));
3510 } else {
3511 goto handle_unusual;
3512 }
3513 continue;
3514 default:
3515 goto handle_unusual;
3516 } // switch
3517 handle_unusual:
3518 if ((tag == 0) || ((tag & 7) == 4)) {
3519 CHK_(ptr);
3520 ctx->SetLastTag(tag);
3521 goto message_done;
3522 }
3523 ptr = UnknownFieldParse(
3524 tag,
3525 _internal_metadata_.mutable_unknown_fields<std::string>(),
3526 ptr, ctx);
3527 CHK_(ptr != nullptr);
3528 } // while
3529 message_done:
3530 return ptr;
3531 failure:
3532 ptr = nullptr;
3533 goto message_done;
3534 #undef CHK_
3535 }
3536
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3537 ::uint8_t* Status::_InternalSerialize(
3538 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3539 // @@protoc_insertion_point(serialize_to_array_start:google.internal.federatedcompute.v1.Status)
3540 ::uint32_t cached_has_bits = 0;
3541 (void) cached_has_bits;
3542
3543 // int32 code = 1;
3544 if (this->_internal_code() != 0) {
3545 target = stream->EnsureSpace(target);
3546 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_code(), target);
3547 }
3548
3549 // string message = 2;
3550 if (!this->_internal_message().empty()) {
3551 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
3552 this->_internal_message().data(), static_cast<int>(this->_internal_message().length()),
3553 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
3554 "google.internal.federatedcompute.v1.Status.message");
3555 target = stream->WriteStringMaybeAliased(
3556 2, this->_internal_message(), target);
3557 }
3558
3559 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3560 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3561 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3562 }
3563 // @@protoc_insertion_point(serialize_to_array_end:google.internal.federatedcompute.v1.Status)
3564 return target;
3565 }
3566
ByteSizeLong() const3567 size_t Status::ByteSizeLong() const {
3568 // @@protoc_insertion_point(message_byte_size_start:google.internal.federatedcompute.v1.Status)
3569 size_t total_size = 0;
3570
3571 ::uint32_t cached_has_bits = 0;
3572 // Prevent compiler warnings about cached_has_bits being unused
3573 (void) cached_has_bits;
3574
3575 // string message = 2;
3576 if (!this->_internal_message().empty()) {
3577 total_size += 1 +
3578 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
3579 this->_internal_message());
3580 }
3581
3582 // int32 code = 1;
3583 if (this->_internal_code() != 0) {
3584 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_code());
3585 }
3586
3587 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3588 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3589 }
3590 int cached_size = ::_pbi::ToCachedSize(total_size);
3591 SetCachedSize(cached_size);
3592 return total_size;
3593 }
3594
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3595 void Status::CheckTypeAndMergeFrom(
3596 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3597 MergeFrom(*::_pbi::DownCast<const Status*>(
3598 &from));
3599 }
3600
MergeFrom(const Status & from)3601 void Status::MergeFrom(const Status& from) {
3602 Status* const _this = this;
3603 // @@protoc_insertion_point(class_specific_merge_from_start:google.internal.federatedcompute.v1.Status)
3604 GOOGLE_DCHECK_NE(&from, _this);
3605 ::uint32_t cached_has_bits = 0;
3606 (void) cached_has_bits;
3607
3608 if (!from._internal_message().empty()) {
3609 _this->_internal_set_message(from._internal_message());
3610 }
3611 if (from._internal_code() != 0) {
3612 _this->_internal_set_code(from._internal_code());
3613 }
3614 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3615 }
3616
CopyFrom(const Status & from)3617 void Status::CopyFrom(const Status& from) {
3618 // @@protoc_insertion_point(class_specific_copy_from_start:google.internal.federatedcompute.v1.Status)
3619 if (&from == this) return;
3620 Clear();
3621 MergeFrom(from);
3622 }
3623
IsInitialized() const3624 bool Status::IsInitialized() const {
3625 return true;
3626 }
3627
InternalSwap(Status * other)3628 void Status::InternalSwap(Status* other) {
3629 using std::swap;
3630 auto* lhs_arena = GetArenaForAllocation();
3631 auto* rhs_arena = other->GetArenaForAllocation();
3632 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3633 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
3634 &_impl_.message_, lhs_arena,
3635 &other->_impl_.message_, rhs_arena
3636 );
3637 swap(_impl_.code_, other->_impl_.code_);
3638 }
3639
GetTypeName() const3640 std::string Status::GetTypeName() const {
3641 return "google.internal.federatedcompute.v1.Status";
3642 }
3643
3644
3645 // @@protoc_insertion_point(namespace_scope)
3646 } // namespace v1
3647 } // namespace federatedcompute
3648 } // namespace internal
3649 } // namespace google
3650 PROTOBUF_NAMESPACE_OPEN
3651 template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::ForwardingInfo_ExtraRequestHeadersEntry_DoNotUse*
CreateMaybeMessage(Arena * arena)3652 Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::ForwardingInfo_ExtraRequestHeadersEntry_DoNotUse >(Arena* arena) {
3653 return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::ForwardingInfo_ExtraRequestHeadersEntry_DoNotUse >(arena);
3654 }
3655 template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::ForwardingInfo*
CreateMaybeMessage(Arena * arena)3656 Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::ForwardingInfo >(Arena* arena) {
3657 return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::ForwardingInfo >(arena);
3658 }
3659 template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::AttestationMeasurement*
CreateMaybeMessage(Arena * arena)3660 Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::AttestationMeasurement >(Arena* arena) {
3661 return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::AttestationMeasurement >(arena);
3662 }
3663 template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::ClientVersion*
CreateMaybeMessage(Arena * arena)3664 Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::ClientVersion >(Arena* arena) {
3665 return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::ClientVersion >(arena);
3666 }
3667 template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::Resource_InlineResource*
CreateMaybeMessage(Arena * arena)3668 Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::Resource_InlineResource >(Arena* arena) {
3669 return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::Resource_InlineResource >(arena);
3670 }
3671 template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::Resource*
CreateMaybeMessage(Arena * arena)3672 Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::Resource >(Arena* arena) {
3673 return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::Resource >(arena);
3674 }
3675 template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::ResourceCapabilities*
CreateMaybeMessage(Arena * arena)3676 Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::ResourceCapabilities >(Arena* arena) {
3677 return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::ResourceCapabilities >(arena);
3678 }
3679 template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::RejectionInfo*
CreateMaybeMessage(Arena * arena)3680 Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::RejectionInfo >(Arena* arena) {
3681 return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::RejectionInfo >(arena);
3682 }
3683 template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::AuthenticationMetadata*
CreateMaybeMessage(Arena * arena)3684 Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::AuthenticationMetadata >(Arena* arena) {
3685 return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::AuthenticationMetadata >(arena);
3686 }
3687 template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::KeyAttestationAuthMetadata*
CreateMaybeMessage(Arena * arena)3688 Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::KeyAttestationAuthMetadata >(Arena* arena) {
3689 return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::KeyAttestationAuthMetadata >(arena);
3690 }
3691 template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::RejectionReason*
CreateMaybeMessage(Arena * arena)3692 Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::RejectionReason >(Arena* arena) {
3693 return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::RejectionReason >(arena);
3694 }
3695 template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::RetryWindow*
CreateMaybeMessage(Arena * arena)3696 Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::RetryWindow >(Arena* arena) {
3697 return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::RetryWindow >(arena);
3698 }
3699 template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::ByteStreamResource*
CreateMaybeMessage(Arena * arena)3700 Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::ByteStreamResource >(Arena* arena) {
3701 return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::ByteStreamResource >(arena);
3702 }
3703 template<> PROTOBUF_NOINLINE ::google::internal::federatedcompute::v1::Status*
CreateMaybeMessage(Arena * arena)3704 Arena::CreateMaybeMessage< ::google::internal::federatedcompute::v1::Status >(Arena* arena) {
3705 return Arena::CreateMessageInternal< ::google::internal::federatedcompute::v1::Status >(arena);
3706 }
3707 PROTOBUF_NAMESPACE_CLOSE
3708
3709 // @@protoc_insertion_point(global_scope)
3710 #include <google/protobuf/port_undef.inc>
3711