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