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