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