1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: fcp/protos/federatedcompute/secure_aggregations.proto
3
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_fcp_2fprotos_2ffederatedcompute_2fsecure_5faggregations_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_fcp_2fprotos_2ffederatedcompute_2fsecure_5faggregations_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 "fcp/protos/federatedcompute/common.pb.h"
36 #include "fcp/secagg/shared/secagg_messages.pb.h"
37 #include <google/protobuf/duration.pb.h>
38 // @@protoc_insertion_point(includes)
39 #include <google/protobuf/port_def.inc>
40 #define PROTOBUF_INTERNAL_EXPORT_fcp_2fprotos_2ffederatedcompute_2fsecure_5faggregations_2eproto
41 PROTOBUF_NAMESPACE_OPEN
42 namespace internal {
43 class AnyMetadata;
44 } // namespace internal
45 PROTOBUF_NAMESPACE_CLOSE
46
47 // Internal implementation detail -- do not use these members.
48 struct TableStruct_fcp_2fprotos_2ffederatedcompute_2fsecure_5faggregations_2eproto {
49 static const ::uint32_t offsets[];
50 };
51 namespace google {
52 namespace internal {
53 namespace federatedcompute {
54 namespace v1 {
55 class AbortSecureAggregationRequest;
56 struct AbortSecureAggregationRequestDefaultTypeInternal;
57 extern AbortSecureAggregationRequestDefaultTypeInternal _AbortSecureAggregationRequest_default_instance_;
58 class AbortSecureAggregationResponse;
59 struct AbortSecureAggregationResponseDefaultTypeInternal;
60 extern AbortSecureAggregationResponseDefaultTypeInternal _AbortSecureAggregationResponse_default_instance_;
61 class AdvertiseKeysMetadata;
62 struct AdvertiseKeysMetadataDefaultTypeInternal;
63 extern AdvertiseKeysMetadataDefaultTypeInternal _AdvertiseKeysMetadata_default_instance_;
64 class AdvertiseKeysRequest;
65 struct AdvertiseKeysRequestDefaultTypeInternal;
66 extern AdvertiseKeysRequestDefaultTypeInternal _AdvertiseKeysRequest_default_instance_;
67 class AdvertiseKeysResponse;
68 struct AdvertiseKeysResponseDefaultTypeInternal;
69 extern AdvertiseKeysResponseDefaultTypeInternal _AdvertiseKeysResponse_default_instance_;
70 class SecureAggregandExecutionInfo;
71 struct SecureAggregandExecutionInfoDefaultTypeInternal;
72 extern SecureAggregandExecutionInfoDefaultTypeInternal _SecureAggregandExecutionInfo_default_instance_;
73 class SecureAggregationProtocolExecutionInfo;
74 struct SecureAggregationProtocolExecutionInfoDefaultTypeInternal;
75 extern SecureAggregationProtocolExecutionInfoDefaultTypeInternal _SecureAggregationProtocolExecutionInfo_default_instance_;
76 class ShareKeysMetadata;
77 struct ShareKeysMetadataDefaultTypeInternal;
78 extern ShareKeysMetadataDefaultTypeInternal _ShareKeysMetadata_default_instance_;
79 class ShareKeysRequest;
80 struct ShareKeysRequestDefaultTypeInternal;
81 extern ShareKeysRequestDefaultTypeInternal _ShareKeysRequest_default_instance_;
82 class ShareKeysResponse;
83 struct ShareKeysResponseDefaultTypeInternal;
84 extern ShareKeysResponseDefaultTypeInternal _ShareKeysResponse_default_instance_;
85 class StartSecureAggregationMetadata;
86 struct StartSecureAggregationMetadataDefaultTypeInternal;
87 extern StartSecureAggregationMetadataDefaultTypeInternal _StartSecureAggregationMetadata_default_instance_;
88 class StartSecureAggregationRequest;
89 struct StartSecureAggregationRequestDefaultTypeInternal;
90 extern StartSecureAggregationRequestDefaultTypeInternal _StartSecureAggregationRequest_default_instance_;
91 class StartSecureAggregationResponse;
92 struct StartSecureAggregationResponseDefaultTypeInternal;
93 extern StartSecureAggregationResponseDefaultTypeInternal _StartSecureAggregationResponse_default_instance_;
94 class StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUse;
95 struct StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUseDefaultTypeInternal;
96 extern StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUseDefaultTypeInternal _StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUse_default_instance_;
97 class SubmitSecureAggregationResultMetadata;
98 struct SubmitSecureAggregationResultMetadataDefaultTypeInternal;
99 extern SubmitSecureAggregationResultMetadataDefaultTypeInternal _SubmitSecureAggregationResultMetadata_default_instance_;
100 class SubmitSecureAggregationResultRequest;
101 struct SubmitSecureAggregationResultRequestDefaultTypeInternal;
102 extern SubmitSecureAggregationResultRequestDefaultTypeInternal _SubmitSecureAggregationResultRequest_default_instance_;
103 class SubmitSecureAggregationResultResponse;
104 struct SubmitSecureAggregationResultResponseDefaultTypeInternal;
105 extern SubmitSecureAggregationResultResponseDefaultTypeInternal _SubmitSecureAggregationResultResponse_default_instance_;
106 class UnmaskRequest;
107 struct UnmaskRequestDefaultTypeInternal;
108 extern UnmaskRequestDefaultTypeInternal _UnmaskRequest_default_instance_;
109 class UnmaskResponse;
110 struct UnmaskResponseDefaultTypeInternal;
111 extern UnmaskResponseDefaultTypeInternal _UnmaskResponse_default_instance_;
112 } // namespace v1
113 } // namespace federatedcompute
114 } // namespace internal
115 } // namespace google
116 PROTOBUF_NAMESPACE_OPEN
117 template<> ::google::internal::federatedcompute::v1::AbortSecureAggregationRequest* Arena::CreateMaybeMessage<::google::internal::federatedcompute::v1::AbortSecureAggregationRequest>(Arena*);
118 template<> ::google::internal::federatedcompute::v1::AbortSecureAggregationResponse* Arena::CreateMaybeMessage<::google::internal::federatedcompute::v1::AbortSecureAggregationResponse>(Arena*);
119 template<> ::google::internal::federatedcompute::v1::AdvertiseKeysMetadata* Arena::CreateMaybeMessage<::google::internal::federatedcompute::v1::AdvertiseKeysMetadata>(Arena*);
120 template<> ::google::internal::federatedcompute::v1::AdvertiseKeysRequest* Arena::CreateMaybeMessage<::google::internal::federatedcompute::v1::AdvertiseKeysRequest>(Arena*);
121 template<> ::google::internal::federatedcompute::v1::AdvertiseKeysResponse* Arena::CreateMaybeMessage<::google::internal::federatedcompute::v1::AdvertiseKeysResponse>(Arena*);
122 template<> ::google::internal::federatedcompute::v1::SecureAggregandExecutionInfo* Arena::CreateMaybeMessage<::google::internal::federatedcompute::v1::SecureAggregandExecutionInfo>(Arena*);
123 template<> ::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo* Arena::CreateMaybeMessage<::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo>(Arena*);
124 template<> ::google::internal::federatedcompute::v1::ShareKeysMetadata* Arena::CreateMaybeMessage<::google::internal::federatedcompute::v1::ShareKeysMetadata>(Arena*);
125 template<> ::google::internal::federatedcompute::v1::ShareKeysRequest* Arena::CreateMaybeMessage<::google::internal::federatedcompute::v1::ShareKeysRequest>(Arena*);
126 template<> ::google::internal::federatedcompute::v1::ShareKeysResponse* Arena::CreateMaybeMessage<::google::internal::federatedcompute::v1::ShareKeysResponse>(Arena*);
127 template<> ::google::internal::federatedcompute::v1::StartSecureAggregationMetadata* Arena::CreateMaybeMessage<::google::internal::federatedcompute::v1::StartSecureAggregationMetadata>(Arena*);
128 template<> ::google::internal::federatedcompute::v1::StartSecureAggregationRequest* Arena::CreateMaybeMessage<::google::internal::federatedcompute::v1::StartSecureAggregationRequest>(Arena*);
129 template<> ::google::internal::federatedcompute::v1::StartSecureAggregationResponse* Arena::CreateMaybeMessage<::google::internal::federatedcompute::v1::StartSecureAggregationResponse>(Arena*);
130 template<> ::google::internal::federatedcompute::v1::StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUse* Arena::CreateMaybeMessage<::google::internal::federatedcompute::v1::StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUse>(Arena*);
131 template<> ::google::internal::federatedcompute::v1::SubmitSecureAggregationResultMetadata* Arena::CreateMaybeMessage<::google::internal::federatedcompute::v1::SubmitSecureAggregationResultMetadata>(Arena*);
132 template<> ::google::internal::federatedcompute::v1::SubmitSecureAggregationResultRequest* Arena::CreateMaybeMessage<::google::internal::federatedcompute::v1::SubmitSecureAggregationResultRequest>(Arena*);
133 template<> ::google::internal::federatedcompute::v1::SubmitSecureAggregationResultResponse* Arena::CreateMaybeMessage<::google::internal::federatedcompute::v1::SubmitSecureAggregationResultResponse>(Arena*);
134 template<> ::google::internal::federatedcompute::v1::UnmaskRequest* Arena::CreateMaybeMessage<::google::internal::federatedcompute::v1::UnmaskRequest>(Arena*);
135 template<> ::google::internal::federatedcompute::v1::UnmaskResponse* Arena::CreateMaybeMessage<::google::internal::federatedcompute::v1::UnmaskResponse>(Arena*);
136 PROTOBUF_NAMESPACE_CLOSE
137 namespace google {
138 namespace internal {
139 namespace federatedcompute {
140 namespace v1 {
141
142 // ===================================================================
143
144 class StartSecureAggregationRequest final :
145 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federatedcompute.v1.StartSecureAggregationRequest) */ {
146 public:
StartSecureAggregationRequest()147 inline StartSecureAggregationRequest() : StartSecureAggregationRequest(nullptr) {}
148 ~StartSecureAggregationRequest() override;
149 explicit PROTOBUF_CONSTEXPR StartSecureAggregationRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
150
151 StartSecureAggregationRequest(const StartSecureAggregationRequest& from);
StartSecureAggregationRequest(StartSecureAggregationRequest && from)152 StartSecureAggregationRequest(StartSecureAggregationRequest&& from) noexcept
153 : StartSecureAggregationRequest() {
154 *this = ::std::move(from);
155 }
156
157 inline StartSecureAggregationRequest& operator=(const StartSecureAggregationRequest& from) {
158 if (this == &from) return *this;
159 CopyFrom(from);
160 return *this;
161 }
162 inline StartSecureAggregationRequest& operator=(StartSecureAggregationRequest&& from) noexcept {
163 if (this == &from) return *this;
164 if (GetOwningArena() == from.GetOwningArena()
165 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
166 && GetOwningArena() != nullptr
167 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
168 ) {
169 InternalSwap(&from);
170 } else {
171 CopyFrom(from);
172 }
173 return *this;
174 }
175
default_instance()176 static const StartSecureAggregationRequest& default_instance() {
177 return *internal_default_instance();
178 }
internal_default_instance()179 static inline const StartSecureAggregationRequest* internal_default_instance() {
180 return reinterpret_cast<const StartSecureAggregationRequest*>(
181 &_StartSecureAggregationRequest_default_instance_);
182 }
183 static constexpr int kIndexInFileMessages =
184 0;
185
swap(StartSecureAggregationRequest & a,StartSecureAggregationRequest & b)186 friend void swap(StartSecureAggregationRequest& a, StartSecureAggregationRequest& b) {
187 a.Swap(&b);
188 }
Swap(StartSecureAggregationRequest * other)189 inline void Swap(StartSecureAggregationRequest* other) {
190 if (other == this) return;
191 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
192 if (GetOwningArena() != nullptr &&
193 GetOwningArena() == other->GetOwningArena()) {
194 #else // PROTOBUF_FORCE_COPY_IN_SWAP
195 if (GetOwningArena() == other->GetOwningArena()) {
196 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
197 InternalSwap(other);
198 } else {
199 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
200 }
201 }
202 void UnsafeArenaSwap(StartSecureAggregationRequest* other) {
203 if (other == this) return;
204 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
205 InternalSwap(other);
206 }
207
208 // implements Message ----------------------------------------------
209
210 StartSecureAggregationRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
211 return CreateMaybeMessage<StartSecureAggregationRequest>(arena);
212 }
213 StartSecureAggregationRequest* New() const {
214 return New(nullptr);
215 }
216 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
217 void CopyFrom(const StartSecureAggregationRequest& from);
218 void MergeFrom(const StartSecureAggregationRequest& from);
219 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
220 bool IsInitialized() const final;
221
222 size_t ByteSizeLong() const final;
223 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
224 ::uint8_t* _InternalSerialize(
225 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
226 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
227
228 private:
229 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
230 void SharedDtor();
231 void SetCachedSize(int size) const;
232 void InternalSwap(StartSecureAggregationRequest* other);
233
234 private:
235 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
236 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
237 return "google.internal.federatedcompute.v1.StartSecureAggregationRequest";
238 }
239 protected:
240 explicit StartSecureAggregationRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
241 bool is_message_owned = false);
242 public:
243
244 std::string GetTypeName() const final;
245
246 // nested types ----------------------------------------------------
247
248 // accessors -------------------------------------------------------
249
250 enum : int {
251 kAggregationIdFieldNumber = 1,
252 kAuthorizationTokenFieldNumber = 2,
253 };
254 // string aggregation_id = 1;
255 void clear_aggregation_id();
256 const std::string& aggregation_id() const;
257 template <typename ArgT0 = const std::string&, typename... ArgT>
258 void set_aggregation_id(ArgT0&& arg0, ArgT... args);
259 std::string* mutable_aggregation_id();
260 PROTOBUF_NODISCARD std::string* release_aggregation_id();
261 void set_allocated_aggregation_id(std::string* aggregation_id);
262 private:
263 const std::string& _internal_aggregation_id() const;
264 inline PROTOBUF_ALWAYS_INLINE void _internal_set_aggregation_id(const std::string& value);
265 std::string* _internal_mutable_aggregation_id();
266 public:
267
268 // string authorization_token = 2;
269 void clear_authorization_token();
270 const std::string& authorization_token() const;
271 template <typename ArgT0 = const std::string&, typename... ArgT>
272 void set_authorization_token(ArgT0&& arg0, ArgT... args);
273 std::string* mutable_authorization_token();
274 PROTOBUF_NODISCARD std::string* release_authorization_token();
275 void set_allocated_authorization_token(std::string* authorization_token);
276 private:
277 const std::string& _internal_authorization_token() const;
278 inline PROTOBUF_ALWAYS_INLINE void _internal_set_authorization_token(const std::string& value);
279 std::string* _internal_mutable_authorization_token();
280 public:
281
282 // @@protoc_insertion_point(class_scope:google.internal.federatedcompute.v1.StartSecureAggregationRequest)
283 private:
284 class _Internal;
285
286 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
287 typedef void InternalArenaConstructable_;
288 typedef void DestructorSkippable_;
289 struct Impl_ {
290 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr aggregation_id_;
291 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr authorization_token_;
292 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
293 };
294 union { Impl_ _impl_; };
295 friend struct ::TableStruct_fcp_2fprotos_2ffederatedcompute_2fsecure_5faggregations_2eproto;
296 };
297 // -------------------------------------------------------------------
298
299 class StartSecureAggregationMetadata final :
300 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federatedcompute.v1.StartSecureAggregationMetadata) */ {
301 public:
StartSecureAggregationMetadata()302 inline StartSecureAggregationMetadata() : StartSecureAggregationMetadata(nullptr) {}
303 ~StartSecureAggregationMetadata() override;
304 explicit PROTOBUF_CONSTEXPR StartSecureAggregationMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
305
306 StartSecureAggregationMetadata(const StartSecureAggregationMetadata& from);
StartSecureAggregationMetadata(StartSecureAggregationMetadata && from)307 StartSecureAggregationMetadata(StartSecureAggregationMetadata&& from) noexcept
308 : StartSecureAggregationMetadata() {
309 *this = ::std::move(from);
310 }
311
312 inline StartSecureAggregationMetadata& operator=(const StartSecureAggregationMetadata& from) {
313 if (this == &from) return *this;
314 CopyFrom(from);
315 return *this;
316 }
317 inline StartSecureAggregationMetadata& operator=(StartSecureAggregationMetadata&& from) noexcept {
318 if (this == &from) return *this;
319 if (GetOwningArena() == from.GetOwningArena()
320 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
321 && GetOwningArena() != nullptr
322 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
323 ) {
324 InternalSwap(&from);
325 } else {
326 CopyFrom(from);
327 }
328 return *this;
329 }
330
default_instance()331 static const StartSecureAggregationMetadata& default_instance() {
332 return *internal_default_instance();
333 }
internal_default_instance()334 static inline const StartSecureAggregationMetadata* internal_default_instance() {
335 return reinterpret_cast<const StartSecureAggregationMetadata*>(
336 &_StartSecureAggregationMetadata_default_instance_);
337 }
338 static constexpr int kIndexInFileMessages =
339 1;
340
swap(StartSecureAggregationMetadata & a,StartSecureAggregationMetadata & b)341 friend void swap(StartSecureAggregationMetadata& a, StartSecureAggregationMetadata& b) {
342 a.Swap(&b);
343 }
Swap(StartSecureAggregationMetadata * other)344 inline void Swap(StartSecureAggregationMetadata* other) {
345 if (other == this) return;
346 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
347 if (GetOwningArena() != nullptr &&
348 GetOwningArena() == other->GetOwningArena()) {
349 #else // PROTOBUF_FORCE_COPY_IN_SWAP
350 if (GetOwningArena() == other->GetOwningArena()) {
351 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
352 InternalSwap(other);
353 } else {
354 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
355 }
356 }
357 void UnsafeArenaSwap(StartSecureAggregationMetadata* other) {
358 if (other == this) return;
359 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
360 InternalSwap(other);
361 }
362
363 // implements Message ----------------------------------------------
364
365 StartSecureAggregationMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
366 return CreateMaybeMessage<StartSecureAggregationMetadata>(arena);
367 }
368 StartSecureAggregationMetadata* New() const {
369 return New(nullptr);
370 }
371 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
372 void CopyFrom(const StartSecureAggregationMetadata& from);
373 void MergeFrom(const StartSecureAggregationMetadata& from);
374 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
375 bool IsInitialized() const final;
376
377 size_t ByteSizeLong() const final;
378 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
379 ::uint8_t* _InternalSerialize(
380 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
381 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
382
383 private:
384 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
385 void SharedDtor();
386 void SetCachedSize(int size) const;
387 void InternalSwap(StartSecureAggregationMetadata* other);
388
389 private:
390 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
391 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
392 return "google.internal.federatedcompute.v1.StartSecureAggregationMetadata";
393 }
394 protected:
395 explicit StartSecureAggregationMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
396 bool is_message_owned = false);
397 public:
398
399 std::string GetTypeName() const final;
400
401 // nested types ----------------------------------------------------
402
403 // accessors -------------------------------------------------------
404
405 // @@protoc_insertion_point(class_scope:google.internal.federatedcompute.v1.StartSecureAggregationMetadata)
406 private:
407 class _Internal;
408
409 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
410 typedef void InternalArenaConstructable_;
411 typedef void DestructorSkippable_;
412 struct Impl_ {
413 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
414 };
415 union { Impl_ _impl_; };
416 friend struct ::TableStruct_fcp_2fprotos_2ffederatedcompute_2fsecure_5faggregations_2eproto;
417 };
418 // -------------------------------------------------------------------
419
420 class StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUse,
421 std::string, ::google::internal::federatedcompute::v1::SecureAggregandExecutionInfo,
422 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
423 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
424 public:
425 typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUse,
426 std::string, ::google::internal::federatedcompute::v1::SecureAggregandExecutionInfo,
427 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
428 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
429 StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUse();
430 explicit PROTOBUF_CONSTEXPR StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUse(
431 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
432 explicit StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
433 void MergeFrom(const StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUse& other);
internal_default_instance()434 static const StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUse*>(&_StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUse_default_instance_); }
ValidateKey(std::string * s)435 static bool ValidateKey(std::string* s) {
436 return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "google.internal.federatedcompute.v1.StartSecureAggregationResponse.SecureAggregandsEntry.key");
437 }
ValidateValue(void *)438 static bool ValidateValue(void*) { return true; }
439 friend struct ::TableStruct_fcp_2fprotos_2ffederatedcompute_2fsecure_5faggregations_2eproto;
440 };
441
442 // -------------------------------------------------------------------
443
444 class StartSecureAggregationResponse final :
445 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federatedcompute.v1.StartSecureAggregationResponse) */ {
446 public:
StartSecureAggregationResponse()447 inline StartSecureAggregationResponse() : StartSecureAggregationResponse(nullptr) {}
448 ~StartSecureAggregationResponse() override;
449 explicit PROTOBUF_CONSTEXPR StartSecureAggregationResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
450
451 StartSecureAggregationResponse(const StartSecureAggregationResponse& from);
StartSecureAggregationResponse(StartSecureAggregationResponse && from)452 StartSecureAggregationResponse(StartSecureAggregationResponse&& from) noexcept
453 : StartSecureAggregationResponse() {
454 *this = ::std::move(from);
455 }
456
457 inline StartSecureAggregationResponse& operator=(const StartSecureAggregationResponse& from) {
458 if (this == &from) return *this;
459 CopyFrom(from);
460 return *this;
461 }
462 inline StartSecureAggregationResponse& operator=(StartSecureAggregationResponse&& from) noexcept {
463 if (this == &from) return *this;
464 if (GetOwningArena() == from.GetOwningArena()
465 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
466 && GetOwningArena() != nullptr
467 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
468 ) {
469 InternalSwap(&from);
470 } else {
471 CopyFrom(from);
472 }
473 return *this;
474 }
475
default_instance()476 static const StartSecureAggregationResponse& default_instance() {
477 return *internal_default_instance();
478 }
internal_default_instance()479 static inline const StartSecureAggregationResponse* internal_default_instance() {
480 return reinterpret_cast<const StartSecureAggregationResponse*>(
481 &_StartSecureAggregationResponse_default_instance_);
482 }
483 static constexpr int kIndexInFileMessages =
484 3;
485
swap(StartSecureAggregationResponse & a,StartSecureAggregationResponse & b)486 friend void swap(StartSecureAggregationResponse& a, StartSecureAggregationResponse& b) {
487 a.Swap(&b);
488 }
Swap(StartSecureAggregationResponse * other)489 inline void Swap(StartSecureAggregationResponse* other) {
490 if (other == this) return;
491 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
492 if (GetOwningArena() != nullptr &&
493 GetOwningArena() == other->GetOwningArena()) {
494 #else // PROTOBUF_FORCE_COPY_IN_SWAP
495 if (GetOwningArena() == other->GetOwningArena()) {
496 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
497 InternalSwap(other);
498 } else {
499 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
500 }
501 }
502 void UnsafeArenaSwap(StartSecureAggregationResponse* other) {
503 if (other == this) return;
504 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
505 InternalSwap(other);
506 }
507
508 // implements Message ----------------------------------------------
509
510 StartSecureAggregationResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
511 return CreateMaybeMessage<StartSecureAggregationResponse>(arena);
512 }
513 StartSecureAggregationResponse* New() const {
514 return New(nullptr);
515 }
516 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
517 void CopyFrom(const StartSecureAggregationResponse& from);
518 void MergeFrom(const StartSecureAggregationResponse& from);
519 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
520 bool IsInitialized() const final;
521
522 size_t ByteSizeLong() const final;
523 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
524 ::uint8_t* _InternalSerialize(
525 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
526 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
527
528 private:
529 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
530 void SharedDtor();
531 void SetCachedSize(int size) const;
532 void InternalSwap(StartSecureAggregationResponse* other);
533
534 private:
535 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
536 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
537 return "google.internal.federatedcompute.v1.StartSecureAggregationResponse";
538 }
539 protected:
540 explicit StartSecureAggregationResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
541 bool is_message_owned = false);
542 public:
543
544 std::string GetTypeName() const final;
545
546 // nested types ----------------------------------------------------
547
548
549 // accessors -------------------------------------------------------
550
551 enum : int {
552 kSecureAggregandsFieldNumber = 2,
553 kClientTokenFieldNumber = 6,
554 kSecaggProtocolForwardingInfoFieldNumber = 1,
555 kProtocolExecutionInfoFieldNumber = 3,
556 kMaskedResultResourceFieldNumber = 4,
557 kNonmaskedResultResourceFieldNumber = 5,
558 };
559 // map<string, .google.internal.federatedcompute.v1.SecureAggregandExecutionInfo> secure_aggregands = 2;
560 int secure_aggregands_size() const;
561 private:
562 int _internal_secure_aggregands_size() const;
563 public:
564 void clear_secure_aggregands();
565 private:
566 const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federatedcompute::v1::SecureAggregandExecutionInfo >&
567 _internal_secure_aggregands() const;
568 ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federatedcompute::v1::SecureAggregandExecutionInfo >*
569 _internal_mutable_secure_aggregands();
570 public:
571 const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federatedcompute::v1::SecureAggregandExecutionInfo >&
572 secure_aggregands() const;
573 ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federatedcompute::v1::SecureAggregandExecutionInfo >*
574 mutable_secure_aggregands();
575
576 // string client_token = 6;
577 void clear_client_token();
578 const std::string& client_token() const;
579 template <typename ArgT0 = const std::string&, typename... ArgT>
580 void set_client_token(ArgT0&& arg0, ArgT... args);
581 std::string* mutable_client_token();
582 PROTOBUF_NODISCARD std::string* release_client_token();
583 void set_allocated_client_token(std::string* client_token);
584 private:
585 const std::string& _internal_client_token() const;
586 inline PROTOBUF_ALWAYS_INLINE void _internal_set_client_token(const std::string& value);
587 std::string* _internal_mutable_client_token();
588 public:
589
590 // .google.internal.federatedcompute.v1.ForwardingInfo secagg_protocol_forwarding_info = 1;
591 bool has_secagg_protocol_forwarding_info() const;
592 private:
593 bool _internal_has_secagg_protocol_forwarding_info() const;
594 public:
595 void clear_secagg_protocol_forwarding_info();
596 const ::google::internal::federatedcompute::v1::ForwardingInfo& secagg_protocol_forwarding_info() const;
597 PROTOBUF_NODISCARD ::google::internal::federatedcompute::v1::ForwardingInfo* release_secagg_protocol_forwarding_info();
598 ::google::internal::federatedcompute::v1::ForwardingInfo* mutable_secagg_protocol_forwarding_info();
599 void set_allocated_secagg_protocol_forwarding_info(::google::internal::federatedcompute::v1::ForwardingInfo* secagg_protocol_forwarding_info);
600 private:
601 const ::google::internal::federatedcompute::v1::ForwardingInfo& _internal_secagg_protocol_forwarding_info() const;
602 ::google::internal::federatedcompute::v1::ForwardingInfo* _internal_mutable_secagg_protocol_forwarding_info();
603 public:
604 void unsafe_arena_set_allocated_secagg_protocol_forwarding_info(
605 ::google::internal::federatedcompute::v1::ForwardingInfo* secagg_protocol_forwarding_info);
606 ::google::internal::federatedcompute::v1::ForwardingInfo* unsafe_arena_release_secagg_protocol_forwarding_info();
607
608 // .google.internal.federatedcompute.v1.SecureAggregationProtocolExecutionInfo protocol_execution_info = 3;
609 bool has_protocol_execution_info() const;
610 private:
611 bool _internal_has_protocol_execution_info() const;
612 public:
613 void clear_protocol_execution_info();
614 const ::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo& protocol_execution_info() const;
615 PROTOBUF_NODISCARD ::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo* release_protocol_execution_info();
616 ::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo* mutable_protocol_execution_info();
617 void set_allocated_protocol_execution_info(::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo* protocol_execution_info);
618 private:
619 const ::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo& _internal_protocol_execution_info() const;
620 ::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo* _internal_mutable_protocol_execution_info();
621 public:
622 void unsafe_arena_set_allocated_protocol_execution_info(
623 ::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo* protocol_execution_info);
624 ::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo* unsafe_arena_release_protocol_execution_info();
625
626 // .google.internal.federatedcompute.v1.ByteStreamResource masked_result_resource = 4;
627 bool has_masked_result_resource() const;
628 private:
629 bool _internal_has_masked_result_resource() const;
630 public:
631 void clear_masked_result_resource();
632 const ::google::internal::federatedcompute::v1::ByteStreamResource& masked_result_resource() const;
633 PROTOBUF_NODISCARD ::google::internal::federatedcompute::v1::ByteStreamResource* release_masked_result_resource();
634 ::google::internal::federatedcompute::v1::ByteStreamResource* mutable_masked_result_resource();
635 void set_allocated_masked_result_resource(::google::internal::federatedcompute::v1::ByteStreamResource* masked_result_resource);
636 private:
637 const ::google::internal::federatedcompute::v1::ByteStreamResource& _internal_masked_result_resource() const;
638 ::google::internal::federatedcompute::v1::ByteStreamResource* _internal_mutable_masked_result_resource();
639 public:
640 void unsafe_arena_set_allocated_masked_result_resource(
641 ::google::internal::federatedcompute::v1::ByteStreamResource* masked_result_resource);
642 ::google::internal::federatedcompute::v1::ByteStreamResource* unsafe_arena_release_masked_result_resource();
643
644 // .google.internal.federatedcompute.v1.ByteStreamResource nonmasked_result_resource = 5;
645 bool has_nonmasked_result_resource() const;
646 private:
647 bool _internal_has_nonmasked_result_resource() const;
648 public:
649 void clear_nonmasked_result_resource();
650 const ::google::internal::federatedcompute::v1::ByteStreamResource& nonmasked_result_resource() const;
651 PROTOBUF_NODISCARD ::google::internal::federatedcompute::v1::ByteStreamResource* release_nonmasked_result_resource();
652 ::google::internal::federatedcompute::v1::ByteStreamResource* mutable_nonmasked_result_resource();
653 void set_allocated_nonmasked_result_resource(::google::internal::federatedcompute::v1::ByteStreamResource* nonmasked_result_resource);
654 private:
655 const ::google::internal::federatedcompute::v1::ByteStreamResource& _internal_nonmasked_result_resource() const;
656 ::google::internal::federatedcompute::v1::ByteStreamResource* _internal_mutable_nonmasked_result_resource();
657 public:
658 void unsafe_arena_set_allocated_nonmasked_result_resource(
659 ::google::internal::federatedcompute::v1::ByteStreamResource* nonmasked_result_resource);
660 ::google::internal::federatedcompute::v1::ByteStreamResource* unsafe_arena_release_nonmasked_result_resource();
661
662 // @@protoc_insertion_point(class_scope:google.internal.federatedcompute.v1.StartSecureAggregationResponse)
663 private:
664 class _Internal;
665
666 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
667 typedef void InternalArenaConstructable_;
668 typedef void DestructorSkippable_;
669 struct Impl_ {
670 ::PROTOBUF_NAMESPACE_ID::internal::MapFieldLite<
671 StartSecureAggregationResponse_SecureAggregandsEntry_DoNotUse,
672 std::string, ::google::internal::federatedcompute::v1::SecureAggregandExecutionInfo,
673 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
674 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> secure_aggregands_;
675 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr client_token_;
676 ::google::internal::federatedcompute::v1::ForwardingInfo* secagg_protocol_forwarding_info_;
677 ::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo* protocol_execution_info_;
678 ::google::internal::federatedcompute::v1::ByteStreamResource* masked_result_resource_;
679 ::google::internal::federatedcompute::v1::ByteStreamResource* nonmasked_result_resource_;
680 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
681 };
682 union { Impl_ _impl_; };
683 friend struct ::TableStruct_fcp_2fprotos_2ffederatedcompute_2fsecure_5faggregations_2eproto;
684 };
685 // -------------------------------------------------------------------
686
687 class SecureAggregandExecutionInfo final :
688 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federatedcompute.v1.SecureAggregandExecutionInfo) */ {
689 public:
SecureAggregandExecutionInfo()690 inline SecureAggregandExecutionInfo() : SecureAggregandExecutionInfo(nullptr) {}
691 ~SecureAggregandExecutionInfo() override;
692 explicit PROTOBUF_CONSTEXPR SecureAggregandExecutionInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
693
694 SecureAggregandExecutionInfo(const SecureAggregandExecutionInfo& from);
SecureAggregandExecutionInfo(SecureAggregandExecutionInfo && from)695 SecureAggregandExecutionInfo(SecureAggregandExecutionInfo&& from) noexcept
696 : SecureAggregandExecutionInfo() {
697 *this = ::std::move(from);
698 }
699
700 inline SecureAggregandExecutionInfo& operator=(const SecureAggregandExecutionInfo& from) {
701 if (this == &from) return *this;
702 CopyFrom(from);
703 return *this;
704 }
705 inline SecureAggregandExecutionInfo& operator=(SecureAggregandExecutionInfo&& from) noexcept {
706 if (this == &from) return *this;
707 if (GetOwningArena() == from.GetOwningArena()
708 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
709 && GetOwningArena() != nullptr
710 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
711 ) {
712 InternalSwap(&from);
713 } else {
714 CopyFrom(from);
715 }
716 return *this;
717 }
718
default_instance()719 static const SecureAggregandExecutionInfo& default_instance() {
720 return *internal_default_instance();
721 }
internal_default_instance()722 static inline const SecureAggregandExecutionInfo* internal_default_instance() {
723 return reinterpret_cast<const SecureAggregandExecutionInfo*>(
724 &_SecureAggregandExecutionInfo_default_instance_);
725 }
726 static constexpr int kIndexInFileMessages =
727 4;
728
swap(SecureAggregandExecutionInfo & a,SecureAggregandExecutionInfo & b)729 friend void swap(SecureAggregandExecutionInfo& a, SecureAggregandExecutionInfo& b) {
730 a.Swap(&b);
731 }
Swap(SecureAggregandExecutionInfo * other)732 inline void Swap(SecureAggregandExecutionInfo* other) {
733 if (other == this) return;
734 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
735 if (GetOwningArena() != nullptr &&
736 GetOwningArena() == other->GetOwningArena()) {
737 #else // PROTOBUF_FORCE_COPY_IN_SWAP
738 if (GetOwningArena() == other->GetOwningArena()) {
739 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
740 InternalSwap(other);
741 } else {
742 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
743 }
744 }
745 void UnsafeArenaSwap(SecureAggregandExecutionInfo* other) {
746 if (other == this) return;
747 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
748 InternalSwap(other);
749 }
750
751 // implements Message ----------------------------------------------
752
753 SecureAggregandExecutionInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
754 return CreateMaybeMessage<SecureAggregandExecutionInfo>(arena);
755 }
756 SecureAggregandExecutionInfo* New() const {
757 return New(nullptr);
758 }
759 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
760 void CopyFrom(const SecureAggregandExecutionInfo& from);
761 void MergeFrom(const SecureAggregandExecutionInfo& from);
762 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
763 bool IsInitialized() const final;
764
765 size_t ByteSizeLong() const final;
766 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
767 ::uint8_t* _InternalSerialize(
768 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
769 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
770
771 private:
772 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
773 void SharedDtor();
774 void SetCachedSize(int size) const;
775 void InternalSwap(SecureAggregandExecutionInfo* other);
776
777 private:
778 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
779 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
780 return "google.internal.federatedcompute.v1.SecureAggregandExecutionInfo";
781 }
782 protected:
783 explicit SecureAggregandExecutionInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
784 bool is_message_owned = false);
785 public:
786
787 std::string GetTypeName() const final;
788
789 // nested types ----------------------------------------------------
790
791 // accessors -------------------------------------------------------
792
793 enum : int {
794 kModulusFieldNumber = 1,
795 };
796 // uint64 modulus = 1;
797 void clear_modulus();
798 ::uint64_t modulus() const;
799 void set_modulus(::uint64_t value);
800 private:
801 ::uint64_t _internal_modulus() const;
802 void _internal_set_modulus(::uint64_t value);
803 public:
804
805 // @@protoc_insertion_point(class_scope:google.internal.federatedcompute.v1.SecureAggregandExecutionInfo)
806 private:
807 class _Internal;
808
809 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
810 typedef void InternalArenaConstructable_;
811 typedef void DestructorSkippable_;
812 struct Impl_ {
813 ::uint64_t modulus_;
814 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
815 };
816 union { Impl_ _impl_; };
817 friend struct ::TableStruct_fcp_2fprotos_2ffederatedcompute_2fsecure_5faggregations_2eproto;
818 };
819 // -------------------------------------------------------------------
820
821 class SecureAggregationProtocolExecutionInfo final :
822 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federatedcompute.v1.SecureAggregationProtocolExecutionInfo) */ {
823 public:
SecureAggregationProtocolExecutionInfo()824 inline SecureAggregationProtocolExecutionInfo() : SecureAggregationProtocolExecutionInfo(nullptr) {}
825 ~SecureAggregationProtocolExecutionInfo() override;
826 explicit PROTOBUF_CONSTEXPR SecureAggregationProtocolExecutionInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
827
828 SecureAggregationProtocolExecutionInfo(const SecureAggregationProtocolExecutionInfo& from);
SecureAggregationProtocolExecutionInfo(SecureAggregationProtocolExecutionInfo && from)829 SecureAggregationProtocolExecutionInfo(SecureAggregationProtocolExecutionInfo&& from) noexcept
830 : SecureAggregationProtocolExecutionInfo() {
831 *this = ::std::move(from);
832 }
833
834 inline SecureAggregationProtocolExecutionInfo& operator=(const SecureAggregationProtocolExecutionInfo& from) {
835 if (this == &from) return *this;
836 CopyFrom(from);
837 return *this;
838 }
839 inline SecureAggregationProtocolExecutionInfo& operator=(SecureAggregationProtocolExecutionInfo&& from) noexcept {
840 if (this == &from) return *this;
841 if (GetOwningArena() == from.GetOwningArena()
842 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
843 && GetOwningArena() != nullptr
844 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
845 ) {
846 InternalSwap(&from);
847 } else {
848 CopyFrom(from);
849 }
850 return *this;
851 }
852
default_instance()853 static const SecureAggregationProtocolExecutionInfo& default_instance() {
854 return *internal_default_instance();
855 }
internal_default_instance()856 static inline const SecureAggregationProtocolExecutionInfo* internal_default_instance() {
857 return reinterpret_cast<const SecureAggregationProtocolExecutionInfo*>(
858 &_SecureAggregationProtocolExecutionInfo_default_instance_);
859 }
860 static constexpr int kIndexInFileMessages =
861 5;
862
swap(SecureAggregationProtocolExecutionInfo & a,SecureAggregationProtocolExecutionInfo & b)863 friend void swap(SecureAggregationProtocolExecutionInfo& a, SecureAggregationProtocolExecutionInfo& b) {
864 a.Swap(&b);
865 }
Swap(SecureAggregationProtocolExecutionInfo * other)866 inline void Swap(SecureAggregationProtocolExecutionInfo* other) {
867 if (other == this) return;
868 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
869 if (GetOwningArena() != nullptr &&
870 GetOwningArena() == other->GetOwningArena()) {
871 #else // PROTOBUF_FORCE_COPY_IN_SWAP
872 if (GetOwningArena() == other->GetOwningArena()) {
873 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
874 InternalSwap(other);
875 } else {
876 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
877 }
878 }
879 void UnsafeArenaSwap(SecureAggregationProtocolExecutionInfo* other) {
880 if (other == this) return;
881 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
882 InternalSwap(other);
883 }
884
885 // implements Message ----------------------------------------------
886
887 SecureAggregationProtocolExecutionInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
888 return CreateMaybeMessage<SecureAggregationProtocolExecutionInfo>(arena);
889 }
890 SecureAggregationProtocolExecutionInfo* New() const {
891 return New(nullptr);
892 }
893 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
894 void CopyFrom(const SecureAggregationProtocolExecutionInfo& from);
895 void MergeFrom(const SecureAggregationProtocolExecutionInfo& from);
896 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
897 bool IsInitialized() const final;
898
899 size_t ByteSizeLong() const final;
900 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
901 ::uint8_t* _InternalSerialize(
902 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
903 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
904
905 private:
906 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
907 void SharedDtor();
908 void SetCachedSize(int size) const;
909 void InternalSwap(SecureAggregationProtocolExecutionInfo* other);
910
911 private:
912 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
913 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
914 return "google.internal.federatedcompute.v1.SecureAggregationProtocolExecutionInfo";
915 }
916 protected:
917 explicit SecureAggregationProtocolExecutionInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
918 bool is_message_owned = false);
919 public:
920
921 std::string GetTypeName() const final;
922
923 // nested types ----------------------------------------------------
924
925 // accessors -------------------------------------------------------
926
927 enum : int {
928 kExpectedNumberOfClientsFieldNumber = 1,
929 kMinimumSurvivingClientsForReconstructionFieldNumber = 2,
930 };
931 // int32 expected_number_of_clients = 1;
932 void clear_expected_number_of_clients();
933 ::int32_t expected_number_of_clients() const;
934 void set_expected_number_of_clients(::int32_t value);
935 private:
936 ::int32_t _internal_expected_number_of_clients() const;
937 void _internal_set_expected_number_of_clients(::int32_t value);
938 public:
939
940 // int32 minimum_surviving_clients_for_reconstruction = 2;
941 void clear_minimum_surviving_clients_for_reconstruction();
942 ::int32_t minimum_surviving_clients_for_reconstruction() const;
943 void set_minimum_surviving_clients_for_reconstruction(::int32_t value);
944 private:
945 ::int32_t _internal_minimum_surviving_clients_for_reconstruction() const;
946 void _internal_set_minimum_surviving_clients_for_reconstruction(::int32_t value);
947 public:
948
949 // @@protoc_insertion_point(class_scope:google.internal.federatedcompute.v1.SecureAggregationProtocolExecutionInfo)
950 private:
951 class _Internal;
952
953 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
954 typedef void InternalArenaConstructable_;
955 typedef void DestructorSkippable_;
956 struct Impl_ {
957 ::int32_t expected_number_of_clients_;
958 ::int32_t minimum_surviving_clients_for_reconstruction_;
959 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
960 };
961 union { Impl_ _impl_; };
962 friend struct ::TableStruct_fcp_2fprotos_2ffederatedcompute_2fsecure_5faggregations_2eproto;
963 };
964 // -------------------------------------------------------------------
965
966 class AbortSecureAggregationRequest final :
967 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federatedcompute.v1.AbortSecureAggregationRequest) */ {
968 public:
AbortSecureAggregationRequest()969 inline AbortSecureAggregationRequest() : AbortSecureAggregationRequest(nullptr) {}
970 ~AbortSecureAggregationRequest() override;
971 explicit PROTOBUF_CONSTEXPR AbortSecureAggregationRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
972
973 AbortSecureAggregationRequest(const AbortSecureAggregationRequest& from);
AbortSecureAggregationRequest(AbortSecureAggregationRequest && from)974 AbortSecureAggregationRequest(AbortSecureAggregationRequest&& from) noexcept
975 : AbortSecureAggregationRequest() {
976 *this = ::std::move(from);
977 }
978
979 inline AbortSecureAggregationRequest& operator=(const AbortSecureAggregationRequest& from) {
980 if (this == &from) return *this;
981 CopyFrom(from);
982 return *this;
983 }
984 inline AbortSecureAggregationRequest& operator=(AbortSecureAggregationRequest&& from) noexcept {
985 if (this == &from) return *this;
986 if (GetOwningArena() == from.GetOwningArena()
987 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
988 && GetOwningArena() != nullptr
989 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
990 ) {
991 InternalSwap(&from);
992 } else {
993 CopyFrom(from);
994 }
995 return *this;
996 }
997
default_instance()998 static const AbortSecureAggregationRequest& default_instance() {
999 return *internal_default_instance();
1000 }
internal_default_instance()1001 static inline const AbortSecureAggregationRequest* internal_default_instance() {
1002 return reinterpret_cast<const AbortSecureAggregationRequest*>(
1003 &_AbortSecureAggregationRequest_default_instance_);
1004 }
1005 static constexpr int kIndexInFileMessages =
1006 6;
1007
swap(AbortSecureAggregationRequest & a,AbortSecureAggregationRequest & b)1008 friend void swap(AbortSecureAggregationRequest& a, AbortSecureAggregationRequest& b) {
1009 a.Swap(&b);
1010 }
Swap(AbortSecureAggregationRequest * other)1011 inline void Swap(AbortSecureAggregationRequest* other) {
1012 if (other == this) return;
1013 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1014 if (GetOwningArena() != nullptr &&
1015 GetOwningArena() == other->GetOwningArena()) {
1016 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1017 if (GetOwningArena() == other->GetOwningArena()) {
1018 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1019 InternalSwap(other);
1020 } else {
1021 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1022 }
1023 }
1024 void UnsafeArenaSwap(AbortSecureAggregationRequest* other) {
1025 if (other == this) return;
1026 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1027 InternalSwap(other);
1028 }
1029
1030 // implements Message ----------------------------------------------
1031
1032 AbortSecureAggregationRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1033 return CreateMaybeMessage<AbortSecureAggregationRequest>(arena);
1034 }
1035 AbortSecureAggregationRequest* New() const {
1036 return New(nullptr);
1037 }
1038 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1039 void CopyFrom(const AbortSecureAggregationRequest& from);
1040 void MergeFrom(const AbortSecureAggregationRequest& from);
1041 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1042 bool IsInitialized() const final;
1043
1044 size_t ByteSizeLong() const final;
1045 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1046 ::uint8_t* _InternalSerialize(
1047 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1048 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1049
1050 private:
1051 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1052 void SharedDtor();
1053 void SetCachedSize(int size) const;
1054 void InternalSwap(AbortSecureAggregationRequest* other);
1055
1056 private:
1057 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1058 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1059 return "google.internal.federatedcompute.v1.AbortSecureAggregationRequest";
1060 }
1061 protected:
1062 explicit AbortSecureAggregationRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1063 bool is_message_owned = false);
1064 public:
1065
1066 std::string GetTypeName() const final;
1067
1068 // nested types ----------------------------------------------------
1069
1070 // accessors -------------------------------------------------------
1071
1072 enum : int {
1073 kAggregationIdFieldNumber = 1,
1074 kClientTokenFieldNumber = 2,
1075 kStatusFieldNumber = 3,
1076 };
1077 // string aggregation_id = 1;
1078 void clear_aggregation_id();
1079 const std::string& aggregation_id() const;
1080 template <typename ArgT0 = const std::string&, typename... ArgT>
1081 void set_aggregation_id(ArgT0&& arg0, ArgT... args);
1082 std::string* mutable_aggregation_id();
1083 PROTOBUF_NODISCARD std::string* release_aggregation_id();
1084 void set_allocated_aggregation_id(std::string* aggregation_id);
1085 private:
1086 const std::string& _internal_aggregation_id() const;
1087 inline PROTOBUF_ALWAYS_INLINE void _internal_set_aggregation_id(const std::string& value);
1088 std::string* _internal_mutable_aggregation_id();
1089 public:
1090
1091 // string client_token = 2;
1092 void clear_client_token();
1093 const std::string& client_token() const;
1094 template <typename ArgT0 = const std::string&, typename... ArgT>
1095 void set_client_token(ArgT0&& arg0, ArgT... args);
1096 std::string* mutable_client_token();
1097 PROTOBUF_NODISCARD std::string* release_client_token();
1098 void set_allocated_client_token(std::string* client_token);
1099 private:
1100 const std::string& _internal_client_token() const;
1101 inline PROTOBUF_ALWAYS_INLINE void _internal_set_client_token(const std::string& value);
1102 std::string* _internal_mutable_client_token();
1103 public:
1104
1105 // .google.internal.federatedcompute.v1.Status status = 3;
1106 bool has_status() const;
1107 private:
1108 bool _internal_has_status() const;
1109 public:
1110 void clear_status();
1111 const ::google::internal::federatedcompute::v1::Status& status() const;
1112 PROTOBUF_NODISCARD ::google::internal::federatedcompute::v1::Status* release_status();
1113 ::google::internal::federatedcompute::v1::Status* mutable_status();
1114 void set_allocated_status(::google::internal::federatedcompute::v1::Status* status);
1115 private:
1116 const ::google::internal::federatedcompute::v1::Status& _internal_status() const;
1117 ::google::internal::federatedcompute::v1::Status* _internal_mutable_status();
1118 public:
1119 void unsafe_arena_set_allocated_status(
1120 ::google::internal::federatedcompute::v1::Status* status);
1121 ::google::internal::federatedcompute::v1::Status* unsafe_arena_release_status();
1122
1123 // @@protoc_insertion_point(class_scope:google.internal.federatedcompute.v1.AbortSecureAggregationRequest)
1124 private:
1125 class _Internal;
1126
1127 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1128 typedef void InternalArenaConstructable_;
1129 typedef void DestructorSkippable_;
1130 struct Impl_ {
1131 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr aggregation_id_;
1132 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr client_token_;
1133 ::google::internal::federatedcompute::v1::Status* status_;
1134 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1135 };
1136 union { Impl_ _impl_; };
1137 friend struct ::TableStruct_fcp_2fprotos_2ffederatedcompute_2fsecure_5faggregations_2eproto;
1138 };
1139 // -------------------------------------------------------------------
1140
1141 class AbortSecureAggregationResponse final :
1142 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federatedcompute.v1.AbortSecureAggregationResponse) */ {
1143 public:
AbortSecureAggregationResponse()1144 inline AbortSecureAggregationResponse() : AbortSecureAggregationResponse(nullptr) {}
1145 ~AbortSecureAggregationResponse() override;
1146 explicit PROTOBUF_CONSTEXPR AbortSecureAggregationResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1147
1148 AbortSecureAggregationResponse(const AbortSecureAggregationResponse& from);
AbortSecureAggregationResponse(AbortSecureAggregationResponse && from)1149 AbortSecureAggregationResponse(AbortSecureAggregationResponse&& from) noexcept
1150 : AbortSecureAggregationResponse() {
1151 *this = ::std::move(from);
1152 }
1153
1154 inline AbortSecureAggregationResponse& operator=(const AbortSecureAggregationResponse& from) {
1155 if (this == &from) return *this;
1156 CopyFrom(from);
1157 return *this;
1158 }
1159 inline AbortSecureAggregationResponse& operator=(AbortSecureAggregationResponse&& from) noexcept {
1160 if (this == &from) return *this;
1161 if (GetOwningArena() == from.GetOwningArena()
1162 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1163 && GetOwningArena() != nullptr
1164 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1165 ) {
1166 InternalSwap(&from);
1167 } else {
1168 CopyFrom(from);
1169 }
1170 return *this;
1171 }
1172
default_instance()1173 static const AbortSecureAggregationResponse& default_instance() {
1174 return *internal_default_instance();
1175 }
internal_default_instance()1176 static inline const AbortSecureAggregationResponse* internal_default_instance() {
1177 return reinterpret_cast<const AbortSecureAggregationResponse*>(
1178 &_AbortSecureAggregationResponse_default_instance_);
1179 }
1180 static constexpr int kIndexInFileMessages =
1181 7;
1182
swap(AbortSecureAggregationResponse & a,AbortSecureAggregationResponse & b)1183 friend void swap(AbortSecureAggregationResponse& a, AbortSecureAggregationResponse& b) {
1184 a.Swap(&b);
1185 }
Swap(AbortSecureAggregationResponse * other)1186 inline void Swap(AbortSecureAggregationResponse* other) {
1187 if (other == this) return;
1188 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1189 if (GetOwningArena() != nullptr &&
1190 GetOwningArena() == other->GetOwningArena()) {
1191 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1192 if (GetOwningArena() == other->GetOwningArena()) {
1193 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1194 InternalSwap(other);
1195 } else {
1196 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1197 }
1198 }
1199 void UnsafeArenaSwap(AbortSecureAggregationResponse* other) {
1200 if (other == this) return;
1201 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1202 InternalSwap(other);
1203 }
1204
1205 // implements Message ----------------------------------------------
1206
1207 AbortSecureAggregationResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1208 return CreateMaybeMessage<AbortSecureAggregationResponse>(arena);
1209 }
1210 AbortSecureAggregationResponse* New() const {
1211 return New(nullptr);
1212 }
1213 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1214 void CopyFrom(const AbortSecureAggregationResponse& from);
1215 void MergeFrom(const AbortSecureAggregationResponse& from);
1216 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1217 bool IsInitialized() const final;
1218
1219 size_t ByteSizeLong() const final;
1220 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1221 ::uint8_t* _InternalSerialize(
1222 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1223 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1224
1225 private:
1226 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1227 void SharedDtor();
1228 void SetCachedSize(int size) const;
1229 void InternalSwap(AbortSecureAggregationResponse* other);
1230
1231 private:
1232 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1233 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1234 return "google.internal.federatedcompute.v1.AbortSecureAggregationResponse";
1235 }
1236 protected:
1237 explicit AbortSecureAggregationResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1238 bool is_message_owned = false);
1239 public:
1240
1241 std::string GetTypeName() const final;
1242
1243 // nested types ----------------------------------------------------
1244
1245 // accessors -------------------------------------------------------
1246
1247 // @@protoc_insertion_point(class_scope:google.internal.federatedcompute.v1.AbortSecureAggregationResponse)
1248 private:
1249 class _Internal;
1250
1251 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1252 typedef void InternalArenaConstructable_;
1253 typedef void DestructorSkippable_;
1254 struct Impl_ {
1255 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1256 };
1257 union { Impl_ _impl_; };
1258 friend struct ::TableStruct_fcp_2fprotos_2ffederatedcompute_2fsecure_5faggregations_2eproto;
1259 };
1260 // -------------------------------------------------------------------
1261
1262 class AdvertiseKeysRequest final :
1263 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federatedcompute.v1.AdvertiseKeysRequest) */ {
1264 public:
AdvertiseKeysRequest()1265 inline AdvertiseKeysRequest() : AdvertiseKeysRequest(nullptr) {}
1266 ~AdvertiseKeysRequest() override;
1267 explicit PROTOBUF_CONSTEXPR AdvertiseKeysRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1268
1269 AdvertiseKeysRequest(const AdvertiseKeysRequest& from);
AdvertiseKeysRequest(AdvertiseKeysRequest && from)1270 AdvertiseKeysRequest(AdvertiseKeysRequest&& from) noexcept
1271 : AdvertiseKeysRequest() {
1272 *this = ::std::move(from);
1273 }
1274
1275 inline AdvertiseKeysRequest& operator=(const AdvertiseKeysRequest& from) {
1276 if (this == &from) return *this;
1277 CopyFrom(from);
1278 return *this;
1279 }
1280 inline AdvertiseKeysRequest& operator=(AdvertiseKeysRequest&& from) noexcept {
1281 if (this == &from) return *this;
1282 if (GetOwningArena() == from.GetOwningArena()
1283 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1284 && GetOwningArena() != nullptr
1285 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1286 ) {
1287 InternalSwap(&from);
1288 } else {
1289 CopyFrom(from);
1290 }
1291 return *this;
1292 }
1293
default_instance()1294 static const AdvertiseKeysRequest& default_instance() {
1295 return *internal_default_instance();
1296 }
internal_default_instance()1297 static inline const AdvertiseKeysRequest* internal_default_instance() {
1298 return reinterpret_cast<const AdvertiseKeysRequest*>(
1299 &_AdvertiseKeysRequest_default_instance_);
1300 }
1301 static constexpr int kIndexInFileMessages =
1302 8;
1303
swap(AdvertiseKeysRequest & a,AdvertiseKeysRequest & b)1304 friend void swap(AdvertiseKeysRequest& a, AdvertiseKeysRequest& b) {
1305 a.Swap(&b);
1306 }
Swap(AdvertiseKeysRequest * other)1307 inline void Swap(AdvertiseKeysRequest* other) {
1308 if (other == this) return;
1309 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1310 if (GetOwningArena() != nullptr &&
1311 GetOwningArena() == other->GetOwningArena()) {
1312 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1313 if (GetOwningArena() == other->GetOwningArena()) {
1314 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1315 InternalSwap(other);
1316 } else {
1317 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1318 }
1319 }
1320 void UnsafeArenaSwap(AdvertiseKeysRequest* other) {
1321 if (other == this) return;
1322 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1323 InternalSwap(other);
1324 }
1325
1326 // implements Message ----------------------------------------------
1327
1328 AdvertiseKeysRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1329 return CreateMaybeMessage<AdvertiseKeysRequest>(arena);
1330 }
1331 AdvertiseKeysRequest* New() const {
1332 return New(nullptr);
1333 }
1334 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1335 void CopyFrom(const AdvertiseKeysRequest& from);
1336 void MergeFrom(const AdvertiseKeysRequest& from);
1337 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1338 bool IsInitialized() const final;
1339
1340 size_t ByteSizeLong() const final;
1341 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1342 ::uint8_t* _InternalSerialize(
1343 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1344 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1345
1346 private:
1347 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1348 void SharedDtor();
1349 void SetCachedSize(int size) const;
1350 void InternalSwap(AdvertiseKeysRequest* other);
1351
1352 private:
1353 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1354 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1355 return "google.internal.federatedcompute.v1.AdvertiseKeysRequest";
1356 }
1357 protected:
1358 explicit AdvertiseKeysRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1359 bool is_message_owned = false);
1360 public:
1361
1362 std::string GetTypeName() const final;
1363
1364 // nested types ----------------------------------------------------
1365
1366 // accessors -------------------------------------------------------
1367
1368 enum : int {
1369 kAggregationIdFieldNumber = 1,
1370 kClientTokenFieldNumber = 2,
1371 kAdvertiseKeysFieldNumber = 3,
1372 };
1373 // string aggregation_id = 1;
1374 void clear_aggregation_id();
1375 const std::string& aggregation_id() const;
1376 template <typename ArgT0 = const std::string&, typename... ArgT>
1377 void set_aggregation_id(ArgT0&& arg0, ArgT... args);
1378 std::string* mutable_aggregation_id();
1379 PROTOBUF_NODISCARD std::string* release_aggregation_id();
1380 void set_allocated_aggregation_id(std::string* aggregation_id);
1381 private:
1382 const std::string& _internal_aggregation_id() const;
1383 inline PROTOBUF_ALWAYS_INLINE void _internal_set_aggregation_id(const std::string& value);
1384 std::string* _internal_mutable_aggregation_id();
1385 public:
1386
1387 // string client_token = 2;
1388 void clear_client_token();
1389 const std::string& client_token() const;
1390 template <typename ArgT0 = const std::string&, typename... ArgT>
1391 void set_client_token(ArgT0&& arg0, ArgT... args);
1392 std::string* mutable_client_token();
1393 PROTOBUF_NODISCARD std::string* release_client_token();
1394 void set_allocated_client_token(std::string* client_token);
1395 private:
1396 const std::string& _internal_client_token() const;
1397 inline PROTOBUF_ALWAYS_INLINE void _internal_set_client_token(const std::string& value);
1398 std::string* _internal_mutable_client_token();
1399 public:
1400
1401 // .fcp.secagg.AdvertiseKeys advertise_keys = 3;
1402 bool has_advertise_keys() const;
1403 private:
1404 bool _internal_has_advertise_keys() const;
1405 public:
1406 void clear_advertise_keys();
1407 const ::fcp::secagg::AdvertiseKeys& advertise_keys() const;
1408 PROTOBUF_NODISCARD ::fcp::secagg::AdvertiseKeys* release_advertise_keys();
1409 ::fcp::secagg::AdvertiseKeys* mutable_advertise_keys();
1410 void set_allocated_advertise_keys(::fcp::secagg::AdvertiseKeys* advertise_keys);
1411 private:
1412 const ::fcp::secagg::AdvertiseKeys& _internal_advertise_keys() const;
1413 ::fcp::secagg::AdvertiseKeys* _internal_mutable_advertise_keys();
1414 public:
1415 void unsafe_arena_set_allocated_advertise_keys(
1416 ::fcp::secagg::AdvertiseKeys* advertise_keys);
1417 ::fcp::secagg::AdvertiseKeys* unsafe_arena_release_advertise_keys();
1418
1419 // @@protoc_insertion_point(class_scope:google.internal.federatedcompute.v1.AdvertiseKeysRequest)
1420 private:
1421 class _Internal;
1422
1423 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1424 typedef void InternalArenaConstructable_;
1425 typedef void DestructorSkippable_;
1426 struct Impl_ {
1427 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr aggregation_id_;
1428 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr client_token_;
1429 ::fcp::secagg::AdvertiseKeys* advertise_keys_;
1430 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1431 };
1432 union { Impl_ _impl_; };
1433 friend struct ::TableStruct_fcp_2fprotos_2ffederatedcompute_2fsecure_5faggregations_2eproto;
1434 };
1435 // -------------------------------------------------------------------
1436
1437 class AdvertiseKeysMetadata final :
1438 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federatedcompute.v1.AdvertiseKeysMetadata) */ {
1439 public:
AdvertiseKeysMetadata()1440 inline AdvertiseKeysMetadata() : AdvertiseKeysMetadata(nullptr) {}
1441 ~AdvertiseKeysMetadata() override;
1442 explicit PROTOBUF_CONSTEXPR AdvertiseKeysMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1443
1444 AdvertiseKeysMetadata(const AdvertiseKeysMetadata& from);
AdvertiseKeysMetadata(AdvertiseKeysMetadata && from)1445 AdvertiseKeysMetadata(AdvertiseKeysMetadata&& from) noexcept
1446 : AdvertiseKeysMetadata() {
1447 *this = ::std::move(from);
1448 }
1449
1450 inline AdvertiseKeysMetadata& operator=(const AdvertiseKeysMetadata& from) {
1451 if (this == &from) return *this;
1452 CopyFrom(from);
1453 return *this;
1454 }
1455 inline AdvertiseKeysMetadata& operator=(AdvertiseKeysMetadata&& from) noexcept {
1456 if (this == &from) return *this;
1457 if (GetOwningArena() == from.GetOwningArena()
1458 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1459 && GetOwningArena() != nullptr
1460 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1461 ) {
1462 InternalSwap(&from);
1463 } else {
1464 CopyFrom(from);
1465 }
1466 return *this;
1467 }
1468
default_instance()1469 static const AdvertiseKeysMetadata& default_instance() {
1470 return *internal_default_instance();
1471 }
internal_default_instance()1472 static inline const AdvertiseKeysMetadata* internal_default_instance() {
1473 return reinterpret_cast<const AdvertiseKeysMetadata*>(
1474 &_AdvertiseKeysMetadata_default_instance_);
1475 }
1476 static constexpr int kIndexInFileMessages =
1477 9;
1478
swap(AdvertiseKeysMetadata & a,AdvertiseKeysMetadata & b)1479 friend void swap(AdvertiseKeysMetadata& a, AdvertiseKeysMetadata& b) {
1480 a.Swap(&b);
1481 }
Swap(AdvertiseKeysMetadata * other)1482 inline void Swap(AdvertiseKeysMetadata* other) {
1483 if (other == this) return;
1484 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1485 if (GetOwningArena() != nullptr &&
1486 GetOwningArena() == other->GetOwningArena()) {
1487 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1488 if (GetOwningArena() == other->GetOwningArena()) {
1489 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1490 InternalSwap(other);
1491 } else {
1492 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1493 }
1494 }
1495 void UnsafeArenaSwap(AdvertiseKeysMetadata* other) {
1496 if (other == this) return;
1497 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1498 InternalSwap(other);
1499 }
1500
1501 // implements Message ----------------------------------------------
1502
1503 AdvertiseKeysMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1504 return CreateMaybeMessage<AdvertiseKeysMetadata>(arena);
1505 }
1506 AdvertiseKeysMetadata* New() const {
1507 return New(nullptr);
1508 }
1509 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1510 void CopyFrom(const AdvertiseKeysMetadata& from);
1511 void MergeFrom(const AdvertiseKeysMetadata& from);
1512 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1513 bool IsInitialized() const final;
1514
1515 size_t ByteSizeLong() const final;
1516 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1517 ::uint8_t* _InternalSerialize(
1518 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1519 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1520
1521 private:
1522 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1523 void SharedDtor();
1524 void SetCachedSize(int size) const;
1525 void InternalSwap(AdvertiseKeysMetadata* other);
1526
1527 private:
1528 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1529 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1530 return "google.internal.federatedcompute.v1.AdvertiseKeysMetadata";
1531 }
1532 protected:
1533 explicit AdvertiseKeysMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1534 bool is_message_owned = false);
1535 public:
1536
1537 std::string GetTypeName() const final;
1538
1539 // nested types ----------------------------------------------------
1540
1541 // accessors -------------------------------------------------------
1542
1543 enum : int {
1544 kPollingIntervalFieldNumber = 1,
1545 };
1546 // .google.protobuf.Duration polling_interval = 1;
1547 bool has_polling_interval() const;
1548 private:
1549 bool _internal_has_polling_interval() const;
1550 public:
1551 void clear_polling_interval();
1552 const ::PROTOBUF_NAMESPACE_ID::Duration& polling_interval() const;
1553 PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Duration* release_polling_interval();
1554 ::PROTOBUF_NAMESPACE_ID::Duration* mutable_polling_interval();
1555 void set_allocated_polling_interval(::PROTOBUF_NAMESPACE_ID::Duration* polling_interval);
1556 private:
1557 const ::PROTOBUF_NAMESPACE_ID::Duration& _internal_polling_interval() const;
1558 ::PROTOBUF_NAMESPACE_ID::Duration* _internal_mutable_polling_interval();
1559 public:
1560 void unsafe_arena_set_allocated_polling_interval(
1561 ::PROTOBUF_NAMESPACE_ID::Duration* polling_interval);
1562 ::PROTOBUF_NAMESPACE_ID::Duration* unsafe_arena_release_polling_interval();
1563
1564 // @@protoc_insertion_point(class_scope:google.internal.federatedcompute.v1.AdvertiseKeysMetadata)
1565 private:
1566 class _Internal;
1567
1568 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1569 typedef void InternalArenaConstructable_;
1570 typedef void DestructorSkippable_;
1571 struct Impl_ {
1572 ::PROTOBUF_NAMESPACE_ID::Duration* polling_interval_;
1573 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1574 };
1575 union { Impl_ _impl_; };
1576 friend struct ::TableStruct_fcp_2fprotos_2ffederatedcompute_2fsecure_5faggregations_2eproto;
1577 };
1578 // -------------------------------------------------------------------
1579
1580 class AdvertiseKeysResponse final :
1581 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federatedcompute.v1.AdvertiseKeysResponse) */ {
1582 public:
AdvertiseKeysResponse()1583 inline AdvertiseKeysResponse() : AdvertiseKeysResponse(nullptr) {}
1584 ~AdvertiseKeysResponse() override;
1585 explicit PROTOBUF_CONSTEXPR AdvertiseKeysResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1586
1587 AdvertiseKeysResponse(const AdvertiseKeysResponse& from);
AdvertiseKeysResponse(AdvertiseKeysResponse && from)1588 AdvertiseKeysResponse(AdvertiseKeysResponse&& from) noexcept
1589 : AdvertiseKeysResponse() {
1590 *this = ::std::move(from);
1591 }
1592
1593 inline AdvertiseKeysResponse& operator=(const AdvertiseKeysResponse& from) {
1594 if (this == &from) return *this;
1595 CopyFrom(from);
1596 return *this;
1597 }
1598 inline AdvertiseKeysResponse& operator=(AdvertiseKeysResponse&& from) noexcept {
1599 if (this == &from) return *this;
1600 if (GetOwningArena() == from.GetOwningArena()
1601 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1602 && GetOwningArena() != nullptr
1603 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1604 ) {
1605 InternalSwap(&from);
1606 } else {
1607 CopyFrom(from);
1608 }
1609 return *this;
1610 }
1611
default_instance()1612 static const AdvertiseKeysResponse& default_instance() {
1613 return *internal_default_instance();
1614 }
internal_default_instance()1615 static inline const AdvertiseKeysResponse* internal_default_instance() {
1616 return reinterpret_cast<const AdvertiseKeysResponse*>(
1617 &_AdvertiseKeysResponse_default_instance_);
1618 }
1619 static constexpr int kIndexInFileMessages =
1620 10;
1621
swap(AdvertiseKeysResponse & a,AdvertiseKeysResponse & b)1622 friend void swap(AdvertiseKeysResponse& a, AdvertiseKeysResponse& b) {
1623 a.Swap(&b);
1624 }
Swap(AdvertiseKeysResponse * other)1625 inline void Swap(AdvertiseKeysResponse* other) {
1626 if (other == this) return;
1627 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1628 if (GetOwningArena() != nullptr &&
1629 GetOwningArena() == other->GetOwningArena()) {
1630 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1631 if (GetOwningArena() == other->GetOwningArena()) {
1632 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1633 InternalSwap(other);
1634 } else {
1635 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1636 }
1637 }
1638 void UnsafeArenaSwap(AdvertiseKeysResponse* other) {
1639 if (other == this) return;
1640 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1641 InternalSwap(other);
1642 }
1643
1644 // implements Message ----------------------------------------------
1645
1646 AdvertiseKeysResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1647 return CreateMaybeMessage<AdvertiseKeysResponse>(arena);
1648 }
1649 AdvertiseKeysResponse* New() const {
1650 return New(nullptr);
1651 }
1652 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1653 void CopyFrom(const AdvertiseKeysResponse& from);
1654 void MergeFrom(const AdvertiseKeysResponse& from);
1655 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1656 bool IsInitialized() const final;
1657
1658 size_t ByteSizeLong() const final;
1659 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1660 ::uint8_t* _InternalSerialize(
1661 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1662 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1663
1664 private:
1665 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1666 void SharedDtor();
1667 void SetCachedSize(int size) const;
1668 void InternalSwap(AdvertiseKeysResponse* other);
1669
1670 private:
1671 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1672 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1673 return "google.internal.federatedcompute.v1.AdvertiseKeysResponse";
1674 }
1675 protected:
1676 explicit AdvertiseKeysResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1677 bool is_message_owned = false);
1678 public:
1679
1680 std::string GetTypeName() const final;
1681
1682 // nested types ----------------------------------------------------
1683
1684 // accessors -------------------------------------------------------
1685
1686 enum : int {
1687 kShareKeysServerRequestFieldNumber = 1,
1688 };
1689 // .fcp.secagg.ShareKeysRequest share_keys_server_request = 1;
1690 bool has_share_keys_server_request() const;
1691 private:
1692 bool _internal_has_share_keys_server_request() const;
1693 public:
1694 void clear_share_keys_server_request();
1695 const ::fcp::secagg::ShareKeysRequest& share_keys_server_request() const;
1696 PROTOBUF_NODISCARD ::fcp::secagg::ShareKeysRequest* release_share_keys_server_request();
1697 ::fcp::secagg::ShareKeysRequest* mutable_share_keys_server_request();
1698 void set_allocated_share_keys_server_request(::fcp::secagg::ShareKeysRequest* share_keys_server_request);
1699 private:
1700 const ::fcp::secagg::ShareKeysRequest& _internal_share_keys_server_request() const;
1701 ::fcp::secagg::ShareKeysRequest* _internal_mutable_share_keys_server_request();
1702 public:
1703 void unsafe_arena_set_allocated_share_keys_server_request(
1704 ::fcp::secagg::ShareKeysRequest* share_keys_server_request);
1705 ::fcp::secagg::ShareKeysRequest* unsafe_arena_release_share_keys_server_request();
1706
1707 // @@protoc_insertion_point(class_scope:google.internal.federatedcompute.v1.AdvertiseKeysResponse)
1708 private:
1709 class _Internal;
1710
1711 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1712 typedef void InternalArenaConstructable_;
1713 typedef void DestructorSkippable_;
1714 struct Impl_ {
1715 ::fcp::secagg::ShareKeysRequest* share_keys_server_request_;
1716 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1717 };
1718 union { Impl_ _impl_; };
1719 friend struct ::TableStruct_fcp_2fprotos_2ffederatedcompute_2fsecure_5faggregations_2eproto;
1720 };
1721 // -------------------------------------------------------------------
1722
1723 class ShareKeysRequest final :
1724 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federatedcompute.v1.ShareKeysRequest) */ {
1725 public:
ShareKeysRequest()1726 inline ShareKeysRequest() : ShareKeysRequest(nullptr) {}
1727 ~ShareKeysRequest() override;
1728 explicit PROTOBUF_CONSTEXPR ShareKeysRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1729
1730 ShareKeysRequest(const ShareKeysRequest& from);
ShareKeysRequest(ShareKeysRequest && from)1731 ShareKeysRequest(ShareKeysRequest&& from) noexcept
1732 : ShareKeysRequest() {
1733 *this = ::std::move(from);
1734 }
1735
1736 inline ShareKeysRequest& operator=(const ShareKeysRequest& from) {
1737 if (this == &from) return *this;
1738 CopyFrom(from);
1739 return *this;
1740 }
1741 inline ShareKeysRequest& operator=(ShareKeysRequest&& from) noexcept {
1742 if (this == &from) return *this;
1743 if (GetOwningArena() == from.GetOwningArena()
1744 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1745 && GetOwningArena() != nullptr
1746 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1747 ) {
1748 InternalSwap(&from);
1749 } else {
1750 CopyFrom(from);
1751 }
1752 return *this;
1753 }
1754
default_instance()1755 static const ShareKeysRequest& default_instance() {
1756 return *internal_default_instance();
1757 }
internal_default_instance()1758 static inline const ShareKeysRequest* internal_default_instance() {
1759 return reinterpret_cast<const ShareKeysRequest*>(
1760 &_ShareKeysRequest_default_instance_);
1761 }
1762 static constexpr int kIndexInFileMessages =
1763 11;
1764
swap(ShareKeysRequest & a,ShareKeysRequest & b)1765 friend void swap(ShareKeysRequest& a, ShareKeysRequest& b) {
1766 a.Swap(&b);
1767 }
Swap(ShareKeysRequest * other)1768 inline void Swap(ShareKeysRequest* other) {
1769 if (other == this) return;
1770 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1771 if (GetOwningArena() != nullptr &&
1772 GetOwningArena() == other->GetOwningArena()) {
1773 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1774 if (GetOwningArena() == other->GetOwningArena()) {
1775 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1776 InternalSwap(other);
1777 } else {
1778 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1779 }
1780 }
1781 void UnsafeArenaSwap(ShareKeysRequest* other) {
1782 if (other == this) return;
1783 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1784 InternalSwap(other);
1785 }
1786
1787 // implements Message ----------------------------------------------
1788
1789 ShareKeysRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1790 return CreateMaybeMessage<ShareKeysRequest>(arena);
1791 }
1792 ShareKeysRequest* New() const {
1793 return New(nullptr);
1794 }
1795 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1796 void CopyFrom(const ShareKeysRequest& from);
1797 void MergeFrom(const ShareKeysRequest& from);
1798 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1799 bool IsInitialized() const final;
1800
1801 size_t ByteSizeLong() const final;
1802 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1803 ::uint8_t* _InternalSerialize(
1804 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1805 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1806
1807 private:
1808 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1809 void SharedDtor();
1810 void SetCachedSize(int size) const;
1811 void InternalSwap(ShareKeysRequest* other);
1812
1813 private:
1814 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1815 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1816 return "google.internal.federatedcompute.v1.ShareKeysRequest";
1817 }
1818 protected:
1819 explicit ShareKeysRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1820 bool is_message_owned = false);
1821 public:
1822
1823 std::string GetTypeName() const final;
1824
1825 // nested types ----------------------------------------------------
1826
1827 // accessors -------------------------------------------------------
1828
1829 enum : int {
1830 kAggregationIdFieldNumber = 1,
1831 kClientTokenFieldNumber = 2,
1832 kShareKeysClientResponseFieldNumber = 3,
1833 };
1834 // string aggregation_id = 1;
1835 void clear_aggregation_id();
1836 const std::string& aggregation_id() const;
1837 template <typename ArgT0 = const std::string&, typename... ArgT>
1838 void set_aggregation_id(ArgT0&& arg0, ArgT... args);
1839 std::string* mutable_aggregation_id();
1840 PROTOBUF_NODISCARD std::string* release_aggregation_id();
1841 void set_allocated_aggregation_id(std::string* aggregation_id);
1842 private:
1843 const std::string& _internal_aggregation_id() const;
1844 inline PROTOBUF_ALWAYS_INLINE void _internal_set_aggregation_id(const std::string& value);
1845 std::string* _internal_mutable_aggregation_id();
1846 public:
1847
1848 // string client_token = 2;
1849 void clear_client_token();
1850 const std::string& client_token() const;
1851 template <typename ArgT0 = const std::string&, typename... ArgT>
1852 void set_client_token(ArgT0&& arg0, ArgT... args);
1853 std::string* mutable_client_token();
1854 PROTOBUF_NODISCARD std::string* release_client_token();
1855 void set_allocated_client_token(std::string* client_token);
1856 private:
1857 const std::string& _internal_client_token() const;
1858 inline PROTOBUF_ALWAYS_INLINE void _internal_set_client_token(const std::string& value);
1859 std::string* _internal_mutable_client_token();
1860 public:
1861
1862 // .fcp.secagg.ShareKeysResponse share_keys_client_response = 3;
1863 bool has_share_keys_client_response() const;
1864 private:
1865 bool _internal_has_share_keys_client_response() const;
1866 public:
1867 void clear_share_keys_client_response();
1868 const ::fcp::secagg::ShareKeysResponse& share_keys_client_response() const;
1869 PROTOBUF_NODISCARD ::fcp::secagg::ShareKeysResponse* release_share_keys_client_response();
1870 ::fcp::secagg::ShareKeysResponse* mutable_share_keys_client_response();
1871 void set_allocated_share_keys_client_response(::fcp::secagg::ShareKeysResponse* share_keys_client_response);
1872 private:
1873 const ::fcp::secagg::ShareKeysResponse& _internal_share_keys_client_response() const;
1874 ::fcp::secagg::ShareKeysResponse* _internal_mutable_share_keys_client_response();
1875 public:
1876 void unsafe_arena_set_allocated_share_keys_client_response(
1877 ::fcp::secagg::ShareKeysResponse* share_keys_client_response);
1878 ::fcp::secagg::ShareKeysResponse* unsafe_arena_release_share_keys_client_response();
1879
1880 // @@protoc_insertion_point(class_scope:google.internal.federatedcompute.v1.ShareKeysRequest)
1881 private:
1882 class _Internal;
1883
1884 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1885 typedef void InternalArenaConstructable_;
1886 typedef void DestructorSkippable_;
1887 struct Impl_ {
1888 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr aggregation_id_;
1889 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr client_token_;
1890 ::fcp::secagg::ShareKeysResponse* share_keys_client_response_;
1891 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1892 };
1893 union { Impl_ _impl_; };
1894 friend struct ::TableStruct_fcp_2fprotos_2ffederatedcompute_2fsecure_5faggregations_2eproto;
1895 };
1896 // -------------------------------------------------------------------
1897
1898 class ShareKeysMetadata final :
1899 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federatedcompute.v1.ShareKeysMetadata) */ {
1900 public:
ShareKeysMetadata()1901 inline ShareKeysMetadata() : ShareKeysMetadata(nullptr) {}
1902 ~ShareKeysMetadata() override;
1903 explicit PROTOBUF_CONSTEXPR ShareKeysMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1904
1905 ShareKeysMetadata(const ShareKeysMetadata& from);
ShareKeysMetadata(ShareKeysMetadata && from)1906 ShareKeysMetadata(ShareKeysMetadata&& from) noexcept
1907 : ShareKeysMetadata() {
1908 *this = ::std::move(from);
1909 }
1910
1911 inline ShareKeysMetadata& operator=(const ShareKeysMetadata& from) {
1912 if (this == &from) return *this;
1913 CopyFrom(from);
1914 return *this;
1915 }
1916 inline ShareKeysMetadata& operator=(ShareKeysMetadata&& from) noexcept {
1917 if (this == &from) return *this;
1918 if (GetOwningArena() == from.GetOwningArena()
1919 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1920 && GetOwningArena() != nullptr
1921 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1922 ) {
1923 InternalSwap(&from);
1924 } else {
1925 CopyFrom(from);
1926 }
1927 return *this;
1928 }
1929
default_instance()1930 static const ShareKeysMetadata& default_instance() {
1931 return *internal_default_instance();
1932 }
internal_default_instance()1933 static inline const ShareKeysMetadata* internal_default_instance() {
1934 return reinterpret_cast<const ShareKeysMetadata*>(
1935 &_ShareKeysMetadata_default_instance_);
1936 }
1937 static constexpr int kIndexInFileMessages =
1938 12;
1939
swap(ShareKeysMetadata & a,ShareKeysMetadata & b)1940 friend void swap(ShareKeysMetadata& a, ShareKeysMetadata& b) {
1941 a.Swap(&b);
1942 }
Swap(ShareKeysMetadata * other)1943 inline void Swap(ShareKeysMetadata* other) {
1944 if (other == this) return;
1945 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1946 if (GetOwningArena() != nullptr &&
1947 GetOwningArena() == other->GetOwningArena()) {
1948 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1949 if (GetOwningArena() == other->GetOwningArena()) {
1950 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1951 InternalSwap(other);
1952 } else {
1953 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1954 }
1955 }
1956 void UnsafeArenaSwap(ShareKeysMetadata* other) {
1957 if (other == this) return;
1958 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1959 InternalSwap(other);
1960 }
1961
1962 // implements Message ----------------------------------------------
1963
1964 ShareKeysMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1965 return CreateMaybeMessage<ShareKeysMetadata>(arena);
1966 }
1967 ShareKeysMetadata* New() const {
1968 return New(nullptr);
1969 }
1970 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1971 void CopyFrom(const ShareKeysMetadata& from);
1972 void MergeFrom(const ShareKeysMetadata& from);
1973 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1974 bool IsInitialized() const final;
1975
1976 size_t ByteSizeLong() const final;
1977 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1978 ::uint8_t* _InternalSerialize(
1979 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1980 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1981
1982 private:
1983 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1984 void SharedDtor();
1985 void SetCachedSize(int size) const;
1986 void InternalSwap(ShareKeysMetadata* other);
1987
1988 private:
1989 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1990 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1991 return "google.internal.federatedcompute.v1.ShareKeysMetadata";
1992 }
1993 protected:
1994 explicit ShareKeysMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1995 bool is_message_owned = false);
1996 public:
1997
1998 std::string GetTypeName() const final;
1999
2000 // nested types ----------------------------------------------------
2001
2002 // accessors -------------------------------------------------------
2003
2004 enum : int {
2005 kPollingIntervalFieldNumber = 1,
2006 };
2007 // .google.protobuf.Duration polling_interval = 1;
2008 bool has_polling_interval() const;
2009 private:
2010 bool _internal_has_polling_interval() const;
2011 public:
2012 void clear_polling_interval();
2013 const ::PROTOBUF_NAMESPACE_ID::Duration& polling_interval() const;
2014 PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Duration* release_polling_interval();
2015 ::PROTOBUF_NAMESPACE_ID::Duration* mutable_polling_interval();
2016 void set_allocated_polling_interval(::PROTOBUF_NAMESPACE_ID::Duration* polling_interval);
2017 private:
2018 const ::PROTOBUF_NAMESPACE_ID::Duration& _internal_polling_interval() const;
2019 ::PROTOBUF_NAMESPACE_ID::Duration* _internal_mutable_polling_interval();
2020 public:
2021 void unsafe_arena_set_allocated_polling_interval(
2022 ::PROTOBUF_NAMESPACE_ID::Duration* polling_interval);
2023 ::PROTOBUF_NAMESPACE_ID::Duration* unsafe_arena_release_polling_interval();
2024
2025 // @@protoc_insertion_point(class_scope:google.internal.federatedcompute.v1.ShareKeysMetadata)
2026 private:
2027 class _Internal;
2028
2029 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2030 typedef void InternalArenaConstructable_;
2031 typedef void DestructorSkippable_;
2032 struct Impl_ {
2033 ::PROTOBUF_NAMESPACE_ID::Duration* polling_interval_;
2034 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2035 };
2036 union { Impl_ _impl_; };
2037 friend struct ::TableStruct_fcp_2fprotos_2ffederatedcompute_2fsecure_5faggregations_2eproto;
2038 };
2039 // -------------------------------------------------------------------
2040
2041 class ShareKeysResponse final :
2042 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federatedcompute.v1.ShareKeysResponse) */ {
2043 public:
ShareKeysResponse()2044 inline ShareKeysResponse() : ShareKeysResponse(nullptr) {}
2045 ~ShareKeysResponse() override;
2046 explicit PROTOBUF_CONSTEXPR ShareKeysResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2047
2048 ShareKeysResponse(const ShareKeysResponse& from);
ShareKeysResponse(ShareKeysResponse && from)2049 ShareKeysResponse(ShareKeysResponse&& from) noexcept
2050 : ShareKeysResponse() {
2051 *this = ::std::move(from);
2052 }
2053
2054 inline ShareKeysResponse& operator=(const ShareKeysResponse& from) {
2055 if (this == &from) return *this;
2056 CopyFrom(from);
2057 return *this;
2058 }
2059 inline ShareKeysResponse& operator=(ShareKeysResponse&& from) noexcept {
2060 if (this == &from) return *this;
2061 if (GetOwningArena() == from.GetOwningArena()
2062 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2063 && GetOwningArena() != nullptr
2064 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2065 ) {
2066 InternalSwap(&from);
2067 } else {
2068 CopyFrom(from);
2069 }
2070 return *this;
2071 }
2072
default_instance()2073 static const ShareKeysResponse& default_instance() {
2074 return *internal_default_instance();
2075 }
internal_default_instance()2076 static inline const ShareKeysResponse* internal_default_instance() {
2077 return reinterpret_cast<const ShareKeysResponse*>(
2078 &_ShareKeysResponse_default_instance_);
2079 }
2080 static constexpr int kIndexInFileMessages =
2081 13;
2082
swap(ShareKeysResponse & a,ShareKeysResponse & b)2083 friend void swap(ShareKeysResponse& a, ShareKeysResponse& b) {
2084 a.Swap(&b);
2085 }
Swap(ShareKeysResponse * other)2086 inline void Swap(ShareKeysResponse* other) {
2087 if (other == this) return;
2088 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2089 if (GetOwningArena() != nullptr &&
2090 GetOwningArena() == other->GetOwningArena()) {
2091 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2092 if (GetOwningArena() == other->GetOwningArena()) {
2093 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2094 InternalSwap(other);
2095 } else {
2096 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2097 }
2098 }
2099 void UnsafeArenaSwap(ShareKeysResponse* other) {
2100 if (other == this) return;
2101 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2102 InternalSwap(other);
2103 }
2104
2105 // implements Message ----------------------------------------------
2106
2107 ShareKeysResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2108 return CreateMaybeMessage<ShareKeysResponse>(arena);
2109 }
2110 ShareKeysResponse* New() const {
2111 return New(nullptr);
2112 }
2113 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2114 void CopyFrom(const ShareKeysResponse& from);
2115 void MergeFrom(const ShareKeysResponse& from);
2116 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2117 bool IsInitialized() const final;
2118
2119 size_t ByteSizeLong() const final;
2120 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2121 ::uint8_t* _InternalSerialize(
2122 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2123 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2124
2125 private:
2126 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2127 void SharedDtor();
2128 void SetCachedSize(int size) const;
2129 void InternalSwap(ShareKeysResponse* other);
2130
2131 private:
2132 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2133 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2134 return "google.internal.federatedcompute.v1.ShareKeysResponse";
2135 }
2136 protected:
2137 explicit ShareKeysResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2138 bool is_message_owned = false);
2139 public:
2140
2141 std::string GetTypeName() const final;
2142
2143 // nested types ----------------------------------------------------
2144
2145 // accessors -------------------------------------------------------
2146
2147 enum : int {
2148 kMaskedInputCollectionServerRequestFieldNumber = 1,
2149 };
2150 // .fcp.secagg.MaskedInputCollectionRequest masked_input_collection_server_request = 1;
2151 bool has_masked_input_collection_server_request() const;
2152 private:
2153 bool _internal_has_masked_input_collection_server_request() const;
2154 public:
2155 void clear_masked_input_collection_server_request();
2156 const ::fcp::secagg::MaskedInputCollectionRequest& masked_input_collection_server_request() const;
2157 PROTOBUF_NODISCARD ::fcp::secagg::MaskedInputCollectionRequest* release_masked_input_collection_server_request();
2158 ::fcp::secagg::MaskedInputCollectionRequest* mutable_masked_input_collection_server_request();
2159 void set_allocated_masked_input_collection_server_request(::fcp::secagg::MaskedInputCollectionRequest* masked_input_collection_server_request);
2160 private:
2161 const ::fcp::secagg::MaskedInputCollectionRequest& _internal_masked_input_collection_server_request() const;
2162 ::fcp::secagg::MaskedInputCollectionRequest* _internal_mutable_masked_input_collection_server_request();
2163 public:
2164 void unsafe_arena_set_allocated_masked_input_collection_server_request(
2165 ::fcp::secagg::MaskedInputCollectionRequest* masked_input_collection_server_request);
2166 ::fcp::secagg::MaskedInputCollectionRequest* unsafe_arena_release_masked_input_collection_server_request();
2167
2168 // @@protoc_insertion_point(class_scope:google.internal.federatedcompute.v1.ShareKeysResponse)
2169 private:
2170 class _Internal;
2171
2172 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2173 typedef void InternalArenaConstructable_;
2174 typedef void DestructorSkippable_;
2175 struct Impl_ {
2176 ::fcp::secagg::MaskedInputCollectionRequest* masked_input_collection_server_request_;
2177 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2178 };
2179 union { Impl_ _impl_; };
2180 friend struct ::TableStruct_fcp_2fprotos_2ffederatedcompute_2fsecure_5faggregations_2eproto;
2181 };
2182 // -------------------------------------------------------------------
2183
2184 class SubmitSecureAggregationResultRequest final :
2185 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest) */ {
2186 public:
SubmitSecureAggregationResultRequest()2187 inline SubmitSecureAggregationResultRequest() : SubmitSecureAggregationResultRequest(nullptr) {}
2188 ~SubmitSecureAggregationResultRequest() override;
2189 explicit PROTOBUF_CONSTEXPR SubmitSecureAggregationResultRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2190
2191 SubmitSecureAggregationResultRequest(const SubmitSecureAggregationResultRequest& from);
SubmitSecureAggregationResultRequest(SubmitSecureAggregationResultRequest && from)2192 SubmitSecureAggregationResultRequest(SubmitSecureAggregationResultRequest&& from) noexcept
2193 : SubmitSecureAggregationResultRequest() {
2194 *this = ::std::move(from);
2195 }
2196
2197 inline SubmitSecureAggregationResultRequest& operator=(const SubmitSecureAggregationResultRequest& from) {
2198 if (this == &from) return *this;
2199 CopyFrom(from);
2200 return *this;
2201 }
2202 inline SubmitSecureAggregationResultRequest& operator=(SubmitSecureAggregationResultRequest&& from) noexcept {
2203 if (this == &from) return *this;
2204 if (GetOwningArena() == from.GetOwningArena()
2205 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2206 && GetOwningArena() != nullptr
2207 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2208 ) {
2209 InternalSwap(&from);
2210 } else {
2211 CopyFrom(from);
2212 }
2213 return *this;
2214 }
2215
default_instance()2216 static const SubmitSecureAggregationResultRequest& default_instance() {
2217 return *internal_default_instance();
2218 }
internal_default_instance()2219 static inline const SubmitSecureAggregationResultRequest* internal_default_instance() {
2220 return reinterpret_cast<const SubmitSecureAggregationResultRequest*>(
2221 &_SubmitSecureAggregationResultRequest_default_instance_);
2222 }
2223 static constexpr int kIndexInFileMessages =
2224 14;
2225
swap(SubmitSecureAggregationResultRequest & a,SubmitSecureAggregationResultRequest & b)2226 friend void swap(SubmitSecureAggregationResultRequest& a, SubmitSecureAggregationResultRequest& b) {
2227 a.Swap(&b);
2228 }
Swap(SubmitSecureAggregationResultRequest * other)2229 inline void Swap(SubmitSecureAggregationResultRequest* other) {
2230 if (other == this) return;
2231 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2232 if (GetOwningArena() != nullptr &&
2233 GetOwningArena() == other->GetOwningArena()) {
2234 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2235 if (GetOwningArena() == other->GetOwningArena()) {
2236 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2237 InternalSwap(other);
2238 } else {
2239 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2240 }
2241 }
2242 void UnsafeArenaSwap(SubmitSecureAggregationResultRequest* other) {
2243 if (other == this) return;
2244 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2245 InternalSwap(other);
2246 }
2247
2248 // implements Message ----------------------------------------------
2249
2250 SubmitSecureAggregationResultRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2251 return CreateMaybeMessage<SubmitSecureAggregationResultRequest>(arena);
2252 }
2253 SubmitSecureAggregationResultRequest* New() const {
2254 return New(nullptr);
2255 }
2256 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2257 void CopyFrom(const SubmitSecureAggregationResultRequest& from);
2258 void MergeFrom(const SubmitSecureAggregationResultRequest& from);
2259 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2260 bool IsInitialized() const final;
2261
2262 size_t ByteSizeLong() const final;
2263 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2264 ::uint8_t* _InternalSerialize(
2265 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2266 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2267
2268 private:
2269 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2270 void SharedDtor();
2271 void SetCachedSize(int size) const;
2272 void InternalSwap(SubmitSecureAggregationResultRequest* other);
2273
2274 private:
2275 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2276 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2277 return "google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest";
2278 }
2279 protected:
2280 explicit SubmitSecureAggregationResultRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2281 bool is_message_owned = false);
2282 public:
2283
2284 std::string GetTypeName() const final;
2285
2286 // nested types ----------------------------------------------------
2287
2288 // accessors -------------------------------------------------------
2289
2290 enum : int {
2291 kAggregationIdFieldNumber = 1,
2292 kClientTokenFieldNumber = 2,
2293 kMaskedResultResourceNameFieldNumber = 3,
2294 kNonmaskedResultResourceNameFieldNumber = 4,
2295 };
2296 // string aggregation_id = 1;
2297 void clear_aggregation_id();
2298 const std::string& aggregation_id() const;
2299 template <typename ArgT0 = const std::string&, typename... ArgT>
2300 void set_aggregation_id(ArgT0&& arg0, ArgT... args);
2301 std::string* mutable_aggregation_id();
2302 PROTOBUF_NODISCARD std::string* release_aggregation_id();
2303 void set_allocated_aggregation_id(std::string* aggregation_id);
2304 private:
2305 const std::string& _internal_aggregation_id() const;
2306 inline PROTOBUF_ALWAYS_INLINE void _internal_set_aggregation_id(const std::string& value);
2307 std::string* _internal_mutable_aggregation_id();
2308 public:
2309
2310 // string client_token = 2;
2311 void clear_client_token();
2312 const std::string& client_token() const;
2313 template <typename ArgT0 = const std::string&, typename... ArgT>
2314 void set_client_token(ArgT0&& arg0, ArgT... args);
2315 std::string* mutable_client_token();
2316 PROTOBUF_NODISCARD std::string* release_client_token();
2317 void set_allocated_client_token(std::string* client_token);
2318 private:
2319 const std::string& _internal_client_token() const;
2320 inline PROTOBUF_ALWAYS_INLINE void _internal_set_client_token(const std::string& value);
2321 std::string* _internal_mutable_client_token();
2322 public:
2323
2324 // string masked_result_resource_name = 3;
2325 void clear_masked_result_resource_name();
2326 const std::string& masked_result_resource_name() const;
2327 template <typename ArgT0 = const std::string&, typename... ArgT>
2328 void set_masked_result_resource_name(ArgT0&& arg0, ArgT... args);
2329 std::string* mutable_masked_result_resource_name();
2330 PROTOBUF_NODISCARD std::string* release_masked_result_resource_name();
2331 void set_allocated_masked_result_resource_name(std::string* masked_result_resource_name);
2332 private:
2333 const std::string& _internal_masked_result_resource_name() const;
2334 inline PROTOBUF_ALWAYS_INLINE void _internal_set_masked_result_resource_name(const std::string& value);
2335 std::string* _internal_mutable_masked_result_resource_name();
2336 public:
2337
2338 // string nonmasked_result_resource_name = 4;
2339 void clear_nonmasked_result_resource_name();
2340 const std::string& nonmasked_result_resource_name() const;
2341 template <typename ArgT0 = const std::string&, typename... ArgT>
2342 void set_nonmasked_result_resource_name(ArgT0&& arg0, ArgT... args);
2343 std::string* mutable_nonmasked_result_resource_name();
2344 PROTOBUF_NODISCARD std::string* release_nonmasked_result_resource_name();
2345 void set_allocated_nonmasked_result_resource_name(std::string* nonmasked_result_resource_name);
2346 private:
2347 const std::string& _internal_nonmasked_result_resource_name() const;
2348 inline PROTOBUF_ALWAYS_INLINE void _internal_set_nonmasked_result_resource_name(const std::string& value);
2349 std::string* _internal_mutable_nonmasked_result_resource_name();
2350 public:
2351
2352 // @@protoc_insertion_point(class_scope:google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest)
2353 private:
2354 class _Internal;
2355
2356 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2357 typedef void InternalArenaConstructable_;
2358 typedef void DestructorSkippable_;
2359 struct Impl_ {
2360 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr aggregation_id_;
2361 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr client_token_;
2362 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr masked_result_resource_name_;
2363 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr nonmasked_result_resource_name_;
2364 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2365 };
2366 union { Impl_ _impl_; };
2367 friend struct ::TableStruct_fcp_2fprotos_2ffederatedcompute_2fsecure_5faggregations_2eproto;
2368 };
2369 // -------------------------------------------------------------------
2370
2371 class SubmitSecureAggregationResultMetadata final :
2372 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federatedcompute.v1.SubmitSecureAggregationResultMetadata) */ {
2373 public:
SubmitSecureAggregationResultMetadata()2374 inline SubmitSecureAggregationResultMetadata() : SubmitSecureAggregationResultMetadata(nullptr) {}
2375 ~SubmitSecureAggregationResultMetadata() override;
2376 explicit PROTOBUF_CONSTEXPR SubmitSecureAggregationResultMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2377
2378 SubmitSecureAggregationResultMetadata(const SubmitSecureAggregationResultMetadata& from);
SubmitSecureAggregationResultMetadata(SubmitSecureAggregationResultMetadata && from)2379 SubmitSecureAggregationResultMetadata(SubmitSecureAggregationResultMetadata&& from) noexcept
2380 : SubmitSecureAggregationResultMetadata() {
2381 *this = ::std::move(from);
2382 }
2383
2384 inline SubmitSecureAggregationResultMetadata& operator=(const SubmitSecureAggregationResultMetadata& from) {
2385 if (this == &from) return *this;
2386 CopyFrom(from);
2387 return *this;
2388 }
2389 inline SubmitSecureAggregationResultMetadata& operator=(SubmitSecureAggregationResultMetadata&& from) noexcept {
2390 if (this == &from) return *this;
2391 if (GetOwningArena() == from.GetOwningArena()
2392 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2393 && GetOwningArena() != nullptr
2394 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2395 ) {
2396 InternalSwap(&from);
2397 } else {
2398 CopyFrom(from);
2399 }
2400 return *this;
2401 }
2402
default_instance()2403 static const SubmitSecureAggregationResultMetadata& default_instance() {
2404 return *internal_default_instance();
2405 }
internal_default_instance()2406 static inline const SubmitSecureAggregationResultMetadata* internal_default_instance() {
2407 return reinterpret_cast<const SubmitSecureAggregationResultMetadata*>(
2408 &_SubmitSecureAggregationResultMetadata_default_instance_);
2409 }
2410 static constexpr int kIndexInFileMessages =
2411 15;
2412
swap(SubmitSecureAggregationResultMetadata & a,SubmitSecureAggregationResultMetadata & b)2413 friend void swap(SubmitSecureAggregationResultMetadata& a, SubmitSecureAggregationResultMetadata& b) {
2414 a.Swap(&b);
2415 }
Swap(SubmitSecureAggregationResultMetadata * other)2416 inline void Swap(SubmitSecureAggregationResultMetadata* other) {
2417 if (other == this) return;
2418 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2419 if (GetOwningArena() != nullptr &&
2420 GetOwningArena() == other->GetOwningArena()) {
2421 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2422 if (GetOwningArena() == other->GetOwningArena()) {
2423 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2424 InternalSwap(other);
2425 } else {
2426 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2427 }
2428 }
2429 void UnsafeArenaSwap(SubmitSecureAggregationResultMetadata* other) {
2430 if (other == this) return;
2431 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2432 InternalSwap(other);
2433 }
2434
2435 // implements Message ----------------------------------------------
2436
2437 SubmitSecureAggregationResultMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2438 return CreateMaybeMessage<SubmitSecureAggregationResultMetadata>(arena);
2439 }
2440 SubmitSecureAggregationResultMetadata* New() const {
2441 return New(nullptr);
2442 }
2443 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2444 void CopyFrom(const SubmitSecureAggregationResultMetadata& from);
2445 void MergeFrom(const SubmitSecureAggregationResultMetadata& from);
2446 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2447 bool IsInitialized() const final;
2448
2449 size_t ByteSizeLong() const final;
2450 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2451 ::uint8_t* _InternalSerialize(
2452 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2453 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2454
2455 private:
2456 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2457 void SharedDtor();
2458 void SetCachedSize(int size) const;
2459 void InternalSwap(SubmitSecureAggregationResultMetadata* other);
2460
2461 private:
2462 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2463 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2464 return "google.internal.federatedcompute.v1.SubmitSecureAggregationResultMetadata";
2465 }
2466 protected:
2467 explicit SubmitSecureAggregationResultMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2468 bool is_message_owned = false);
2469 public:
2470
2471 std::string GetTypeName() const final;
2472
2473 // nested types ----------------------------------------------------
2474
2475 // accessors -------------------------------------------------------
2476
2477 enum : int {
2478 kPollingIntervalFieldNumber = 1,
2479 };
2480 // .google.protobuf.Duration polling_interval = 1;
2481 bool has_polling_interval() const;
2482 private:
2483 bool _internal_has_polling_interval() const;
2484 public:
2485 void clear_polling_interval();
2486 const ::PROTOBUF_NAMESPACE_ID::Duration& polling_interval() const;
2487 PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Duration* release_polling_interval();
2488 ::PROTOBUF_NAMESPACE_ID::Duration* mutable_polling_interval();
2489 void set_allocated_polling_interval(::PROTOBUF_NAMESPACE_ID::Duration* polling_interval);
2490 private:
2491 const ::PROTOBUF_NAMESPACE_ID::Duration& _internal_polling_interval() const;
2492 ::PROTOBUF_NAMESPACE_ID::Duration* _internal_mutable_polling_interval();
2493 public:
2494 void unsafe_arena_set_allocated_polling_interval(
2495 ::PROTOBUF_NAMESPACE_ID::Duration* polling_interval);
2496 ::PROTOBUF_NAMESPACE_ID::Duration* unsafe_arena_release_polling_interval();
2497
2498 // @@protoc_insertion_point(class_scope:google.internal.federatedcompute.v1.SubmitSecureAggregationResultMetadata)
2499 private:
2500 class _Internal;
2501
2502 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2503 typedef void InternalArenaConstructable_;
2504 typedef void DestructorSkippable_;
2505 struct Impl_ {
2506 ::PROTOBUF_NAMESPACE_ID::Duration* polling_interval_;
2507 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2508 };
2509 union { Impl_ _impl_; };
2510 friend struct ::TableStruct_fcp_2fprotos_2ffederatedcompute_2fsecure_5faggregations_2eproto;
2511 };
2512 // -------------------------------------------------------------------
2513
2514 class SubmitSecureAggregationResultResponse final :
2515 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federatedcompute.v1.SubmitSecureAggregationResultResponse) */ {
2516 public:
SubmitSecureAggregationResultResponse()2517 inline SubmitSecureAggregationResultResponse() : SubmitSecureAggregationResultResponse(nullptr) {}
2518 ~SubmitSecureAggregationResultResponse() override;
2519 explicit PROTOBUF_CONSTEXPR SubmitSecureAggregationResultResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2520
2521 SubmitSecureAggregationResultResponse(const SubmitSecureAggregationResultResponse& from);
SubmitSecureAggregationResultResponse(SubmitSecureAggregationResultResponse && from)2522 SubmitSecureAggregationResultResponse(SubmitSecureAggregationResultResponse&& from) noexcept
2523 : SubmitSecureAggregationResultResponse() {
2524 *this = ::std::move(from);
2525 }
2526
2527 inline SubmitSecureAggregationResultResponse& operator=(const SubmitSecureAggregationResultResponse& from) {
2528 if (this == &from) return *this;
2529 CopyFrom(from);
2530 return *this;
2531 }
2532 inline SubmitSecureAggregationResultResponse& operator=(SubmitSecureAggregationResultResponse&& from) noexcept {
2533 if (this == &from) return *this;
2534 if (GetOwningArena() == from.GetOwningArena()
2535 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2536 && GetOwningArena() != nullptr
2537 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2538 ) {
2539 InternalSwap(&from);
2540 } else {
2541 CopyFrom(from);
2542 }
2543 return *this;
2544 }
2545
default_instance()2546 static const SubmitSecureAggregationResultResponse& default_instance() {
2547 return *internal_default_instance();
2548 }
internal_default_instance()2549 static inline const SubmitSecureAggregationResultResponse* internal_default_instance() {
2550 return reinterpret_cast<const SubmitSecureAggregationResultResponse*>(
2551 &_SubmitSecureAggregationResultResponse_default_instance_);
2552 }
2553 static constexpr int kIndexInFileMessages =
2554 16;
2555
swap(SubmitSecureAggregationResultResponse & a,SubmitSecureAggregationResultResponse & b)2556 friend void swap(SubmitSecureAggregationResultResponse& a, SubmitSecureAggregationResultResponse& b) {
2557 a.Swap(&b);
2558 }
Swap(SubmitSecureAggregationResultResponse * other)2559 inline void Swap(SubmitSecureAggregationResultResponse* other) {
2560 if (other == this) return;
2561 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2562 if (GetOwningArena() != nullptr &&
2563 GetOwningArena() == other->GetOwningArena()) {
2564 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2565 if (GetOwningArena() == other->GetOwningArena()) {
2566 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2567 InternalSwap(other);
2568 } else {
2569 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2570 }
2571 }
2572 void UnsafeArenaSwap(SubmitSecureAggregationResultResponse* other) {
2573 if (other == this) return;
2574 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2575 InternalSwap(other);
2576 }
2577
2578 // implements Message ----------------------------------------------
2579
2580 SubmitSecureAggregationResultResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2581 return CreateMaybeMessage<SubmitSecureAggregationResultResponse>(arena);
2582 }
2583 SubmitSecureAggregationResultResponse* New() const {
2584 return New(nullptr);
2585 }
2586 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2587 void CopyFrom(const SubmitSecureAggregationResultResponse& from);
2588 void MergeFrom(const SubmitSecureAggregationResultResponse& from);
2589 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2590 bool IsInitialized() const final;
2591
2592 size_t ByteSizeLong() const final;
2593 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2594 ::uint8_t* _InternalSerialize(
2595 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2596 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2597
2598 private:
2599 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2600 void SharedDtor();
2601 void SetCachedSize(int size) const;
2602 void InternalSwap(SubmitSecureAggregationResultResponse* other);
2603
2604 private:
2605 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2606 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2607 return "google.internal.federatedcompute.v1.SubmitSecureAggregationResultResponse";
2608 }
2609 protected:
2610 explicit SubmitSecureAggregationResultResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2611 bool is_message_owned = false);
2612 public:
2613
2614 std::string GetTypeName() const final;
2615
2616 // nested types ----------------------------------------------------
2617
2618 // accessors -------------------------------------------------------
2619
2620 enum : int {
2621 kUnmaskingServerRequestFieldNumber = 1,
2622 };
2623 // .fcp.secagg.UnmaskingRequest unmasking_server_request = 1;
2624 bool has_unmasking_server_request() const;
2625 private:
2626 bool _internal_has_unmasking_server_request() const;
2627 public:
2628 void clear_unmasking_server_request();
2629 const ::fcp::secagg::UnmaskingRequest& unmasking_server_request() const;
2630 PROTOBUF_NODISCARD ::fcp::secagg::UnmaskingRequest* release_unmasking_server_request();
2631 ::fcp::secagg::UnmaskingRequest* mutable_unmasking_server_request();
2632 void set_allocated_unmasking_server_request(::fcp::secagg::UnmaskingRequest* unmasking_server_request);
2633 private:
2634 const ::fcp::secagg::UnmaskingRequest& _internal_unmasking_server_request() const;
2635 ::fcp::secagg::UnmaskingRequest* _internal_mutable_unmasking_server_request();
2636 public:
2637 void unsafe_arena_set_allocated_unmasking_server_request(
2638 ::fcp::secagg::UnmaskingRequest* unmasking_server_request);
2639 ::fcp::secagg::UnmaskingRequest* unsafe_arena_release_unmasking_server_request();
2640
2641 // @@protoc_insertion_point(class_scope:google.internal.federatedcompute.v1.SubmitSecureAggregationResultResponse)
2642 private:
2643 class _Internal;
2644
2645 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2646 typedef void InternalArenaConstructable_;
2647 typedef void DestructorSkippable_;
2648 struct Impl_ {
2649 ::fcp::secagg::UnmaskingRequest* unmasking_server_request_;
2650 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2651 };
2652 union { Impl_ _impl_; };
2653 friend struct ::TableStruct_fcp_2fprotos_2ffederatedcompute_2fsecure_5faggregations_2eproto;
2654 };
2655 // -------------------------------------------------------------------
2656
2657 class UnmaskRequest final :
2658 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federatedcompute.v1.UnmaskRequest) */ {
2659 public:
UnmaskRequest()2660 inline UnmaskRequest() : UnmaskRequest(nullptr) {}
2661 ~UnmaskRequest() override;
2662 explicit PROTOBUF_CONSTEXPR UnmaskRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2663
2664 UnmaskRequest(const UnmaskRequest& from);
UnmaskRequest(UnmaskRequest && from)2665 UnmaskRequest(UnmaskRequest&& from) noexcept
2666 : UnmaskRequest() {
2667 *this = ::std::move(from);
2668 }
2669
2670 inline UnmaskRequest& operator=(const UnmaskRequest& from) {
2671 if (this == &from) return *this;
2672 CopyFrom(from);
2673 return *this;
2674 }
2675 inline UnmaskRequest& operator=(UnmaskRequest&& from) noexcept {
2676 if (this == &from) return *this;
2677 if (GetOwningArena() == from.GetOwningArena()
2678 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2679 && GetOwningArena() != nullptr
2680 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2681 ) {
2682 InternalSwap(&from);
2683 } else {
2684 CopyFrom(from);
2685 }
2686 return *this;
2687 }
2688
default_instance()2689 static const UnmaskRequest& default_instance() {
2690 return *internal_default_instance();
2691 }
internal_default_instance()2692 static inline const UnmaskRequest* internal_default_instance() {
2693 return reinterpret_cast<const UnmaskRequest*>(
2694 &_UnmaskRequest_default_instance_);
2695 }
2696 static constexpr int kIndexInFileMessages =
2697 17;
2698
swap(UnmaskRequest & a,UnmaskRequest & b)2699 friend void swap(UnmaskRequest& a, UnmaskRequest& b) {
2700 a.Swap(&b);
2701 }
Swap(UnmaskRequest * other)2702 inline void Swap(UnmaskRequest* other) {
2703 if (other == this) return;
2704 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2705 if (GetOwningArena() != nullptr &&
2706 GetOwningArena() == other->GetOwningArena()) {
2707 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2708 if (GetOwningArena() == other->GetOwningArena()) {
2709 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2710 InternalSwap(other);
2711 } else {
2712 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2713 }
2714 }
2715 void UnsafeArenaSwap(UnmaskRequest* other) {
2716 if (other == this) return;
2717 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2718 InternalSwap(other);
2719 }
2720
2721 // implements Message ----------------------------------------------
2722
2723 UnmaskRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2724 return CreateMaybeMessage<UnmaskRequest>(arena);
2725 }
2726 UnmaskRequest* New() const {
2727 return New(nullptr);
2728 }
2729 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2730 void CopyFrom(const UnmaskRequest& from);
2731 void MergeFrom(const UnmaskRequest& from);
2732 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2733 bool IsInitialized() const final;
2734
2735 size_t ByteSizeLong() const final;
2736 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2737 ::uint8_t* _InternalSerialize(
2738 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2739 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2740
2741 private:
2742 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2743 void SharedDtor();
2744 void SetCachedSize(int size) const;
2745 void InternalSwap(UnmaskRequest* other);
2746
2747 private:
2748 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2749 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2750 return "google.internal.federatedcompute.v1.UnmaskRequest";
2751 }
2752 protected:
2753 explicit UnmaskRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2754 bool is_message_owned = false);
2755 public:
2756
2757 std::string GetTypeName() const final;
2758
2759 // nested types ----------------------------------------------------
2760
2761 // accessors -------------------------------------------------------
2762
2763 enum : int {
2764 kAggregationIdFieldNumber = 1,
2765 kClientTokenFieldNumber = 2,
2766 kUnmaskingClientResponseFieldNumber = 3,
2767 };
2768 // string aggregation_id = 1;
2769 void clear_aggregation_id();
2770 const std::string& aggregation_id() const;
2771 template <typename ArgT0 = const std::string&, typename... ArgT>
2772 void set_aggregation_id(ArgT0&& arg0, ArgT... args);
2773 std::string* mutable_aggregation_id();
2774 PROTOBUF_NODISCARD std::string* release_aggregation_id();
2775 void set_allocated_aggregation_id(std::string* aggregation_id);
2776 private:
2777 const std::string& _internal_aggregation_id() const;
2778 inline PROTOBUF_ALWAYS_INLINE void _internal_set_aggregation_id(const std::string& value);
2779 std::string* _internal_mutable_aggregation_id();
2780 public:
2781
2782 // string client_token = 2;
2783 void clear_client_token();
2784 const std::string& client_token() const;
2785 template <typename ArgT0 = const std::string&, typename... ArgT>
2786 void set_client_token(ArgT0&& arg0, ArgT... args);
2787 std::string* mutable_client_token();
2788 PROTOBUF_NODISCARD std::string* release_client_token();
2789 void set_allocated_client_token(std::string* client_token);
2790 private:
2791 const std::string& _internal_client_token() const;
2792 inline PROTOBUF_ALWAYS_INLINE void _internal_set_client_token(const std::string& value);
2793 std::string* _internal_mutable_client_token();
2794 public:
2795
2796 // .fcp.secagg.UnmaskingResponse unmasking_client_response = 3;
2797 bool has_unmasking_client_response() const;
2798 private:
2799 bool _internal_has_unmasking_client_response() const;
2800 public:
2801 void clear_unmasking_client_response();
2802 const ::fcp::secagg::UnmaskingResponse& unmasking_client_response() const;
2803 PROTOBUF_NODISCARD ::fcp::secagg::UnmaskingResponse* release_unmasking_client_response();
2804 ::fcp::secagg::UnmaskingResponse* mutable_unmasking_client_response();
2805 void set_allocated_unmasking_client_response(::fcp::secagg::UnmaskingResponse* unmasking_client_response);
2806 private:
2807 const ::fcp::secagg::UnmaskingResponse& _internal_unmasking_client_response() const;
2808 ::fcp::secagg::UnmaskingResponse* _internal_mutable_unmasking_client_response();
2809 public:
2810 void unsafe_arena_set_allocated_unmasking_client_response(
2811 ::fcp::secagg::UnmaskingResponse* unmasking_client_response);
2812 ::fcp::secagg::UnmaskingResponse* unsafe_arena_release_unmasking_client_response();
2813
2814 // @@protoc_insertion_point(class_scope:google.internal.federatedcompute.v1.UnmaskRequest)
2815 private:
2816 class _Internal;
2817
2818 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2819 typedef void InternalArenaConstructable_;
2820 typedef void DestructorSkippable_;
2821 struct Impl_ {
2822 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr aggregation_id_;
2823 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr client_token_;
2824 ::fcp::secagg::UnmaskingResponse* unmasking_client_response_;
2825 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2826 };
2827 union { Impl_ _impl_; };
2828 friend struct ::TableStruct_fcp_2fprotos_2ffederatedcompute_2fsecure_5faggregations_2eproto;
2829 };
2830 // -------------------------------------------------------------------
2831
2832 class UnmaskResponse final :
2833 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federatedcompute.v1.UnmaskResponse) */ {
2834 public:
UnmaskResponse()2835 inline UnmaskResponse() : UnmaskResponse(nullptr) {}
2836 ~UnmaskResponse() override;
2837 explicit PROTOBUF_CONSTEXPR UnmaskResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2838
2839 UnmaskResponse(const UnmaskResponse& from);
UnmaskResponse(UnmaskResponse && from)2840 UnmaskResponse(UnmaskResponse&& from) noexcept
2841 : UnmaskResponse() {
2842 *this = ::std::move(from);
2843 }
2844
2845 inline UnmaskResponse& operator=(const UnmaskResponse& from) {
2846 if (this == &from) return *this;
2847 CopyFrom(from);
2848 return *this;
2849 }
2850 inline UnmaskResponse& operator=(UnmaskResponse&& from) noexcept {
2851 if (this == &from) return *this;
2852 if (GetOwningArena() == from.GetOwningArena()
2853 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2854 && GetOwningArena() != nullptr
2855 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2856 ) {
2857 InternalSwap(&from);
2858 } else {
2859 CopyFrom(from);
2860 }
2861 return *this;
2862 }
2863
default_instance()2864 static const UnmaskResponse& default_instance() {
2865 return *internal_default_instance();
2866 }
internal_default_instance()2867 static inline const UnmaskResponse* internal_default_instance() {
2868 return reinterpret_cast<const UnmaskResponse*>(
2869 &_UnmaskResponse_default_instance_);
2870 }
2871 static constexpr int kIndexInFileMessages =
2872 18;
2873
swap(UnmaskResponse & a,UnmaskResponse & b)2874 friend void swap(UnmaskResponse& a, UnmaskResponse& b) {
2875 a.Swap(&b);
2876 }
Swap(UnmaskResponse * other)2877 inline void Swap(UnmaskResponse* other) {
2878 if (other == this) return;
2879 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2880 if (GetOwningArena() != nullptr &&
2881 GetOwningArena() == other->GetOwningArena()) {
2882 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2883 if (GetOwningArena() == other->GetOwningArena()) {
2884 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2885 InternalSwap(other);
2886 } else {
2887 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2888 }
2889 }
2890 void UnsafeArenaSwap(UnmaskResponse* other) {
2891 if (other == this) return;
2892 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2893 InternalSwap(other);
2894 }
2895
2896 // implements Message ----------------------------------------------
2897
2898 UnmaskResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2899 return CreateMaybeMessage<UnmaskResponse>(arena);
2900 }
2901 UnmaskResponse* New() const {
2902 return New(nullptr);
2903 }
2904 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2905 void CopyFrom(const UnmaskResponse& from);
2906 void MergeFrom(const UnmaskResponse& from);
2907 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2908 bool IsInitialized() const final;
2909
2910 size_t ByteSizeLong() const final;
2911 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2912 ::uint8_t* _InternalSerialize(
2913 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2914 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2915
2916 private:
2917 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2918 void SharedDtor();
2919 void SetCachedSize(int size) const;
2920 void InternalSwap(UnmaskResponse* other);
2921
2922 private:
2923 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2924 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2925 return "google.internal.federatedcompute.v1.UnmaskResponse";
2926 }
2927 protected:
2928 explicit UnmaskResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2929 bool is_message_owned = false);
2930 public:
2931
2932 std::string GetTypeName() const final;
2933
2934 // nested types ----------------------------------------------------
2935
2936 // accessors -------------------------------------------------------
2937
2938 // @@protoc_insertion_point(class_scope:google.internal.federatedcompute.v1.UnmaskResponse)
2939 private:
2940 class _Internal;
2941
2942 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2943 typedef void InternalArenaConstructable_;
2944 typedef void DestructorSkippable_;
2945 struct Impl_ {
2946 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2947 };
2948 union { Impl_ _impl_; };
2949 friend struct ::TableStruct_fcp_2fprotos_2ffederatedcompute_2fsecure_5faggregations_2eproto;
2950 };
2951 // ===================================================================
2952
2953
2954 // ===================================================================
2955
2956 #ifdef __GNUC__
2957 #pragma GCC diagnostic push
2958 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
2959 #endif // __GNUC__
2960 // StartSecureAggregationRequest
2961
2962 // string aggregation_id = 1;
clear_aggregation_id()2963 inline void StartSecureAggregationRequest::clear_aggregation_id() {
2964 _impl_.aggregation_id_.ClearToEmpty();
2965 }
aggregation_id()2966 inline const std::string& StartSecureAggregationRequest::aggregation_id() const {
2967 // @@protoc_insertion_point(field_get:google.internal.federatedcompute.v1.StartSecureAggregationRequest.aggregation_id)
2968 return _internal_aggregation_id();
2969 }
2970 template <typename ArgT0, typename... ArgT>
2971 inline PROTOBUF_ALWAYS_INLINE
set_aggregation_id(ArgT0 && arg0,ArgT...args)2972 void StartSecureAggregationRequest::set_aggregation_id(ArgT0&& arg0, ArgT... args) {
2973
2974 _impl_.aggregation_id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2975 // @@protoc_insertion_point(field_set:google.internal.federatedcompute.v1.StartSecureAggregationRequest.aggregation_id)
2976 }
mutable_aggregation_id()2977 inline std::string* StartSecureAggregationRequest::mutable_aggregation_id() {
2978 std::string* _s = _internal_mutable_aggregation_id();
2979 // @@protoc_insertion_point(field_mutable:google.internal.federatedcompute.v1.StartSecureAggregationRequest.aggregation_id)
2980 return _s;
2981 }
_internal_aggregation_id()2982 inline const std::string& StartSecureAggregationRequest::_internal_aggregation_id() const {
2983 return _impl_.aggregation_id_.Get();
2984 }
_internal_set_aggregation_id(const std::string & value)2985 inline void StartSecureAggregationRequest::_internal_set_aggregation_id(const std::string& value) {
2986
2987 _impl_.aggregation_id_.Set(value, GetArenaForAllocation());
2988 }
_internal_mutable_aggregation_id()2989 inline std::string* StartSecureAggregationRequest::_internal_mutable_aggregation_id() {
2990
2991 return _impl_.aggregation_id_.Mutable(GetArenaForAllocation());
2992 }
release_aggregation_id()2993 inline std::string* StartSecureAggregationRequest::release_aggregation_id() {
2994 // @@protoc_insertion_point(field_release:google.internal.federatedcompute.v1.StartSecureAggregationRequest.aggregation_id)
2995 return _impl_.aggregation_id_.Release();
2996 }
set_allocated_aggregation_id(std::string * aggregation_id)2997 inline void StartSecureAggregationRequest::set_allocated_aggregation_id(std::string* aggregation_id) {
2998 _impl_.aggregation_id_.SetAllocated(aggregation_id, GetArenaForAllocation());
2999 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3000 if (_impl_.aggregation_id_.IsDefault()) {
3001 _impl_.aggregation_id_.Set("", GetArenaForAllocation());
3002 }
3003 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3004 // @@protoc_insertion_point(field_set_allocated:google.internal.federatedcompute.v1.StartSecureAggregationRequest.aggregation_id)
3005 }
3006
3007 // string authorization_token = 2;
clear_authorization_token()3008 inline void StartSecureAggregationRequest::clear_authorization_token() {
3009 _impl_.authorization_token_.ClearToEmpty();
3010 }
authorization_token()3011 inline const std::string& StartSecureAggregationRequest::authorization_token() const {
3012 // @@protoc_insertion_point(field_get:google.internal.federatedcompute.v1.StartSecureAggregationRequest.authorization_token)
3013 return _internal_authorization_token();
3014 }
3015 template <typename ArgT0, typename... ArgT>
3016 inline PROTOBUF_ALWAYS_INLINE
set_authorization_token(ArgT0 && arg0,ArgT...args)3017 void StartSecureAggregationRequest::set_authorization_token(ArgT0&& arg0, ArgT... args) {
3018
3019 _impl_.authorization_token_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3020 // @@protoc_insertion_point(field_set:google.internal.federatedcompute.v1.StartSecureAggregationRequest.authorization_token)
3021 }
mutable_authorization_token()3022 inline std::string* StartSecureAggregationRequest::mutable_authorization_token() {
3023 std::string* _s = _internal_mutable_authorization_token();
3024 // @@protoc_insertion_point(field_mutable:google.internal.federatedcompute.v1.StartSecureAggregationRequest.authorization_token)
3025 return _s;
3026 }
_internal_authorization_token()3027 inline const std::string& StartSecureAggregationRequest::_internal_authorization_token() const {
3028 return _impl_.authorization_token_.Get();
3029 }
_internal_set_authorization_token(const std::string & value)3030 inline void StartSecureAggregationRequest::_internal_set_authorization_token(const std::string& value) {
3031
3032 _impl_.authorization_token_.Set(value, GetArenaForAllocation());
3033 }
_internal_mutable_authorization_token()3034 inline std::string* StartSecureAggregationRequest::_internal_mutable_authorization_token() {
3035
3036 return _impl_.authorization_token_.Mutable(GetArenaForAllocation());
3037 }
release_authorization_token()3038 inline std::string* StartSecureAggregationRequest::release_authorization_token() {
3039 // @@protoc_insertion_point(field_release:google.internal.federatedcompute.v1.StartSecureAggregationRequest.authorization_token)
3040 return _impl_.authorization_token_.Release();
3041 }
set_allocated_authorization_token(std::string * authorization_token)3042 inline void StartSecureAggregationRequest::set_allocated_authorization_token(std::string* authorization_token) {
3043 _impl_.authorization_token_.SetAllocated(authorization_token, GetArenaForAllocation());
3044 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3045 if (_impl_.authorization_token_.IsDefault()) {
3046 _impl_.authorization_token_.Set("", GetArenaForAllocation());
3047 }
3048 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3049 // @@protoc_insertion_point(field_set_allocated:google.internal.federatedcompute.v1.StartSecureAggregationRequest.authorization_token)
3050 }
3051
3052 // -------------------------------------------------------------------
3053
3054 // StartSecureAggregationMetadata
3055
3056 // -------------------------------------------------------------------
3057
3058 // -------------------------------------------------------------------
3059
3060 // StartSecureAggregationResponse
3061
3062 // .google.internal.federatedcompute.v1.ForwardingInfo secagg_protocol_forwarding_info = 1;
_internal_has_secagg_protocol_forwarding_info()3063 inline bool StartSecureAggregationResponse::_internal_has_secagg_protocol_forwarding_info() const {
3064 return this != internal_default_instance() && _impl_.secagg_protocol_forwarding_info_ != nullptr;
3065 }
has_secagg_protocol_forwarding_info()3066 inline bool StartSecureAggregationResponse::has_secagg_protocol_forwarding_info() const {
3067 return _internal_has_secagg_protocol_forwarding_info();
3068 }
_internal_secagg_protocol_forwarding_info()3069 inline const ::google::internal::federatedcompute::v1::ForwardingInfo& StartSecureAggregationResponse::_internal_secagg_protocol_forwarding_info() const {
3070 const ::google::internal::federatedcompute::v1::ForwardingInfo* p = _impl_.secagg_protocol_forwarding_info_;
3071 return p != nullptr ? *p : reinterpret_cast<const ::google::internal::federatedcompute::v1::ForwardingInfo&>(
3072 ::google::internal::federatedcompute::v1::_ForwardingInfo_default_instance_);
3073 }
secagg_protocol_forwarding_info()3074 inline const ::google::internal::federatedcompute::v1::ForwardingInfo& StartSecureAggregationResponse::secagg_protocol_forwarding_info() const {
3075 // @@protoc_insertion_point(field_get:google.internal.federatedcompute.v1.StartSecureAggregationResponse.secagg_protocol_forwarding_info)
3076 return _internal_secagg_protocol_forwarding_info();
3077 }
unsafe_arena_set_allocated_secagg_protocol_forwarding_info(::google::internal::federatedcompute::v1::ForwardingInfo * secagg_protocol_forwarding_info)3078 inline void StartSecureAggregationResponse::unsafe_arena_set_allocated_secagg_protocol_forwarding_info(
3079 ::google::internal::federatedcompute::v1::ForwardingInfo* secagg_protocol_forwarding_info) {
3080 if (GetArenaForAllocation() == nullptr) {
3081 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.secagg_protocol_forwarding_info_);
3082 }
3083 _impl_.secagg_protocol_forwarding_info_ = secagg_protocol_forwarding_info;
3084 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federatedcompute.v1.StartSecureAggregationResponse.secagg_protocol_forwarding_info)
3085 }
release_secagg_protocol_forwarding_info()3086 inline ::google::internal::federatedcompute::v1::ForwardingInfo* StartSecureAggregationResponse::release_secagg_protocol_forwarding_info() {
3087
3088 ::google::internal::federatedcompute::v1::ForwardingInfo* temp = _impl_.secagg_protocol_forwarding_info_;
3089 _impl_.secagg_protocol_forwarding_info_ = nullptr;
3090 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
3091 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
3092 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3093 if (GetArenaForAllocation() == nullptr) { delete old; }
3094 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
3095 if (GetArenaForAllocation() != nullptr) {
3096 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3097 }
3098 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
3099 return temp;
3100 }
unsafe_arena_release_secagg_protocol_forwarding_info()3101 inline ::google::internal::federatedcompute::v1::ForwardingInfo* StartSecureAggregationResponse::unsafe_arena_release_secagg_protocol_forwarding_info() {
3102 // @@protoc_insertion_point(field_release:google.internal.federatedcompute.v1.StartSecureAggregationResponse.secagg_protocol_forwarding_info)
3103
3104 ::google::internal::federatedcompute::v1::ForwardingInfo* temp = _impl_.secagg_protocol_forwarding_info_;
3105 _impl_.secagg_protocol_forwarding_info_ = nullptr;
3106 return temp;
3107 }
_internal_mutable_secagg_protocol_forwarding_info()3108 inline ::google::internal::federatedcompute::v1::ForwardingInfo* StartSecureAggregationResponse::_internal_mutable_secagg_protocol_forwarding_info() {
3109
3110 if (_impl_.secagg_protocol_forwarding_info_ == nullptr) {
3111 auto* p = CreateMaybeMessage<::google::internal::federatedcompute::v1::ForwardingInfo>(GetArenaForAllocation());
3112 _impl_.secagg_protocol_forwarding_info_ = p;
3113 }
3114 return _impl_.secagg_protocol_forwarding_info_;
3115 }
mutable_secagg_protocol_forwarding_info()3116 inline ::google::internal::federatedcompute::v1::ForwardingInfo* StartSecureAggregationResponse::mutable_secagg_protocol_forwarding_info() {
3117 ::google::internal::federatedcompute::v1::ForwardingInfo* _msg = _internal_mutable_secagg_protocol_forwarding_info();
3118 // @@protoc_insertion_point(field_mutable:google.internal.federatedcompute.v1.StartSecureAggregationResponse.secagg_protocol_forwarding_info)
3119 return _msg;
3120 }
set_allocated_secagg_protocol_forwarding_info(::google::internal::federatedcompute::v1::ForwardingInfo * secagg_protocol_forwarding_info)3121 inline void StartSecureAggregationResponse::set_allocated_secagg_protocol_forwarding_info(::google::internal::federatedcompute::v1::ForwardingInfo* secagg_protocol_forwarding_info) {
3122 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
3123 if (message_arena == nullptr) {
3124 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.secagg_protocol_forwarding_info_);
3125 }
3126 if (secagg_protocol_forwarding_info) {
3127 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
3128 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
3129 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(secagg_protocol_forwarding_info));
3130 if (message_arena != submessage_arena) {
3131 secagg_protocol_forwarding_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
3132 message_arena, secagg_protocol_forwarding_info, submessage_arena);
3133 }
3134
3135 } else {
3136
3137 }
3138 _impl_.secagg_protocol_forwarding_info_ = secagg_protocol_forwarding_info;
3139 // @@protoc_insertion_point(field_set_allocated:google.internal.federatedcompute.v1.StartSecureAggregationResponse.secagg_protocol_forwarding_info)
3140 }
3141
3142 // map<string, .google.internal.federatedcompute.v1.SecureAggregandExecutionInfo> secure_aggregands = 2;
_internal_secure_aggregands_size()3143 inline int StartSecureAggregationResponse::_internal_secure_aggregands_size() const {
3144 return _impl_.secure_aggregands_.size();
3145 }
secure_aggregands_size()3146 inline int StartSecureAggregationResponse::secure_aggregands_size() const {
3147 return _internal_secure_aggregands_size();
3148 }
clear_secure_aggregands()3149 inline void StartSecureAggregationResponse::clear_secure_aggregands() {
3150 _impl_.secure_aggregands_.Clear();
3151 }
3152 inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federatedcompute::v1::SecureAggregandExecutionInfo >&
_internal_secure_aggregands()3153 StartSecureAggregationResponse::_internal_secure_aggregands() const {
3154 return _impl_.secure_aggregands_.GetMap();
3155 }
3156 inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federatedcompute::v1::SecureAggregandExecutionInfo >&
secure_aggregands()3157 StartSecureAggregationResponse::secure_aggregands() const {
3158 // @@protoc_insertion_point(field_map:google.internal.federatedcompute.v1.StartSecureAggregationResponse.secure_aggregands)
3159 return _internal_secure_aggregands();
3160 }
3161 inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federatedcompute::v1::SecureAggregandExecutionInfo >*
_internal_mutable_secure_aggregands()3162 StartSecureAggregationResponse::_internal_mutable_secure_aggregands() {
3163 return _impl_.secure_aggregands_.MutableMap();
3164 }
3165 inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federatedcompute::v1::SecureAggregandExecutionInfo >*
mutable_secure_aggregands()3166 StartSecureAggregationResponse::mutable_secure_aggregands() {
3167 // @@protoc_insertion_point(field_mutable_map:google.internal.federatedcompute.v1.StartSecureAggregationResponse.secure_aggregands)
3168 return _internal_mutable_secure_aggregands();
3169 }
3170
3171 // .google.internal.federatedcompute.v1.SecureAggregationProtocolExecutionInfo protocol_execution_info = 3;
_internal_has_protocol_execution_info()3172 inline bool StartSecureAggregationResponse::_internal_has_protocol_execution_info() const {
3173 return this != internal_default_instance() && _impl_.protocol_execution_info_ != nullptr;
3174 }
has_protocol_execution_info()3175 inline bool StartSecureAggregationResponse::has_protocol_execution_info() const {
3176 return _internal_has_protocol_execution_info();
3177 }
clear_protocol_execution_info()3178 inline void StartSecureAggregationResponse::clear_protocol_execution_info() {
3179 if (GetArenaForAllocation() == nullptr && _impl_.protocol_execution_info_ != nullptr) {
3180 delete _impl_.protocol_execution_info_;
3181 }
3182 _impl_.protocol_execution_info_ = nullptr;
3183 }
_internal_protocol_execution_info()3184 inline const ::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo& StartSecureAggregationResponse::_internal_protocol_execution_info() const {
3185 const ::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo* p = _impl_.protocol_execution_info_;
3186 return p != nullptr ? *p : reinterpret_cast<const ::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo&>(
3187 ::google::internal::federatedcompute::v1::_SecureAggregationProtocolExecutionInfo_default_instance_);
3188 }
protocol_execution_info()3189 inline const ::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo& StartSecureAggregationResponse::protocol_execution_info() const {
3190 // @@protoc_insertion_point(field_get:google.internal.federatedcompute.v1.StartSecureAggregationResponse.protocol_execution_info)
3191 return _internal_protocol_execution_info();
3192 }
unsafe_arena_set_allocated_protocol_execution_info(::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo * protocol_execution_info)3193 inline void StartSecureAggregationResponse::unsafe_arena_set_allocated_protocol_execution_info(
3194 ::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo* protocol_execution_info) {
3195 if (GetArenaForAllocation() == nullptr) {
3196 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.protocol_execution_info_);
3197 }
3198 _impl_.protocol_execution_info_ = protocol_execution_info;
3199 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federatedcompute.v1.StartSecureAggregationResponse.protocol_execution_info)
3200 }
release_protocol_execution_info()3201 inline ::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo* StartSecureAggregationResponse::release_protocol_execution_info() {
3202
3203 ::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo* temp = _impl_.protocol_execution_info_;
3204 _impl_.protocol_execution_info_ = nullptr;
3205 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
3206 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
3207 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3208 if (GetArenaForAllocation() == nullptr) { delete old; }
3209 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
3210 if (GetArenaForAllocation() != nullptr) {
3211 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3212 }
3213 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
3214 return temp;
3215 }
unsafe_arena_release_protocol_execution_info()3216 inline ::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo* StartSecureAggregationResponse::unsafe_arena_release_protocol_execution_info() {
3217 // @@protoc_insertion_point(field_release:google.internal.federatedcompute.v1.StartSecureAggregationResponse.protocol_execution_info)
3218
3219 ::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo* temp = _impl_.protocol_execution_info_;
3220 _impl_.protocol_execution_info_ = nullptr;
3221 return temp;
3222 }
_internal_mutable_protocol_execution_info()3223 inline ::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo* StartSecureAggregationResponse::_internal_mutable_protocol_execution_info() {
3224
3225 if (_impl_.protocol_execution_info_ == nullptr) {
3226 auto* p = CreateMaybeMessage<::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo>(GetArenaForAllocation());
3227 _impl_.protocol_execution_info_ = p;
3228 }
3229 return _impl_.protocol_execution_info_;
3230 }
mutable_protocol_execution_info()3231 inline ::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo* StartSecureAggregationResponse::mutable_protocol_execution_info() {
3232 ::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo* _msg = _internal_mutable_protocol_execution_info();
3233 // @@protoc_insertion_point(field_mutable:google.internal.federatedcompute.v1.StartSecureAggregationResponse.protocol_execution_info)
3234 return _msg;
3235 }
set_allocated_protocol_execution_info(::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo * protocol_execution_info)3236 inline void StartSecureAggregationResponse::set_allocated_protocol_execution_info(::google::internal::federatedcompute::v1::SecureAggregationProtocolExecutionInfo* protocol_execution_info) {
3237 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
3238 if (message_arena == nullptr) {
3239 delete _impl_.protocol_execution_info_;
3240 }
3241 if (protocol_execution_info) {
3242 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
3243 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(protocol_execution_info);
3244 if (message_arena != submessage_arena) {
3245 protocol_execution_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
3246 message_arena, protocol_execution_info, submessage_arena);
3247 }
3248
3249 } else {
3250
3251 }
3252 _impl_.protocol_execution_info_ = protocol_execution_info;
3253 // @@protoc_insertion_point(field_set_allocated:google.internal.federatedcompute.v1.StartSecureAggregationResponse.protocol_execution_info)
3254 }
3255
3256 // .google.internal.federatedcompute.v1.ByteStreamResource masked_result_resource = 4;
_internal_has_masked_result_resource()3257 inline bool StartSecureAggregationResponse::_internal_has_masked_result_resource() const {
3258 return this != internal_default_instance() && _impl_.masked_result_resource_ != nullptr;
3259 }
has_masked_result_resource()3260 inline bool StartSecureAggregationResponse::has_masked_result_resource() const {
3261 return _internal_has_masked_result_resource();
3262 }
_internal_masked_result_resource()3263 inline const ::google::internal::federatedcompute::v1::ByteStreamResource& StartSecureAggregationResponse::_internal_masked_result_resource() const {
3264 const ::google::internal::federatedcompute::v1::ByteStreamResource* p = _impl_.masked_result_resource_;
3265 return p != nullptr ? *p : reinterpret_cast<const ::google::internal::federatedcompute::v1::ByteStreamResource&>(
3266 ::google::internal::federatedcompute::v1::_ByteStreamResource_default_instance_);
3267 }
masked_result_resource()3268 inline const ::google::internal::federatedcompute::v1::ByteStreamResource& StartSecureAggregationResponse::masked_result_resource() const {
3269 // @@protoc_insertion_point(field_get:google.internal.federatedcompute.v1.StartSecureAggregationResponse.masked_result_resource)
3270 return _internal_masked_result_resource();
3271 }
unsafe_arena_set_allocated_masked_result_resource(::google::internal::federatedcompute::v1::ByteStreamResource * masked_result_resource)3272 inline void StartSecureAggregationResponse::unsafe_arena_set_allocated_masked_result_resource(
3273 ::google::internal::federatedcompute::v1::ByteStreamResource* masked_result_resource) {
3274 if (GetArenaForAllocation() == nullptr) {
3275 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.masked_result_resource_);
3276 }
3277 _impl_.masked_result_resource_ = masked_result_resource;
3278 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federatedcompute.v1.StartSecureAggregationResponse.masked_result_resource)
3279 }
release_masked_result_resource()3280 inline ::google::internal::federatedcompute::v1::ByteStreamResource* StartSecureAggregationResponse::release_masked_result_resource() {
3281
3282 ::google::internal::federatedcompute::v1::ByteStreamResource* temp = _impl_.masked_result_resource_;
3283 _impl_.masked_result_resource_ = nullptr;
3284 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
3285 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
3286 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3287 if (GetArenaForAllocation() == nullptr) { delete old; }
3288 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
3289 if (GetArenaForAllocation() != nullptr) {
3290 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3291 }
3292 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
3293 return temp;
3294 }
unsafe_arena_release_masked_result_resource()3295 inline ::google::internal::federatedcompute::v1::ByteStreamResource* StartSecureAggregationResponse::unsafe_arena_release_masked_result_resource() {
3296 // @@protoc_insertion_point(field_release:google.internal.federatedcompute.v1.StartSecureAggregationResponse.masked_result_resource)
3297
3298 ::google::internal::federatedcompute::v1::ByteStreamResource* temp = _impl_.masked_result_resource_;
3299 _impl_.masked_result_resource_ = nullptr;
3300 return temp;
3301 }
_internal_mutable_masked_result_resource()3302 inline ::google::internal::federatedcompute::v1::ByteStreamResource* StartSecureAggregationResponse::_internal_mutable_masked_result_resource() {
3303
3304 if (_impl_.masked_result_resource_ == nullptr) {
3305 auto* p = CreateMaybeMessage<::google::internal::federatedcompute::v1::ByteStreamResource>(GetArenaForAllocation());
3306 _impl_.masked_result_resource_ = p;
3307 }
3308 return _impl_.masked_result_resource_;
3309 }
mutable_masked_result_resource()3310 inline ::google::internal::federatedcompute::v1::ByteStreamResource* StartSecureAggregationResponse::mutable_masked_result_resource() {
3311 ::google::internal::federatedcompute::v1::ByteStreamResource* _msg = _internal_mutable_masked_result_resource();
3312 // @@protoc_insertion_point(field_mutable:google.internal.federatedcompute.v1.StartSecureAggregationResponse.masked_result_resource)
3313 return _msg;
3314 }
set_allocated_masked_result_resource(::google::internal::federatedcompute::v1::ByteStreamResource * masked_result_resource)3315 inline void StartSecureAggregationResponse::set_allocated_masked_result_resource(::google::internal::federatedcompute::v1::ByteStreamResource* masked_result_resource) {
3316 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
3317 if (message_arena == nullptr) {
3318 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.masked_result_resource_);
3319 }
3320 if (masked_result_resource) {
3321 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
3322 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
3323 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(masked_result_resource));
3324 if (message_arena != submessage_arena) {
3325 masked_result_resource = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
3326 message_arena, masked_result_resource, submessage_arena);
3327 }
3328
3329 } else {
3330
3331 }
3332 _impl_.masked_result_resource_ = masked_result_resource;
3333 // @@protoc_insertion_point(field_set_allocated:google.internal.federatedcompute.v1.StartSecureAggregationResponse.masked_result_resource)
3334 }
3335
3336 // .google.internal.federatedcompute.v1.ByteStreamResource nonmasked_result_resource = 5;
_internal_has_nonmasked_result_resource()3337 inline bool StartSecureAggregationResponse::_internal_has_nonmasked_result_resource() const {
3338 return this != internal_default_instance() && _impl_.nonmasked_result_resource_ != nullptr;
3339 }
has_nonmasked_result_resource()3340 inline bool StartSecureAggregationResponse::has_nonmasked_result_resource() const {
3341 return _internal_has_nonmasked_result_resource();
3342 }
_internal_nonmasked_result_resource()3343 inline const ::google::internal::federatedcompute::v1::ByteStreamResource& StartSecureAggregationResponse::_internal_nonmasked_result_resource() const {
3344 const ::google::internal::federatedcompute::v1::ByteStreamResource* p = _impl_.nonmasked_result_resource_;
3345 return p != nullptr ? *p : reinterpret_cast<const ::google::internal::federatedcompute::v1::ByteStreamResource&>(
3346 ::google::internal::federatedcompute::v1::_ByteStreamResource_default_instance_);
3347 }
nonmasked_result_resource()3348 inline const ::google::internal::federatedcompute::v1::ByteStreamResource& StartSecureAggregationResponse::nonmasked_result_resource() const {
3349 // @@protoc_insertion_point(field_get:google.internal.federatedcompute.v1.StartSecureAggregationResponse.nonmasked_result_resource)
3350 return _internal_nonmasked_result_resource();
3351 }
unsafe_arena_set_allocated_nonmasked_result_resource(::google::internal::federatedcompute::v1::ByteStreamResource * nonmasked_result_resource)3352 inline void StartSecureAggregationResponse::unsafe_arena_set_allocated_nonmasked_result_resource(
3353 ::google::internal::federatedcompute::v1::ByteStreamResource* nonmasked_result_resource) {
3354 if (GetArenaForAllocation() == nullptr) {
3355 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.nonmasked_result_resource_);
3356 }
3357 _impl_.nonmasked_result_resource_ = nonmasked_result_resource;
3358 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federatedcompute.v1.StartSecureAggregationResponse.nonmasked_result_resource)
3359 }
release_nonmasked_result_resource()3360 inline ::google::internal::federatedcompute::v1::ByteStreamResource* StartSecureAggregationResponse::release_nonmasked_result_resource() {
3361
3362 ::google::internal::federatedcompute::v1::ByteStreamResource* temp = _impl_.nonmasked_result_resource_;
3363 _impl_.nonmasked_result_resource_ = nullptr;
3364 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
3365 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
3366 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3367 if (GetArenaForAllocation() == nullptr) { delete old; }
3368 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
3369 if (GetArenaForAllocation() != nullptr) {
3370 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3371 }
3372 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
3373 return temp;
3374 }
unsafe_arena_release_nonmasked_result_resource()3375 inline ::google::internal::federatedcompute::v1::ByteStreamResource* StartSecureAggregationResponse::unsafe_arena_release_nonmasked_result_resource() {
3376 // @@protoc_insertion_point(field_release:google.internal.federatedcompute.v1.StartSecureAggregationResponse.nonmasked_result_resource)
3377
3378 ::google::internal::federatedcompute::v1::ByteStreamResource* temp = _impl_.nonmasked_result_resource_;
3379 _impl_.nonmasked_result_resource_ = nullptr;
3380 return temp;
3381 }
_internal_mutable_nonmasked_result_resource()3382 inline ::google::internal::federatedcompute::v1::ByteStreamResource* StartSecureAggregationResponse::_internal_mutable_nonmasked_result_resource() {
3383
3384 if (_impl_.nonmasked_result_resource_ == nullptr) {
3385 auto* p = CreateMaybeMessage<::google::internal::federatedcompute::v1::ByteStreamResource>(GetArenaForAllocation());
3386 _impl_.nonmasked_result_resource_ = p;
3387 }
3388 return _impl_.nonmasked_result_resource_;
3389 }
mutable_nonmasked_result_resource()3390 inline ::google::internal::federatedcompute::v1::ByteStreamResource* StartSecureAggregationResponse::mutable_nonmasked_result_resource() {
3391 ::google::internal::federatedcompute::v1::ByteStreamResource* _msg = _internal_mutable_nonmasked_result_resource();
3392 // @@protoc_insertion_point(field_mutable:google.internal.federatedcompute.v1.StartSecureAggregationResponse.nonmasked_result_resource)
3393 return _msg;
3394 }
set_allocated_nonmasked_result_resource(::google::internal::federatedcompute::v1::ByteStreamResource * nonmasked_result_resource)3395 inline void StartSecureAggregationResponse::set_allocated_nonmasked_result_resource(::google::internal::federatedcompute::v1::ByteStreamResource* nonmasked_result_resource) {
3396 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
3397 if (message_arena == nullptr) {
3398 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.nonmasked_result_resource_);
3399 }
3400 if (nonmasked_result_resource) {
3401 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
3402 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
3403 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(nonmasked_result_resource));
3404 if (message_arena != submessage_arena) {
3405 nonmasked_result_resource = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
3406 message_arena, nonmasked_result_resource, submessage_arena);
3407 }
3408
3409 } else {
3410
3411 }
3412 _impl_.nonmasked_result_resource_ = nonmasked_result_resource;
3413 // @@protoc_insertion_point(field_set_allocated:google.internal.federatedcompute.v1.StartSecureAggregationResponse.nonmasked_result_resource)
3414 }
3415
3416 // string client_token = 6;
clear_client_token()3417 inline void StartSecureAggregationResponse::clear_client_token() {
3418 _impl_.client_token_.ClearToEmpty();
3419 }
client_token()3420 inline const std::string& StartSecureAggregationResponse::client_token() const {
3421 // @@protoc_insertion_point(field_get:google.internal.federatedcompute.v1.StartSecureAggregationResponse.client_token)
3422 return _internal_client_token();
3423 }
3424 template <typename ArgT0, typename... ArgT>
3425 inline PROTOBUF_ALWAYS_INLINE
set_client_token(ArgT0 && arg0,ArgT...args)3426 void StartSecureAggregationResponse::set_client_token(ArgT0&& arg0, ArgT... args) {
3427
3428 _impl_.client_token_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3429 // @@protoc_insertion_point(field_set:google.internal.federatedcompute.v1.StartSecureAggregationResponse.client_token)
3430 }
mutable_client_token()3431 inline std::string* StartSecureAggregationResponse::mutable_client_token() {
3432 std::string* _s = _internal_mutable_client_token();
3433 // @@protoc_insertion_point(field_mutable:google.internal.federatedcompute.v1.StartSecureAggregationResponse.client_token)
3434 return _s;
3435 }
_internal_client_token()3436 inline const std::string& StartSecureAggregationResponse::_internal_client_token() const {
3437 return _impl_.client_token_.Get();
3438 }
_internal_set_client_token(const std::string & value)3439 inline void StartSecureAggregationResponse::_internal_set_client_token(const std::string& value) {
3440
3441 _impl_.client_token_.Set(value, GetArenaForAllocation());
3442 }
_internal_mutable_client_token()3443 inline std::string* StartSecureAggregationResponse::_internal_mutable_client_token() {
3444
3445 return _impl_.client_token_.Mutable(GetArenaForAllocation());
3446 }
release_client_token()3447 inline std::string* StartSecureAggregationResponse::release_client_token() {
3448 // @@protoc_insertion_point(field_release:google.internal.federatedcompute.v1.StartSecureAggregationResponse.client_token)
3449 return _impl_.client_token_.Release();
3450 }
set_allocated_client_token(std::string * client_token)3451 inline void StartSecureAggregationResponse::set_allocated_client_token(std::string* client_token) {
3452 _impl_.client_token_.SetAllocated(client_token, GetArenaForAllocation());
3453 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3454 if (_impl_.client_token_.IsDefault()) {
3455 _impl_.client_token_.Set("", GetArenaForAllocation());
3456 }
3457 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3458 // @@protoc_insertion_point(field_set_allocated:google.internal.federatedcompute.v1.StartSecureAggregationResponse.client_token)
3459 }
3460
3461 // -------------------------------------------------------------------
3462
3463 // SecureAggregandExecutionInfo
3464
3465 // uint64 modulus = 1;
clear_modulus()3466 inline void SecureAggregandExecutionInfo::clear_modulus() {
3467 _impl_.modulus_ = ::uint64_t{0u};
3468 }
_internal_modulus()3469 inline ::uint64_t SecureAggregandExecutionInfo::_internal_modulus() const {
3470 return _impl_.modulus_;
3471 }
modulus()3472 inline ::uint64_t SecureAggregandExecutionInfo::modulus() const {
3473 // @@protoc_insertion_point(field_get:google.internal.federatedcompute.v1.SecureAggregandExecutionInfo.modulus)
3474 return _internal_modulus();
3475 }
_internal_set_modulus(::uint64_t value)3476 inline void SecureAggregandExecutionInfo::_internal_set_modulus(::uint64_t value) {
3477
3478 _impl_.modulus_ = value;
3479 }
set_modulus(::uint64_t value)3480 inline void SecureAggregandExecutionInfo::set_modulus(::uint64_t value) {
3481 _internal_set_modulus(value);
3482 // @@protoc_insertion_point(field_set:google.internal.federatedcompute.v1.SecureAggregandExecutionInfo.modulus)
3483 }
3484
3485 // -------------------------------------------------------------------
3486
3487 // SecureAggregationProtocolExecutionInfo
3488
3489 // int32 expected_number_of_clients = 1;
clear_expected_number_of_clients()3490 inline void SecureAggregationProtocolExecutionInfo::clear_expected_number_of_clients() {
3491 _impl_.expected_number_of_clients_ = 0;
3492 }
_internal_expected_number_of_clients()3493 inline ::int32_t SecureAggregationProtocolExecutionInfo::_internal_expected_number_of_clients() const {
3494 return _impl_.expected_number_of_clients_;
3495 }
expected_number_of_clients()3496 inline ::int32_t SecureAggregationProtocolExecutionInfo::expected_number_of_clients() const {
3497 // @@protoc_insertion_point(field_get:google.internal.federatedcompute.v1.SecureAggregationProtocolExecutionInfo.expected_number_of_clients)
3498 return _internal_expected_number_of_clients();
3499 }
_internal_set_expected_number_of_clients(::int32_t value)3500 inline void SecureAggregationProtocolExecutionInfo::_internal_set_expected_number_of_clients(::int32_t value) {
3501
3502 _impl_.expected_number_of_clients_ = value;
3503 }
set_expected_number_of_clients(::int32_t value)3504 inline void SecureAggregationProtocolExecutionInfo::set_expected_number_of_clients(::int32_t value) {
3505 _internal_set_expected_number_of_clients(value);
3506 // @@protoc_insertion_point(field_set:google.internal.federatedcompute.v1.SecureAggregationProtocolExecutionInfo.expected_number_of_clients)
3507 }
3508
3509 // int32 minimum_surviving_clients_for_reconstruction = 2;
clear_minimum_surviving_clients_for_reconstruction()3510 inline void SecureAggregationProtocolExecutionInfo::clear_minimum_surviving_clients_for_reconstruction() {
3511 _impl_.minimum_surviving_clients_for_reconstruction_ = 0;
3512 }
_internal_minimum_surviving_clients_for_reconstruction()3513 inline ::int32_t SecureAggregationProtocolExecutionInfo::_internal_minimum_surviving_clients_for_reconstruction() const {
3514 return _impl_.minimum_surviving_clients_for_reconstruction_;
3515 }
minimum_surviving_clients_for_reconstruction()3516 inline ::int32_t SecureAggregationProtocolExecutionInfo::minimum_surviving_clients_for_reconstruction() const {
3517 // @@protoc_insertion_point(field_get:google.internal.federatedcompute.v1.SecureAggregationProtocolExecutionInfo.minimum_surviving_clients_for_reconstruction)
3518 return _internal_minimum_surviving_clients_for_reconstruction();
3519 }
_internal_set_minimum_surviving_clients_for_reconstruction(::int32_t value)3520 inline void SecureAggregationProtocolExecutionInfo::_internal_set_minimum_surviving_clients_for_reconstruction(::int32_t value) {
3521
3522 _impl_.minimum_surviving_clients_for_reconstruction_ = value;
3523 }
set_minimum_surviving_clients_for_reconstruction(::int32_t value)3524 inline void SecureAggregationProtocolExecutionInfo::set_minimum_surviving_clients_for_reconstruction(::int32_t value) {
3525 _internal_set_minimum_surviving_clients_for_reconstruction(value);
3526 // @@protoc_insertion_point(field_set:google.internal.federatedcompute.v1.SecureAggregationProtocolExecutionInfo.minimum_surviving_clients_for_reconstruction)
3527 }
3528
3529 // -------------------------------------------------------------------
3530
3531 // AbortSecureAggregationRequest
3532
3533 // string aggregation_id = 1;
clear_aggregation_id()3534 inline void AbortSecureAggregationRequest::clear_aggregation_id() {
3535 _impl_.aggregation_id_.ClearToEmpty();
3536 }
aggregation_id()3537 inline const std::string& AbortSecureAggregationRequest::aggregation_id() const {
3538 // @@protoc_insertion_point(field_get:google.internal.federatedcompute.v1.AbortSecureAggregationRequest.aggregation_id)
3539 return _internal_aggregation_id();
3540 }
3541 template <typename ArgT0, typename... ArgT>
3542 inline PROTOBUF_ALWAYS_INLINE
set_aggregation_id(ArgT0 && arg0,ArgT...args)3543 void AbortSecureAggregationRequest::set_aggregation_id(ArgT0&& arg0, ArgT... args) {
3544
3545 _impl_.aggregation_id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3546 // @@protoc_insertion_point(field_set:google.internal.federatedcompute.v1.AbortSecureAggregationRequest.aggregation_id)
3547 }
mutable_aggregation_id()3548 inline std::string* AbortSecureAggregationRequest::mutable_aggregation_id() {
3549 std::string* _s = _internal_mutable_aggregation_id();
3550 // @@protoc_insertion_point(field_mutable:google.internal.federatedcompute.v1.AbortSecureAggregationRequest.aggregation_id)
3551 return _s;
3552 }
_internal_aggregation_id()3553 inline const std::string& AbortSecureAggregationRequest::_internal_aggregation_id() const {
3554 return _impl_.aggregation_id_.Get();
3555 }
_internal_set_aggregation_id(const std::string & value)3556 inline void AbortSecureAggregationRequest::_internal_set_aggregation_id(const std::string& value) {
3557
3558 _impl_.aggregation_id_.Set(value, GetArenaForAllocation());
3559 }
_internal_mutable_aggregation_id()3560 inline std::string* AbortSecureAggregationRequest::_internal_mutable_aggregation_id() {
3561
3562 return _impl_.aggregation_id_.Mutable(GetArenaForAllocation());
3563 }
release_aggregation_id()3564 inline std::string* AbortSecureAggregationRequest::release_aggregation_id() {
3565 // @@protoc_insertion_point(field_release:google.internal.federatedcompute.v1.AbortSecureAggregationRequest.aggregation_id)
3566 return _impl_.aggregation_id_.Release();
3567 }
set_allocated_aggregation_id(std::string * aggregation_id)3568 inline void AbortSecureAggregationRequest::set_allocated_aggregation_id(std::string* aggregation_id) {
3569 _impl_.aggregation_id_.SetAllocated(aggregation_id, GetArenaForAllocation());
3570 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3571 if (_impl_.aggregation_id_.IsDefault()) {
3572 _impl_.aggregation_id_.Set("", GetArenaForAllocation());
3573 }
3574 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3575 // @@protoc_insertion_point(field_set_allocated:google.internal.federatedcompute.v1.AbortSecureAggregationRequest.aggregation_id)
3576 }
3577
3578 // string client_token = 2;
clear_client_token()3579 inline void AbortSecureAggregationRequest::clear_client_token() {
3580 _impl_.client_token_.ClearToEmpty();
3581 }
client_token()3582 inline const std::string& AbortSecureAggregationRequest::client_token() const {
3583 // @@protoc_insertion_point(field_get:google.internal.federatedcompute.v1.AbortSecureAggregationRequest.client_token)
3584 return _internal_client_token();
3585 }
3586 template <typename ArgT0, typename... ArgT>
3587 inline PROTOBUF_ALWAYS_INLINE
set_client_token(ArgT0 && arg0,ArgT...args)3588 void AbortSecureAggregationRequest::set_client_token(ArgT0&& arg0, ArgT... args) {
3589
3590 _impl_.client_token_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3591 // @@protoc_insertion_point(field_set:google.internal.federatedcompute.v1.AbortSecureAggregationRequest.client_token)
3592 }
mutable_client_token()3593 inline std::string* AbortSecureAggregationRequest::mutable_client_token() {
3594 std::string* _s = _internal_mutable_client_token();
3595 // @@protoc_insertion_point(field_mutable:google.internal.federatedcompute.v1.AbortSecureAggregationRequest.client_token)
3596 return _s;
3597 }
_internal_client_token()3598 inline const std::string& AbortSecureAggregationRequest::_internal_client_token() const {
3599 return _impl_.client_token_.Get();
3600 }
_internal_set_client_token(const std::string & value)3601 inline void AbortSecureAggregationRequest::_internal_set_client_token(const std::string& value) {
3602
3603 _impl_.client_token_.Set(value, GetArenaForAllocation());
3604 }
_internal_mutable_client_token()3605 inline std::string* AbortSecureAggregationRequest::_internal_mutable_client_token() {
3606
3607 return _impl_.client_token_.Mutable(GetArenaForAllocation());
3608 }
release_client_token()3609 inline std::string* AbortSecureAggregationRequest::release_client_token() {
3610 // @@protoc_insertion_point(field_release:google.internal.federatedcompute.v1.AbortSecureAggregationRequest.client_token)
3611 return _impl_.client_token_.Release();
3612 }
set_allocated_client_token(std::string * client_token)3613 inline void AbortSecureAggregationRequest::set_allocated_client_token(std::string* client_token) {
3614 _impl_.client_token_.SetAllocated(client_token, GetArenaForAllocation());
3615 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3616 if (_impl_.client_token_.IsDefault()) {
3617 _impl_.client_token_.Set("", GetArenaForAllocation());
3618 }
3619 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3620 // @@protoc_insertion_point(field_set_allocated:google.internal.federatedcompute.v1.AbortSecureAggregationRequest.client_token)
3621 }
3622
3623 // .google.internal.federatedcompute.v1.Status status = 3;
_internal_has_status()3624 inline bool AbortSecureAggregationRequest::_internal_has_status() const {
3625 return this != internal_default_instance() && _impl_.status_ != nullptr;
3626 }
has_status()3627 inline bool AbortSecureAggregationRequest::has_status() const {
3628 return _internal_has_status();
3629 }
_internal_status()3630 inline const ::google::internal::federatedcompute::v1::Status& AbortSecureAggregationRequest::_internal_status() const {
3631 const ::google::internal::federatedcompute::v1::Status* p = _impl_.status_;
3632 return p != nullptr ? *p : reinterpret_cast<const ::google::internal::federatedcompute::v1::Status&>(
3633 ::google::internal::federatedcompute::v1::_Status_default_instance_);
3634 }
status()3635 inline const ::google::internal::federatedcompute::v1::Status& AbortSecureAggregationRequest::status() const {
3636 // @@protoc_insertion_point(field_get:google.internal.federatedcompute.v1.AbortSecureAggregationRequest.status)
3637 return _internal_status();
3638 }
unsafe_arena_set_allocated_status(::google::internal::federatedcompute::v1::Status * status)3639 inline void AbortSecureAggregationRequest::unsafe_arena_set_allocated_status(
3640 ::google::internal::federatedcompute::v1::Status* status) {
3641 if (GetArenaForAllocation() == nullptr) {
3642 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.status_);
3643 }
3644 _impl_.status_ = status;
3645 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federatedcompute.v1.AbortSecureAggregationRequest.status)
3646 }
release_status()3647 inline ::google::internal::federatedcompute::v1::Status* AbortSecureAggregationRequest::release_status() {
3648
3649 ::google::internal::federatedcompute::v1::Status* temp = _impl_.status_;
3650 _impl_.status_ = nullptr;
3651 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
3652 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
3653 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3654 if (GetArenaForAllocation() == nullptr) { delete old; }
3655 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
3656 if (GetArenaForAllocation() != nullptr) {
3657 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3658 }
3659 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
3660 return temp;
3661 }
unsafe_arena_release_status()3662 inline ::google::internal::federatedcompute::v1::Status* AbortSecureAggregationRequest::unsafe_arena_release_status() {
3663 // @@protoc_insertion_point(field_release:google.internal.federatedcompute.v1.AbortSecureAggregationRequest.status)
3664
3665 ::google::internal::federatedcompute::v1::Status* temp = _impl_.status_;
3666 _impl_.status_ = nullptr;
3667 return temp;
3668 }
_internal_mutable_status()3669 inline ::google::internal::federatedcompute::v1::Status* AbortSecureAggregationRequest::_internal_mutable_status() {
3670
3671 if (_impl_.status_ == nullptr) {
3672 auto* p = CreateMaybeMessage<::google::internal::federatedcompute::v1::Status>(GetArenaForAllocation());
3673 _impl_.status_ = p;
3674 }
3675 return _impl_.status_;
3676 }
mutable_status()3677 inline ::google::internal::federatedcompute::v1::Status* AbortSecureAggregationRequest::mutable_status() {
3678 ::google::internal::federatedcompute::v1::Status* _msg = _internal_mutable_status();
3679 // @@protoc_insertion_point(field_mutable:google.internal.federatedcompute.v1.AbortSecureAggregationRequest.status)
3680 return _msg;
3681 }
set_allocated_status(::google::internal::federatedcompute::v1::Status * status)3682 inline void AbortSecureAggregationRequest::set_allocated_status(::google::internal::federatedcompute::v1::Status* status) {
3683 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
3684 if (message_arena == nullptr) {
3685 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.status_);
3686 }
3687 if (status) {
3688 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
3689 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
3690 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(status));
3691 if (message_arena != submessage_arena) {
3692 status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
3693 message_arena, status, submessage_arena);
3694 }
3695
3696 } else {
3697
3698 }
3699 _impl_.status_ = status;
3700 // @@protoc_insertion_point(field_set_allocated:google.internal.federatedcompute.v1.AbortSecureAggregationRequest.status)
3701 }
3702
3703 // -------------------------------------------------------------------
3704
3705 // AbortSecureAggregationResponse
3706
3707 // -------------------------------------------------------------------
3708
3709 // AdvertiseKeysRequest
3710
3711 // string aggregation_id = 1;
clear_aggregation_id()3712 inline void AdvertiseKeysRequest::clear_aggregation_id() {
3713 _impl_.aggregation_id_.ClearToEmpty();
3714 }
aggregation_id()3715 inline const std::string& AdvertiseKeysRequest::aggregation_id() const {
3716 // @@protoc_insertion_point(field_get:google.internal.federatedcompute.v1.AdvertiseKeysRequest.aggregation_id)
3717 return _internal_aggregation_id();
3718 }
3719 template <typename ArgT0, typename... ArgT>
3720 inline PROTOBUF_ALWAYS_INLINE
set_aggregation_id(ArgT0 && arg0,ArgT...args)3721 void AdvertiseKeysRequest::set_aggregation_id(ArgT0&& arg0, ArgT... args) {
3722
3723 _impl_.aggregation_id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3724 // @@protoc_insertion_point(field_set:google.internal.federatedcompute.v1.AdvertiseKeysRequest.aggregation_id)
3725 }
mutable_aggregation_id()3726 inline std::string* AdvertiseKeysRequest::mutable_aggregation_id() {
3727 std::string* _s = _internal_mutable_aggregation_id();
3728 // @@protoc_insertion_point(field_mutable:google.internal.federatedcompute.v1.AdvertiseKeysRequest.aggregation_id)
3729 return _s;
3730 }
_internal_aggregation_id()3731 inline const std::string& AdvertiseKeysRequest::_internal_aggregation_id() const {
3732 return _impl_.aggregation_id_.Get();
3733 }
_internal_set_aggregation_id(const std::string & value)3734 inline void AdvertiseKeysRequest::_internal_set_aggregation_id(const std::string& value) {
3735
3736 _impl_.aggregation_id_.Set(value, GetArenaForAllocation());
3737 }
_internal_mutable_aggregation_id()3738 inline std::string* AdvertiseKeysRequest::_internal_mutable_aggregation_id() {
3739
3740 return _impl_.aggregation_id_.Mutable(GetArenaForAllocation());
3741 }
release_aggregation_id()3742 inline std::string* AdvertiseKeysRequest::release_aggregation_id() {
3743 // @@protoc_insertion_point(field_release:google.internal.federatedcompute.v1.AdvertiseKeysRequest.aggregation_id)
3744 return _impl_.aggregation_id_.Release();
3745 }
set_allocated_aggregation_id(std::string * aggregation_id)3746 inline void AdvertiseKeysRequest::set_allocated_aggregation_id(std::string* aggregation_id) {
3747 _impl_.aggregation_id_.SetAllocated(aggregation_id, GetArenaForAllocation());
3748 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3749 if (_impl_.aggregation_id_.IsDefault()) {
3750 _impl_.aggregation_id_.Set("", GetArenaForAllocation());
3751 }
3752 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3753 // @@protoc_insertion_point(field_set_allocated:google.internal.federatedcompute.v1.AdvertiseKeysRequest.aggregation_id)
3754 }
3755
3756 // string client_token = 2;
clear_client_token()3757 inline void AdvertiseKeysRequest::clear_client_token() {
3758 _impl_.client_token_.ClearToEmpty();
3759 }
client_token()3760 inline const std::string& AdvertiseKeysRequest::client_token() const {
3761 // @@protoc_insertion_point(field_get:google.internal.federatedcompute.v1.AdvertiseKeysRequest.client_token)
3762 return _internal_client_token();
3763 }
3764 template <typename ArgT0, typename... ArgT>
3765 inline PROTOBUF_ALWAYS_INLINE
set_client_token(ArgT0 && arg0,ArgT...args)3766 void AdvertiseKeysRequest::set_client_token(ArgT0&& arg0, ArgT... args) {
3767
3768 _impl_.client_token_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3769 // @@protoc_insertion_point(field_set:google.internal.federatedcompute.v1.AdvertiseKeysRequest.client_token)
3770 }
mutable_client_token()3771 inline std::string* AdvertiseKeysRequest::mutable_client_token() {
3772 std::string* _s = _internal_mutable_client_token();
3773 // @@protoc_insertion_point(field_mutable:google.internal.federatedcompute.v1.AdvertiseKeysRequest.client_token)
3774 return _s;
3775 }
_internal_client_token()3776 inline const std::string& AdvertiseKeysRequest::_internal_client_token() const {
3777 return _impl_.client_token_.Get();
3778 }
_internal_set_client_token(const std::string & value)3779 inline void AdvertiseKeysRequest::_internal_set_client_token(const std::string& value) {
3780
3781 _impl_.client_token_.Set(value, GetArenaForAllocation());
3782 }
_internal_mutable_client_token()3783 inline std::string* AdvertiseKeysRequest::_internal_mutable_client_token() {
3784
3785 return _impl_.client_token_.Mutable(GetArenaForAllocation());
3786 }
release_client_token()3787 inline std::string* AdvertiseKeysRequest::release_client_token() {
3788 // @@protoc_insertion_point(field_release:google.internal.federatedcompute.v1.AdvertiseKeysRequest.client_token)
3789 return _impl_.client_token_.Release();
3790 }
set_allocated_client_token(std::string * client_token)3791 inline void AdvertiseKeysRequest::set_allocated_client_token(std::string* client_token) {
3792 _impl_.client_token_.SetAllocated(client_token, GetArenaForAllocation());
3793 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3794 if (_impl_.client_token_.IsDefault()) {
3795 _impl_.client_token_.Set("", GetArenaForAllocation());
3796 }
3797 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3798 // @@protoc_insertion_point(field_set_allocated:google.internal.federatedcompute.v1.AdvertiseKeysRequest.client_token)
3799 }
3800
3801 // .fcp.secagg.AdvertiseKeys advertise_keys = 3;
_internal_has_advertise_keys()3802 inline bool AdvertiseKeysRequest::_internal_has_advertise_keys() const {
3803 return this != internal_default_instance() && _impl_.advertise_keys_ != nullptr;
3804 }
has_advertise_keys()3805 inline bool AdvertiseKeysRequest::has_advertise_keys() const {
3806 return _internal_has_advertise_keys();
3807 }
_internal_advertise_keys()3808 inline const ::fcp::secagg::AdvertiseKeys& AdvertiseKeysRequest::_internal_advertise_keys() const {
3809 const ::fcp::secagg::AdvertiseKeys* p = _impl_.advertise_keys_;
3810 return p != nullptr ? *p : reinterpret_cast<const ::fcp::secagg::AdvertiseKeys&>(
3811 ::fcp::secagg::_AdvertiseKeys_default_instance_);
3812 }
advertise_keys()3813 inline const ::fcp::secagg::AdvertiseKeys& AdvertiseKeysRequest::advertise_keys() const {
3814 // @@protoc_insertion_point(field_get:google.internal.federatedcompute.v1.AdvertiseKeysRequest.advertise_keys)
3815 return _internal_advertise_keys();
3816 }
unsafe_arena_set_allocated_advertise_keys(::fcp::secagg::AdvertiseKeys * advertise_keys)3817 inline void AdvertiseKeysRequest::unsafe_arena_set_allocated_advertise_keys(
3818 ::fcp::secagg::AdvertiseKeys* advertise_keys) {
3819 if (GetArenaForAllocation() == nullptr) {
3820 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.advertise_keys_);
3821 }
3822 _impl_.advertise_keys_ = advertise_keys;
3823 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federatedcompute.v1.AdvertiseKeysRequest.advertise_keys)
3824 }
release_advertise_keys()3825 inline ::fcp::secagg::AdvertiseKeys* AdvertiseKeysRequest::release_advertise_keys() {
3826
3827 ::fcp::secagg::AdvertiseKeys* temp = _impl_.advertise_keys_;
3828 _impl_.advertise_keys_ = nullptr;
3829 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
3830 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
3831 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3832 if (GetArenaForAllocation() == nullptr) { delete old; }
3833 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
3834 if (GetArenaForAllocation() != nullptr) {
3835 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3836 }
3837 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
3838 return temp;
3839 }
unsafe_arena_release_advertise_keys()3840 inline ::fcp::secagg::AdvertiseKeys* AdvertiseKeysRequest::unsafe_arena_release_advertise_keys() {
3841 // @@protoc_insertion_point(field_release:google.internal.federatedcompute.v1.AdvertiseKeysRequest.advertise_keys)
3842
3843 ::fcp::secagg::AdvertiseKeys* temp = _impl_.advertise_keys_;
3844 _impl_.advertise_keys_ = nullptr;
3845 return temp;
3846 }
_internal_mutable_advertise_keys()3847 inline ::fcp::secagg::AdvertiseKeys* AdvertiseKeysRequest::_internal_mutable_advertise_keys() {
3848
3849 if (_impl_.advertise_keys_ == nullptr) {
3850 auto* p = CreateMaybeMessage<::fcp::secagg::AdvertiseKeys>(GetArenaForAllocation());
3851 _impl_.advertise_keys_ = p;
3852 }
3853 return _impl_.advertise_keys_;
3854 }
mutable_advertise_keys()3855 inline ::fcp::secagg::AdvertiseKeys* AdvertiseKeysRequest::mutable_advertise_keys() {
3856 ::fcp::secagg::AdvertiseKeys* _msg = _internal_mutable_advertise_keys();
3857 // @@protoc_insertion_point(field_mutable:google.internal.federatedcompute.v1.AdvertiseKeysRequest.advertise_keys)
3858 return _msg;
3859 }
set_allocated_advertise_keys(::fcp::secagg::AdvertiseKeys * advertise_keys)3860 inline void AdvertiseKeysRequest::set_allocated_advertise_keys(::fcp::secagg::AdvertiseKeys* advertise_keys) {
3861 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
3862 if (message_arena == nullptr) {
3863 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.advertise_keys_);
3864 }
3865 if (advertise_keys) {
3866 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
3867 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
3868 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advertise_keys));
3869 if (message_arena != submessage_arena) {
3870 advertise_keys = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
3871 message_arena, advertise_keys, submessage_arena);
3872 }
3873
3874 } else {
3875
3876 }
3877 _impl_.advertise_keys_ = advertise_keys;
3878 // @@protoc_insertion_point(field_set_allocated:google.internal.federatedcompute.v1.AdvertiseKeysRequest.advertise_keys)
3879 }
3880
3881 // -------------------------------------------------------------------
3882
3883 // AdvertiseKeysMetadata
3884
3885 // .google.protobuf.Duration polling_interval = 1;
_internal_has_polling_interval()3886 inline bool AdvertiseKeysMetadata::_internal_has_polling_interval() const {
3887 return this != internal_default_instance() && _impl_.polling_interval_ != nullptr;
3888 }
has_polling_interval()3889 inline bool AdvertiseKeysMetadata::has_polling_interval() const {
3890 return _internal_has_polling_interval();
3891 }
_internal_polling_interval()3892 inline const ::PROTOBUF_NAMESPACE_ID::Duration& AdvertiseKeysMetadata::_internal_polling_interval() const {
3893 const ::PROTOBUF_NAMESPACE_ID::Duration* p = _impl_.polling_interval_;
3894 return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Duration&>(
3895 ::PROTOBUF_NAMESPACE_ID::_Duration_default_instance_);
3896 }
polling_interval()3897 inline const ::PROTOBUF_NAMESPACE_ID::Duration& AdvertiseKeysMetadata::polling_interval() const {
3898 // @@protoc_insertion_point(field_get:google.internal.federatedcompute.v1.AdvertiseKeysMetadata.polling_interval)
3899 return _internal_polling_interval();
3900 }
unsafe_arena_set_allocated_polling_interval(::PROTOBUF_NAMESPACE_ID::Duration * polling_interval)3901 inline void AdvertiseKeysMetadata::unsafe_arena_set_allocated_polling_interval(
3902 ::PROTOBUF_NAMESPACE_ID::Duration* polling_interval) {
3903 if (GetArenaForAllocation() == nullptr) {
3904 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.polling_interval_);
3905 }
3906 _impl_.polling_interval_ = polling_interval;
3907 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federatedcompute.v1.AdvertiseKeysMetadata.polling_interval)
3908 }
release_polling_interval()3909 inline ::PROTOBUF_NAMESPACE_ID::Duration* AdvertiseKeysMetadata::release_polling_interval() {
3910
3911 ::PROTOBUF_NAMESPACE_ID::Duration* temp = _impl_.polling_interval_;
3912 _impl_.polling_interval_ = nullptr;
3913 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
3914 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
3915 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3916 if (GetArenaForAllocation() == nullptr) { delete old; }
3917 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
3918 if (GetArenaForAllocation() != nullptr) {
3919 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3920 }
3921 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
3922 return temp;
3923 }
unsafe_arena_release_polling_interval()3924 inline ::PROTOBUF_NAMESPACE_ID::Duration* AdvertiseKeysMetadata::unsafe_arena_release_polling_interval() {
3925 // @@protoc_insertion_point(field_release:google.internal.federatedcompute.v1.AdvertiseKeysMetadata.polling_interval)
3926
3927 ::PROTOBUF_NAMESPACE_ID::Duration* temp = _impl_.polling_interval_;
3928 _impl_.polling_interval_ = nullptr;
3929 return temp;
3930 }
_internal_mutable_polling_interval()3931 inline ::PROTOBUF_NAMESPACE_ID::Duration* AdvertiseKeysMetadata::_internal_mutable_polling_interval() {
3932
3933 if (_impl_.polling_interval_ == nullptr) {
3934 auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Duration>(GetArenaForAllocation());
3935 _impl_.polling_interval_ = p;
3936 }
3937 return _impl_.polling_interval_;
3938 }
mutable_polling_interval()3939 inline ::PROTOBUF_NAMESPACE_ID::Duration* AdvertiseKeysMetadata::mutable_polling_interval() {
3940 ::PROTOBUF_NAMESPACE_ID::Duration* _msg = _internal_mutable_polling_interval();
3941 // @@protoc_insertion_point(field_mutable:google.internal.federatedcompute.v1.AdvertiseKeysMetadata.polling_interval)
3942 return _msg;
3943 }
set_allocated_polling_interval(::PROTOBUF_NAMESPACE_ID::Duration * polling_interval)3944 inline void AdvertiseKeysMetadata::set_allocated_polling_interval(::PROTOBUF_NAMESPACE_ID::Duration* polling_interval) {
3945 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
3946 if (message_arena == nullptr) {
3947 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.polling_interval_);
3948 }
3949 if (polling_interval) {
3950 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
3951 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
3952 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(polling_interval));
3953 if (message_arena != submessage_arena) {
3954 polling_interval = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
3955 message_arena, polling_interval, submessage_arena);
3956 }
3957
3958 } else {
3959
3960 }
3961 _impl_.polling_interval_ = polling_interval;
3962 // @@protoc_insertion_point(field_set_allocated:google.internal.federatedcompute.v1.AdvertiseKeysMetadata.polling_interval)
3963 }
3964
3965 // -------------------------------------------------------------------
3966
3967 // AdvertiseKeysResponse
3968
3969 // .fcp.secagg.ShareKeysRequest share_keys_server_request = 1;
_internal_has_share_keys_server_request()3970 inline bool AdvertiseKeysResponse::_internal_has_share_keys_server_request() const {
3971 return this != internal_default_instance() && _impl_.share_keys_server_request_ != nullptr;
3972 }
has_share_keys_server_request()3973 inline bool AdvertiseKeysResponse::has_share_keys_server_request() const {
3974 return _internal_has_share_keys_server_request();
3975 }
_internal_share_keys_server_request()3976 inline const ::fcp::secagg::ShareKeysRequest& AdvertiseKeysResponse::_internal_share_keys_server_request() const {
3977 const ::fcp::secagg::ShareKeysRequest* p = _impl_.share_keys_server_request_;
3978 return p != nullptr ? *p : reinterpret_cast<const ::fcp::secagg::ShareKeysRequest&>(
3979 ::fcp::secagg::_ShareKeysRequest_default_instance_);
3980 }
share_keys_server_request()3981 inline const ::fcp::secagg::ShareKeysRequest& AdvertiseKeysResponse::share_keys_server_request() const {
3982 // @@protoc_insertion_point(field_get:google.internal.federatedcompute.v1.AdvertiseKeysResponse.share_keys_server_request)
3983 return _internal_share_keys_server_request();
3984 }
unsafe_arena_set_allocated_share_keys_server_request(::fcp::secagg::ShareKeysRequest * share_keys_server_request)3985 inline void AdvertiseKeysResponse::unsafe_arena_set_allocated_share_keys_server_request(
3986 ::fcp::secagg::ShareKeysRequest* share_keys_server_request) {
3987 if (GetArenaForAllocation() == nullptr) {
3988 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.share_keys_server_request_);
3989 }
3990 _impl_.share_keys_server_request_ = share_keys_server_request;
3991 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federatedcompute.v1.AdvertiseKeysResponse.share_keys_server_request)
3992 }
release_share_keys_server_request()3993 inline ::fcp::secagg::ShareKeysRequest* AdvertiseKeysResponse::release_share_keys_server_request() {
3994
3995 ::fcp::secagg::ShareKeysRequest* temp = _impl_.share_keys_server_request_;
3996 _impl_.share_keys_server_request_ = nullptr;
3997 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
3998 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
3999 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
4000 if (GetArenaForAllocation() == nullptr) { delete old; }
4001 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
4002 if (GetArenaForAllocation() != nullptr) {
4003 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
4004 }
4005 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
4006 return temp;
4007 }
unsafe_arena_release_share_keys_server_request()4008 inline ::fcp::secagg::ShareKeysRequest* AdvertiseKeysResponse::unsafe_arena_release_share_keys_server_request() {
4009 // @@protoc_insertion_point(field_release:google.internal.federatedcompute.v1.AdvertiseKeysResponse.share_keys_server_request)
4010
4011 ::fcp::secagg::ShareKeysRequest* temp = _impl_.share_keys_server_request_;
4012 _impl_.share_keys_server_request_ = nullptr;
4013 return temp;
4014 }
_internal_mutable_share_keys_server_request()4015 inline ::fcp::secagg::ShareKeysRequest* AdvertiseKeysResponse::_internal_mutable_share_keys_server_request() {
4016
4017 if (_impl_.share_keys_server_request_ == nullptr) {
4018 auto* p = CreateMaybeMessage<::fcp::secagg::ShareKeysRequest>(GetArenaForAllocation());
4019 _impl_.share_keys_server_request_ = p;
4020 }
4021 return _impl_.share_keys_server_request_;
4022 }
mutable_share_keys_server_request()4023 inline ::fcp::secagg::ShareKeysRequest* AdvertiseKeysResponse::mutable_share_keys_server_request() {
4024 ::fcp::secagg::ShareKeysRequest* _msg = _internal_mutable_share_keys_server_request();
4025 // @@protoc_insertion_point(field_mutable:google.internal.federatedcompute.v1.AdvertiseKeysResponse.share_keys_server_request)
4026 return _msg;
4027 }
set_allocated_share_keys_server_request(::fcp::secagg::ShareKeysRequest * share_keys_server_request)4028 inline void AdvertiseKeysResponse::set_allocated_share_keys_server_request(::fcp::secagg::ShareKeysRequest* share_keys_server_request) {
4029 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
4030 if (message_arena == nullptr) {
4031 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.share_keys_server_request_);
4032 }
4033 if (share_keys_server_request) {
4034 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
4035 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
4036 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(share_keys_server_request));
4037 if (message_arena != submessage_arena) {
4038 share_keys_server_request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
4039 message_arena, share_keys_server_request, submessage_arena);
4040 }
4041
4042 } else {
4043
4044 }
4045 _impl_.share_keys_server_request_ = share_keys_server_request;
4046 // @@protoc_insertion_point(field_set_allocated:google.internal.federatedcompute.v1.AdvertiseKeysResponse.share_keys_server_request)
4047 }
4048
4049 // -------------------------------------------------------------------
4050
4051 // ShareKeysRequest
4052
4053 // string aggregation_id = 1;
clear_aggregation_id()4054 inline void ShareKeysRequest::clear_aggregation_id() {
4055 _impl_.aggregation_id_.ClearToEmpty();
4056 }
aggregation_id()4057 inline const std::string& ShareKeysRequest::aggregation_id() const {
4058 // @@protoc_insertion_point(field_get:google.internal.federatedcompute.v1.ShareKeysRequest.aggregation_id)
4059 return _internal_aggregation_id();
4060 }
4061 template <typename ArgT0, typename... ArgT>
4062 inline PROTOBUF_ALWAYS_INLINE
set_aggregation_id(ArgT0 && arg0,ArgT...args)4063 void ShareKeysRequest::set_aggregation_id(ArgT0&& arg0, ArgT... args) {
4064
4065 _impl_.aggregation_id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4066 // @@protoc_insertion_point(field_set:google.internal.federatedcompute.v1.ShareKeysRequest.aggregation_id)
4067 }
mutable_aggregation_id()4068 inline std::string* ShareKeysRequest::mutable_aggregation_id() {
4069 std::string* _s = _internal_mutable_aggregation_id();
4070 // @@protoc_insertion_point(field_mutable:google.internal.federatedcompute.v1.ShareKeysRequest.aggregation_id)
4071 return _s;
4072 }
_internal_aggregation_id()4073 inline const std::string& ShareKeysRequest::_internal_aggregation_id() const {
4074 return _impl_.aggregation_id_.Get();
4075 }
_internal_set_aggregation_id(const std::string & value)4076 inline void ShareKeysRequest::_internal_set_aggregation_id(const std::string& value) {
4077
4078 _impl_.aggregation_id_.Set(value, GetArenaForAllocation());
4079 }
_internal_mutable_aggregation_id()4080 inline std::string* ShareKeysRequest::_internal_mutable_aggregation_id() {
4081
4082 return _impl_.aggregation_id_.Mutable(GetArenaForAllocation());
4083 }
release_aggregation_id()4084 inline std::string* ShareKeysRequest::release_aggregation_id() {
4085 // @@protoc_insertion_point(field_release:google.internal.federatedcompute.v1.ShareKeysRequest.aggregation_id)
4086 return _impl_.aggregation_id_.Release();
4087 }
set_allocated_aggregation_id(std::string * aggregation_id)4088 inline void ShareKeysRequest::set_allocated_aggregation_id(std::string* aggregation_id) {
4089 _impl_.aggregation_id_.SetAllocated(aggregation_id, GetArenaForAllocation());
4090 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4091 if (_impl_.aggregation_id_.IsDefault()) {
4092 _impl_.aggregation_id_.Set("", GetArenaForAllocation());
4093 }
4094 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4095 // @@protoc_insertion_point(field_set_allocated:google.internal.federatedcompute.v1.ShareKeysRequest.aggregation_id)
4096 }
4097
4098 // string client_token = 2;
clear_client_token()4099 inline void ShareKeysRequest::clear_client_token() {
4100 _impl_.client_token_.ClearToEmpty();
4101 }
client_token()4102 inline const std::string& ShareKeysRequest::client_token() const {
4103 // @@protoc_insertion_point(field_get:google.internal.federatedcompute.v1.ShareKeysRequest.client_token)
4104 return _internal_client_token();
4105 }
4106 template <typename ArgT0, typename... ArgT>
4107 inline PROTOBUF_ALWAYS_INLINE
set_client_token(ArgT0 && arg0,ArgT...args)4108 void ShareKeysRequest::set_client_token(ArgT0&& arg0, ArgT... args) {
4109
4110 _impl_.client_token_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4111 // @@protoc_insertion_point(field_set:google.internal.federatedcompute.v1.ShareKeysRequest.client_token)
4112 }
mutable_client_token()4113 inline std::string* ShareKeysRequest::mutable_client_token() {
4114 std::string* _s = _internal_mutable_client_token();
4115 // @@protoc_insertion_point(field_mutable:google.internal.federatedcompute.v1.ShareKeysRequest.client_token)
4116 return _s;
4117 }
_internal_client_token()4118 inline const std::string& ShareKeysRequest::_internal_client_token() const {
4119 return _impl_.client_token_.Get();
4120 }
_internal_set_client_token(const std::string & value)4121 inline void ShareKeysRequest::_internal_set_client_token(const std::string& value) {
4122
4123 _impl_.client_token_.Set(value, GetArenaForAllocation());
4124 }
_internal_mutable_client_token()4125 inline std::string* ShareKeysRequest::_internal_mutable_client_token() {
4126
4127 return _impl_.client_token_.Mutable(GetArenaForAllocation());
4128 }
release_client_token()4129 inline std::string* ShareKeysRequest::release_client_token() {
4130 // @@protoc_insertion_point(field_release:google.internal.federatedcompute.v1.ShareKeysRequest.client_token)
4131 return _impl_.client_token_.Release();
4132 }
set_allocated_client_token(std::string * client_token)4133 inline void ShareKeysRequest::set_allocated_client_token(std::string* client_token) {
4134 _impl_.client_token_.SetAllocated(client_token, GetArenaForAllocation());
4135 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4136 if (_impl_.client_token_.IsDefault()) {
4137 _impl_.client_token_.Set("", GetArenaForAllocation());
4138 }
4139 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4140 // @@protoc_insertion_point(field_set_allocated:google.internal.federatedcompute.v1.ShareKeysRequest.client_token)
4141 }
4142
4143 // .fcp.secagg.ShareKeysResponse share_keys_client_response = 3;
_internal_has_share_keys_client_response()4144 inline bool ShareKeysRequest::_internal_has_share_keys_client_response() const {
4145 return this != internal_default_instance() && _impl_.share_keys_client_response_ != nullptr;
4146 }
has_share_keys_client_response()4147 inline bool ShareKeysRequest::has_share_keys_client_response() const {
4148 return _internal_has_share_keys_client_response();
4149 }
_internal_share_keys_client_response()4150 inline const ::fcp::secagg::ShareKeysResponse& ShareKeysRequest::_internal_share_keys_client_response() const {
4151 const ::fcp::secagg::ShareKeysResponse* p = _impl_.share_keys_client_response_;
4152 return p != nullptr ? *p : reinterpret_cast<const ::fcp::secagg::ShareKeysResponse&>(
4153 ::fcp::secagg::_ShareKeysResponse_default_instance_);
4154 }
share_keys_client_response()4155 inline const ::fcp::secagg::ShareKeysResponse& ShareKeysRequest::share_keys_client_response() const {
4156 // @@protoc_insertion_point(field_get:google.internal.federatedcompute.v1.ShareKeysRequest.share_keys_client_response)
4157 return _internal_share_keys_client_response();
4158 }
unsafe_arena_set_allocated_share_keys_client_response(::fcp::secagg::ShareKeysResponse * share_keys_client_response)4159 inline void ShareKeysRequest::unsafe_arena_set_allocated_share_keys_client_response(
4160 ::fcp::secagg::ShareKeysResponse* share_keys_client_response) {
4161 if (GetArenaForAllocation() == nullptr) {
4162 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.share_keys_client_response_);
4163 }
4164 _impl_.share_keys_client_response_ = share_keys_client_response;
4165 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federatedcompute.v1.ShareKeysRequest.share_keys_client_response)
4166 }
release_share_keys_client_response()4167 inline ::fcp::secagg::ShareKeysResponse* ShareKeysRequest::release_share_keys_client_response() {
4168
4169 ::fcp::secagg::ShareKeysResponse* temp = _impl_.share_keys_client_response_;
4170 _impl_.share_keys_client_response_ = nullptr;
4171 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
4172 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
4173 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
4174 if (GetArenaForAllocation() == nullptr) { delete old; }
4175 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
4176 if (GetArenaForAllocation() != nullptr) {
4177 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
4178 }
4179 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
4180 return temp;
4181 }
unsafe_arena_release_share_keys_client_response()4182 inline ::fcp::secagg::ShareKeysResponse* ShareKeysRequest::unsafe_arena_release_share_keys_client_response() {
4183 // @@protoc_insertion_point(field_release:google.internal.federatedcompute.v1.ShareKeysRequest.share_keys_client_response)
4184
4185 ::fcp::secagg::ShareKeysResponse* temp = _impl_.share_keys_client_response_;
4186 _impl_.share_keys_client_response_ = nullptr;
4187 return temp;
4188 }
_internal_mutable_share_keys_client_response()4189 inline ::fcp::secagg::ShareKeysResponse* ShareKeysRequest::_internal_mutable_share_keys_client_response() {
4190
4191 if (_impl_.share_keys_client_response_ == nullptr) {
4192 auto* p = CreateMaybeMessage<::fcp::secagg::ShareKeysResponse>(GetArenaForAllocation());
4193 _impl_.share_keys_client_response_ = p;
4194 }
4195 return _impl_.share_keys_client_response_;
4196 }
mutable_share_keys_client_response()4197 inline ::fcp::secagg::ShareKeysResponse* ShareKeysRequest::mutable_share_keys_client_response() {
4198 ::fcp::secagg::ShareKeysResponse* _msg = _internal_mutable_share_keys_client_response();
4199 // @@protoc_insertion_point(field_mutable:google.internal.federatedcompute.v1.ShareKeysRequest.share_keys_client_response)
4200 return _msg;
4201 }
set_allocated_share_keys_client_response(::fcp::secagg::ShareKeysResponse * share_keys_client_response)4202 inline void ShareKeysRequest::set_allocated_share_keys_client_response(::fcp::secagg::ShareKeysResponse* share_keys_client_response) {
4203 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
4204 if (message_arena == nullptr) {
4205 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.share_keys_client_response_);
4206 }
4207 if (share_keys_client_response) {
4208 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
4209 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
4210 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(share_keys_client_response));
4211 if (message_arena != submessage_arena) {
4212 share_keys_client_response = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
4213 message_arena, share_keys_client_response, submessage_arena);
4214 }
4215
4216 } else {
4217
4218 }
4219 _impl_.share_keys_client_response_ = share_keys_client_response;
4220 // @@protoc_insertion_point(field_set_allocated:google.internal.federatedcompute.v1.ShareKeysRequest.share_keys_client_response)
4221 }
4222
4223 // -------------------------------------------------------------------
4224
4225 // ShareKeysMetadata
4226
4227 // .google.protobuf.Duration polling_interval = 1;
_internal_has_polling_interval()4228 inline bool ShareKeysMetadata::_internal_has_polling_interval() const {
4229 return this != internal_default_instance() && _impl_.polling_interval_ != nullptr;
4230 }
has_polling_interval()4231 inline bool ShareKeysMetadata::has_polling_interval() const {
4232 return _internal_has_polling_interval();
4233 }
_internal_polling_interval()4234 inline const ::PROTOBUF_NAMESPACE_ID::Duration& ShareKeysMetadata::_internal_polling_interval() const {
4235 const ::PROTOBUF_NAMESPACE_ID::Duration* p = _impl_.polling_interval_;
4236 return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Duration&>(
4237 ::PROTOBUF_NAMESPACE_ID::_Duration_default_instance_);
4238 }
polling_interval()4239 inline const ::PROTOBUF_NAMESPACE_ID::Duration& ShareKeysMetadata::polling_interval() const {
4240 // @@protoc_insertion_point(field_get:google.internal.federatedcompute.v1.ShareKeysMetadata.polling_interval)
4241 return _internal_polling_interval();
4242 }
unsafe_arena_set_allocated_polling_interval(::PROTOBUF_NAMESPACE_ID::Duration * polling_interval)4243 inline void ShareKeysMetadata::unsafe_arena_set_allocated_polling_interval(
4244 ::PROTOBUF_NAMESPACE_ID::Duration* polling_interval) {
4245 if (GetArenaForAllocation() == nullptr) {
4246 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.polling_interval_);
4247 }
4248 _impl_.polling_interval_ = polling_interval;
4249 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federatedcompute.v1.ShareKeysMetadata.polling_interval)
4250 }
release_polling_interval()4251 inline ::PROTOBUF_NAMESPACE_ID::Duration* ShareKeysMetadata::release_polling_interval() {
4252
4253 ::PROTOBUF_NAMESPACE_ID::Duration* temp = _impl_.polling_interval_;
4254 _impl_.polling_interval_ = nullptr;
4255 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
4256 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
4257 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
4258 if (GetArenaForAllocation() == nullptr) { delete old; }
4259 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
4260 if (GetArenaForAllocation() != nullptr) {
4261 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
4262 }
4263 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
4264 return temp;
4265 }
unsafe_arena_release_polling_interval()4266 inline ::PROTOBUF_NAMESPACE_ID::Duration* ShareKeysMetadata::unsafe_arena_release_polling_interval() {
4267 // @@protoc_insertion_point(field_release:google.internal.federatedcompute.v1.ShareKeysMetadata.polling_interval)
4268
4269 ::PROTOBUF_NAMESPACE_ID::Duration* temp = _impl_.polling_interval_;
4270 _impl_.polling_interval_ = nullptr;
4271 return temp;
4272 }
_internal_mutable_polling_interval()4273 inline ::PROTOBUF_NAMESPACE_ID::Duration* ShareKeysMetadata::_internal_mutable_polling_interval() {
4274
4275 if (_impl_.polling_interval_ == nullptr) {
4276 auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Duration>(GetArenaForAllocation());
4277 _impl_.polling_interval_ = p;
4278 }
4279 return _impl_.polling_interval_;
4280 }
mutable_polling_interval()4281 inline ::PROTOBUF_NAMESPACE_ID::Duration* ShareKeysMetadata::mutable_polling_interval() {
4282 ::PROTOBUF_NAMESPACE_ID::Duration* _msg = _internal_mutable_polling_interval();
4283 // @@protoc_insertion_point(field_mutable:google.internal.federatedcompute.v1.ShareKeysMetadata.polling_interval)
4284 return _msg;
4285 }
set_allocated_polling_interval(::PROTOBUF_NAMESPACE_ID::Duration * polling_interval)4286 inline void ShareKeysMetadata::set_allocated_polling_interval(::PROTOBUF_NAMESPACE_ID::Duration* polling_interval) {
4287 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
4288 if (message_arena == nullptr) {
4289 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.polling_interval_);
4290 }
4291 if (polling_interval) {
4292 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
4293 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
4294 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(polling_interval));
4295 if (message_arena != submessage_arena) {
4296 polling_interval = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
4297 message_arena, polling_interval, submessage_arena);
4298 }
4299
4300 } else {
4301
4302 }
4303 _impl_.polling_interval_ = polling_interval;
4304 // @@protoc_insertion_point(field_set_allocated:google.internal.federatedcompute.v1.ShareKeysMetadata.polling_interval)
4305 }
4306
4307 // -------------------------------------------------------------------
4308
4309 // ShareKeysResponse
4310
4311 // .fcp.secagg.MaskedInputCollectionRequest masked_input_collection_server_request = 1;
_internal_has_masked_input_collection_server_request()4312 inline bool ShareKeysResponse::_internal_has_masked_input_collection_server_request() const {
4313 return this != internal_default_instance() && _impl_.masked_input_collection_server_request_ != nullptr;
4314 }
has_masked_input_collection_server_request()4315 inline bool ShareKeysResponse::has_masked_input_collection_server_request() const {
4316 return _internal_has_masked_input_collection_server_request();
4317 }
_internal_masked_input_collection_server_request()4318 inline const ::fcp::secagg::MaskedInputCollectionRequest& ShareKeysResponse::_internal_masked_input_collection_server_request() const {
4319 const ::fcp::secagg::MaskedInputCollectionRequest* p = _impl_.masked_input_collection_server_request_;
4320 return p != nullptr ? *p : reinterpret_cast<const ::fcp::secagg::MaskedInputCollectionRequest&>(
4321 ::fcp::secagg::_MaskedInputCollectionRequest_default_instance_);
4322 }
masked_input_collection_server_request()4323 inline const ::fcp::secagg::MaskedInputCollectionRequest& ShareKeysResponse::masked_input_collection_server_request() const {
4324 // @@protoc_insertion_point(field_get:google.internal.federatedcompute.v1.ShareKeysResponse.masked_input_collection_server_request)
4325 return _internal_masked_input_collection_server_request();
4326 }
unsafe_arena_set_allocated_masked_input_collection_server_request(::fcp::secagg::MaskedInputCollectionRequest * masked_input_collection_server_request)4327 inline void ShareKeysResponse::unsafe_arena_set_allocated_masked_input_collection_server_request(
4328 ::fcp::secagg::MaskedInputCollectionRequest* masked_input_collection_server_request) {
4329 if (GetArenaForAllocation() == nullptr) {
4330 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.masked_input_collection_server_request_);
4331 }
4332 _impl_.masked_input_collection_server_request_ = masked_input_collection_server_request;
4333 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federatedcompute.v1.ShareKeysResponse.masked_input_collection_server_request)
4334 }
release_masked_input_collection_server_request()4335 inline ::fcp::secagg::MaskedInputCollectionRequest* ShareKeysResponse::release_masked_input_collection_server_request() {
4336
4337 ::fcp::secagg::MaskedInputCollectionRequest* temp = _impl_.masked_input_collection_server_request_;
4338 _impl_.masked_input_collection_server_request_ = nullptr;
4339 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
4340 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
4341 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
4342 if (GetArenaForAllocation() == nullptr) { delete old; }
4343 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
4344 if (GetArenaForAllocation() != nullptr) {
4345 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
4346 }
4347 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
4348 return temp;
4349 }
unsafe_arena_release_masked_input_collection_server_request()4350 inline ::fcp::secagg::MaskedInputCollectionRequest* ShareKeysResponse::unsafe_arena_release_masked_input_collection_server_request() {
4351 // @@protoc_insertion_point(field_release:google.internal.federatedcompute.v1.ShareKeysResponse.masked_input_collection_server_request)
4352
4353 ::fcp::secagg::MaskedInputCollectionRequest* temp = _impl_.masked_input_collection_server_request_;
4354 _impl_.masked_input_collection_server_request_ = nullptr;
4355 return temp;
4356 }
_internal_mutable_masked_input_collection_server_request()4357 inline ::fcp::secagg::MaskedInputCollectionRequest* ShareKeysResponse::_internal_mutable_masked_input_collection_server_request() {
4358
4359 if (_impl_.masked_input_collection_server_request_ == nullptr) {
4360 auto* p = CreateMaybeMessage<::fcp::secagg::MaskedInputCollectionRequest>(GetArenaForAllocation());
4361 _impl_.masked_input_collection_server_request_ = p;
4362 }
4363 return _impl_.masked_input_collection_server_request_;
4364 }
mutable_masked_input_collection_server_request()4365 inline ::fcp::secagg::MaskedInputCollectionRequest* ShareKeysResponse::mutable_masked_input_collection_server_request() {
4366 ::fcp::secagg::MaskedInputCollectionRequest* _msg = _internal_mutable_masked_input_collection_server_request();
4367 // @@protoc_insertion_point(field_mutable:google.internal.federatedcompute.v1.ShareKeysResponse.masked_input_collection_server_request)
4368 return _msg;
4369 }
set_allocated_masked_input_collection_server_request(::fcp::secagg::MaskedInputCollectionRequest * masked_input_collection_server_request)4370 inline void ShareKeysResponse::set_allocated_masked_input_collection_server_request(::fcp::secagg::MaskedInputCollectionRequest* masked_input_collection_server_request) {
4371 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
4372 if (message_arena == nullptr) {
4373 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.masked_input_collection_server_request_);
4374 }
4375 if (masked_input_collection_server_request) {
4376 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
4377 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
4378 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(masked_input_collection_server_request));
4379 if (message_arena != submessage_arena) {
4380 masked_input_collection_server_request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
4381 message_arena, masked_input_collection_server_request, submessage_arena);
4382 }
4383
4384 } else {
4385
4386 }
4387 _impl_.masked_input_collection_server_request_ = masked_input_collection_server_request;
4388 // @@protoc_insertion_point(field_set_allocated:google.internal.federatedcompute.v1.ShareKeysResponse.masked_input_collection_server_request)
4389 }
4390
4391 // -------------------------------------------------------------------
4392
4393 // SubmitSecureAggregationResultRequest
4394
4395 // string aggregation_id = 1;
clear_aggregation_id()4396 inline void SubmitSecureAggregationResultRequest::clear_aggregation_id() {
4397 _impl_.aggregation_id_.ClearToEmpty();
4398 }
aggregation_id()4399 inline const std::string& SubmitSecureAggregationResultRequest::aggregation_id() const {
4400 // @@protoc_insertion_point(field_get:google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest.aggregation_id)
4401 return _internal_aggregation_id();
4402 }
4403 template <typename ArgT0, typename... ArgT>
4404 inline PROTOBUF_ALWAYS_INLINE
set_aggregation_id(ArgT0 && arg0,ArgT...args)4405 void SubmitSecureAggregationResultRequest::set_aggregation_id(ArgT0&& arg0, ArgT... args) {
4406
4407 _impl_.aggregation_id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4408 // @@protoc_insertion_point(field_set:google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest.aggregation_id)
4409 }
mutable_aggregation_id()4410 inline std::string* SubmitSecureAggregationResultRequest::mutable_aggregation_id() {
4411 std::string* _s = _internal_mutable_aggregation_id();
4412 // @@protoc_insertion_point(field_mutable:google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest.aggregation_id)
4413 return _s;
4414 }
_internal_aggregation_id()4415 inline const std::string& SubmitSecureAggregationResultRequest::_internal_aggregation_id() const {
4416 return _impl_.aggregation_id_.Get();
4417 }
_internal_set_aggregation_id(const std::string & value)4418 inline void SubmitSecureAggregationResultRequest::_internal_set_aggregation_id(const std::string& value) {
4419
4420 _impl_.aggregation_id_.Set(value, GetArenaForAllocation());
4421 }
_internal_mutable_aggregation_id()4422 inline std::string* SubmitSecureAggregationResultRequest::_internal_mutable_aggregation_id() {
4423
4424 return _impl_.aggregation_id_.Mutable(GetArenaForAllocation());
4425 }
release_aggregation_id()4426 inline std::string* SubmitSecureAggregationResultRequest::release_aggregation_id() {
4427 // @@protoc_insertion_point(field_release:google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest.aggregation_id)
4428 return _impl_.aggregation_id_.Release();
4429 }
set_allocated_aggregation_id(std::string * aggregation_id)4430 inline void SubmitSecureAggregationResultRequest::set_allocated_aggregation_id(std::string* aggregation_id) {
4431 _impl_.aggregation_id_.SetAllocated(aggregation_id, GetArenaForAllocation());
4432 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4433 if (_impl_.aggregation_id_.IsDefault()) {
4434 _impl_.aggregation_id_.Set("", GetArenaForAllocation());
4435 }
4436 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4437 // @@protoc_insertion_point(field_set_allocated:google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest.aggregation_id)
4438 }
4439
4440 // string client_token = 2;
clear_client_token()4441 inline void SubmitSecureAggregationResultRequest::clear_client_token() {
4442 _impl_.client_token_.ClearToEmpty();
4443 }
client_token()4444 inline const std::string& SubmitSecureAggregationResultRequest::client_token() const {
4445 // @@protoc_insertion_point(field_get:google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest.client_token)
4446 return _internal_client_token();
4447 }
4448 template <typename ArgT0, typename... ArgT>
4449 inline PROTOBUF_ALWAYS_INLINE
set_client_token(ArgT0 && arg0,ArgT...args)4450 void SubmitSecureAggregationResultRequest::set_client_token(ArgT0&& arg0, ArgT... args) {
4451
4452 _impl_.client_token_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4453 // @@protoc_insertion_point(field_set:google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest.client_token)
4454 }
mutable_client_token()4455 inline std::string* SubmitSecureAggregationResultRequest::mutable_client_token() {
4456 std::string* _s = _internal_mutable_client_token();
4457 // @@protoc_insertion_point(field_mutable:google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest.client_token)
4458 return _s;
4459 }
_internal_client_token()4460 inline const std::string& SubmitSecureAggregationResultRequest::_internal_client_token() const {
4461 return _impl_.client_token_.Get();
4462 }
_internal_set_client_token(const std::string & value)4463 inline void SubmitSecureAggregationResultRequest::_internal_set_client_token(const std::string& value) {
4464
4465 _impl_.client_token_.Set(value, GetArenaForAllocation());
4466 }
_internal_mutable_client_token()4467 inline std::string* SubmitSecureAggregationResultRequest::_internal_mutable_client_token() {
4468
4469 return _impl_.client_token_.Mutable(GetArenaForAllocation());
4470 }
release_client_token()4471 inline std::string* SubmitSecureAggregationResultRequest::release_client_token() {
4472 // @@protoc_insertion_point(field_release:google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest.client_token)
4473 return _impl_.client_token_.Release();
4474 }
set_allocated_client_token(std::string * client_token)4475 inline void SubmitSecureAggregationResultRequest::set_allocated_client_token(std::string* client_token) {
4476 _impl_.client_token_.SetAllocated(client_token, GetArenaForAllocation());
4477 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4478 if (_impl_.client_token_.IsDefault()) {
4479 _impl_.client_token_.Set("", GetArenaForAllocation());
4480 }
4481 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4482 // @@protoc_insertion_point(field_set_allocated:google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest.client_token)
4483 }
4484
4485 // string masked_result_resource_name = 3;
clear_masked_result_resource_name()4486 inline void SubmitSecureAggregationResultRequest::clear_masked_result_resource_name() {
4487 _impl_.masked_result_resource_name_.ClearToEmpty();
4488 }
masked_result_resource_name()4489 inline const std::string& SubmitSecureAggregationResultRequest::masked_result_resource_name() const {
4490 // @@protoc_insertion_point(field_get:google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest.masked_result_resource_name)
4491 return _internal_masked_result_resource_name();
4492 }
4493 template <typename ArgT0, typename... ArgT>
4494 inline PROTOBUF_ALWAYS_INLINE
set_masked_result_resource_name(ArgT0 && arg0,ArgT...args)4495 void SubmitSecureAggregationResultRequest::set_masked_result_resource_name(ArgT0&& arg0, ArgT... args) {
4496
4497 _impl_.masked_result_resource_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4498 // @@protoc_insertion_point(field_set:google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest.masked_result_resource_name)
4499 }
mutable_masked_result_resource_name()4500 inline std::string* SubmitSecureAggregationResultRequest::mutable_masked_result_resource_name() {
4501 std::string* _s = _internal_mutable_masked_result_resource_name();
4502 // @@protoc_insertion_point(field_mutable:google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest.masked_result_resource_name)
4503 return _s;
4504 }
_internal_masked_result_resource_name()4505 inline const std::string& SubmitSecureAggregationResultRequest::_internal_masked_result_resource_name() const {
4506 return _impl_.masked_result_resource_name_.Get();
4507 }
_internal_set_masked_result_resource_name(const std::string & value)4508 inline void SubmitSecureAggregationResultRequest::_internal_set_masked_result_resource_name(const std::string& value) {
4509
4510 _impl_.masked_result_resource_name_.Set(value, GetArenaForAllocation());
4511 }
_internal_mutable_masked_result_resource_name()4512 inline std::string* SubmitSecureAggregationResultRequest::_internal_mutable_masked_result_resource_name() {
4513
4514 return _impl_.masked_result_resource_name_.Mutable(GetArenaForAllocation());
4515 }
release_masked_result_resource_name()4516 inline std::string* SubmitSecureAggregationResultRequest::release_masked_result_resource_name() {
4517 // @@protoc_insertion_point(field_release:google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest.masked_result_resource_name)
4518 return _impl_.masked_result_resource_name_.Release();
4519 }
set_allocated_masked_result_resource_name(std::string * masked_result_resource_name)4520 inline void SubmitSecureAggregationResultRequest::set_allocated_masked_result_resource_name(std::string* masked_result_resource_name) {
4521 _impl_.masked_result_resource_name_.SetAllocated(masked_result_resource_name, GetArenaForAllocation());
4522 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4523 if (_impl_.masked_result_resource_name_.IsDefault()) {
4524 _impl_.masked_result_resource_name_.Set("", GetArenaForAllocation());
4525 }
4526 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4527 // @@protoc_insertion_point(field_set_allocated:google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest.masked_result_resource_name)
4528 }
4529
4530 // string nonmasked_result_resource_name = 4;
clear_nonmasked_result_resource_name()4531 inline void SubmitSecureAggregationResultRequest::clear_nonmasked_result_resource_name() {
4532 _impl_.nonmasked_result_resource_name_.ClearToEmpty();
4533 }
nonmasked_result_resource_name()4534 inline const std::string& SubmitSecureAggregationResultRequest::nonmasked_result_resource_name() const {
4535 // @@protoc_insertion_point(field_get:google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest.nonmasked_result_resource_name)
4536 return _internal_nonmasked_result_resource_name();
4537 }
4538 template <typename ArgT0, typename... ArgT>
4539 inline PROTOBUF_ALWAYS_INLINE
set_nonmasked_result_resource_name(ArgT0 && arg0,ArgT...args)4540 void SubmitSecureAggregationResultRequest::set_nonmasked_result_resource_name(ArgT0&& arg0, ArgT... args) {
4541
4542 _impl_.nonmasked_result_resource_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4543 // @@protoc_insertion_point(field_set:google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest.nonmasked_result_resource_name)
4544 }
mutable_nonmasked_result_resource_name()4545 inline std::string* SubmitSecureAggregationResultRequest::mutable_nonmasked_result_resource_name() {
4546 std::string* _s = _internal_mutable_nonmasked_result_resource_name();
4547 // @@protoc_insertion_point(field_mutable:google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest.nonmasked_result_resource_name)
4548 return _s;
4549 }
_internal_nonmasked_result_resource_name()4550 inline const std::string& SubmitSecureAggregationResultRequest::_internal_nonmasked_result_resource_name() const {
4551 return _impl_.nonmasked_result_resource_name_.Get();
4552 }
_internal_set_nonmasked_result_resource_name(const std::string & value)4553 inline void SubmitSecureAggregationResultRequest::_internal_set_nonmasked_result_resource_name(const std::string& value) {
4554
4555 _impl_.nonmasked_result_resource_name_.Set(value, GetArenaForAllocation());
4556 }
_internal_mutable_nonmasked_result_resource_name()4557 inline std::string* SubmitSecureAggregationResultRequest::_internal_mutable_nonmasked_result_resource_name() {
4558
4559 return _impl_.nonmasked_result_resource_name_.Mutable(GetArenaForAllocation());
4560 }
release_nonmasked_result_resource_name()4561 inline std::string* SubmitSecureAggregationResultRequest::release_nonmasked_result_resource_name() {
4562 // @@protoc_insertion_point(field_release:google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest.nonmasked_result_resource_name)
4563 return _impl_.nonmasked_result_resource_name_.Release();
4564 }
set_allocated_nonmasked_result_resource_name(std::string * nonmasked_result_resource_name)4565 inline void SubmitSecureAggregationResultRequest::set_allocated_nonmasked_result_resource_name(std::string* nonmasked_result_resource_name) {
4566 _impl_.nonmasked_result_resource_name_.SetAllocated(nonmasked_result_resource_name, GetArenaForAllocation());
4567 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4568 if (_impl_.nonmasked_result_resource_name_.IsDefault()) {
4569 _impl_.nonmasked_result_resource_name_.Set("", GetArenaForAllocation());
4570 }
4571 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4572 // @@protoc_insertion_point(field_set_allocated:google.internal.federatedcompute.v1.SubmitSecureAggregationResultRequest.nonmasked_result_resource_name)
4573 }
4574
4575 // -------------------------------------------------------------------
4576
4577 // SubmitSecureAggregationResultMetadata
4578
4579 // .google.protobuf.Duration polling_interval = 1;
_internal_has_polling_interval()4580 inline bool SubmitSecureAggregationResultMetadata::_internal_has_polling_interval() const {
4581 return this != internal_default_instance() && _impl_.polling_interval_ != nullptr;
4582 }
has_polling_interval()4583 inline bool SubmitSecureAggregationResultMetadata::has_polling_interval() const {
4584 return _internal_has_polling_interval();
4585 }
_internal_polling_interval()4586 inline const ::PROTOBUF_NAMESPACE_ID::Duration& SubmitSecureAggregationResultMetadata::_internal_polling_interval() const {
4587 const ::PROTOBUF_NAMESPACE_ID::Duration* p = _impl_.polling_interval_;
4588 return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Duration&>(
4589 ::PROTOBUF_NAMESPACE_ID::_Duration_default_instance_);
4590 }
polling_interval()4591 inline const ::PROTOBUF_NAMESPACE_ID::Duration& SubmitSecureAggregationResultMetadata::polling_interval() const {
4592 // @@protoc_insertion_point(field_get:google.internal.federatedcompute.v1.SubmitSecureAggregationResultMetadata.polling_interval)
4593 return _internal_polling_interval();
4594 }
unsafe_arena_set_allocated_polling_interval(::PROTOBUF_NAMESPACE_ID::Duration * polling_interval)4595 inline void SubmitSecureAggregationResultMetadata::unsafe_arena_set_allocated_polling_interval(
4596 ::PROTOBUF_NAMESPACE_ID::Duration* polling_interval) {
4597 if (GetArenaForAllocation() == nullptr) {
4598 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.polling_interval_);
4599 }
4600 _impl_.polling_interval_ = polling_interval;
4601 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federatedcompute.v1.SubmitSecureAggregationResultMetadata.polling_interval)
4602 }
release_polling_interval()4603