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