1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: fcp/client/selector_context.proto
3
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_fcp_2fclient_2fselector_5fcontext_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_fcp_2fclient_2fselector_5fcontext_2eproto
6
7 #include <cstdint>
8 #include <limits>
9 #include <string>
10
11 #include <google/protobuf/port_def.inc>
12 #if PROTOBUF_VERSION < 3021000
13 #error This file was generated by a newer version of protoc which is
14 #error incompatible with your Protocol Buffer headers. Please update
15 #error your headers.
16 #endif
17 #if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
18 #error This file was generated by an older version of protoc which is
19 #error incompatible with your Protocol Buffer headers. Please
20 #error regenerate this file with a newer version of protoc.
21 #endif
22
23 #include <google/protobuf/port_undef.inc>
24 #include <google/protobuf/io/coded_stream.h>
25 #include <google/protobuf/arena.h>
26 #include <google/protobuf/arenastring.h>
27 #include <google/protobuf/generated_message_util.h>
28 #include <google/protobuf/metadata_lite.h>
29 #include <google/protobuf/message_lite.h>
30 #include <google/protobuf/repeated_field.h> // IWYU pragma: export
31 #include <google/protobuf/extension_set.h> // IWYU pragma: export
32 #include <google/protobuf/map.h> // IWYU pragma: export
33 #include <google/protobuf/map_entry_lite.h>
34 #include <google/protobuf/map_field_lite.h>
35 #include <google/protobuf/generated_enum_util.h>
36 #include <google/protobuf/timestamp.pb.h>
37 // @@protoc_insertion_point(includes)
38 #include <google/protobuf/port_def.inc>
39 #define PROTOBUF_INTERNAL_EXPORT_fcp_2fclient_2fselector_5fcontext_2eproto
40 PROTOBUF_NAMESPACE_OPEN
41 namespace internal {
42 class AnyMetadata;
43 } // namespace internal
44 PROTOBUF_NAMESPACE_CLOSE
45
46 // Internal implementation detail -- do not use these members.
47 struct TableStruct_fcp_2fclient_2fselector_5fcontext_2eproto {
48 static const ::uint32_t offsets[];
49 };
50 namespace fcp {
51 namespace client {
52 class EligibilityEvalComputation;
53 struct EligibilityEvalComputationDefaultTypeInternal;
54 extern EligibilityEvalComputationDefaultTypeInternal _EligibilityEvalComputation_default_instance_;
55 class FederatedComputation;
56 struct FederatedComputationDefaultTypeInternal;
57 extern FederatedComputationDefaultTypeInternal _FederatedComputation_default_instance_;
58 class HistoricalContext;
59 struct HistoricalContextDefaultTypeInternal;
60 extern HistoricalContextDefaultTypeInternal _HistoricalContext_default_instance_;
61 class LocalComputation;
62 struct LocalComputationDefaultTypeInternal;
63 extern LocalComputationDefaultTypeInternal _LocalComputation_default_instance_;
64 class LocalComputation_InputResourceMapEntry_DoNotUse;
65 struct LocalComputation_InputResourceMapEntry_DoNotUseDefaultTypeInternal;
66 extern LocalComputation_InputResourceMapEntry_DoNotUseDefaultTypeInternal _LocalComputation_InputResourceMapEntry_DoNotUse_default_instance_;
67 class QueryTimeComputationProperties;
68 struct QueryTimeComputationPropertiesDefaultTypeInternal;
69 extern QueryTimeComputationPropertiesDefaultTypeInternal _QueryTimeComputationProperties_default_instance_;
70 class SecureAggregation;
71 struct SecureAggregationDefaultTypeInternal;
72 extern SecureAggregationDefaultTypeInternal _SecureAggregation_default_instance_;
73 class SelectorContext;
74 struct SelectorContextDefaultTypeInternal;
75 extern SelectorContextDefaultTypeInternal _SelectorContext_default_instance_;
76 class SimpleAggregation;
77 struct SimpleAggregationDefaultTypeInternal;
78 extern SimpleAggregationDefaultTypeInternal _SimpleAggregation_default_instance_;
79 } // namespace client
80 } // namespace fcp
81 PROTOBUF_NAMESPACE_OPEN
82 template<> ::fcp::client::EligibilityEvalComputation* Arena::CreateMaybeMessage<::fcp::client::EligibilityEvalComputation>(Arena*);
83 template<> ::fcp::client::FederatedComputation* Arena::CreateMaybeMessage<::fcp::client::FederatedComputation>(Arena*);
84 template<> ::fcp::client::HistoricalContext* Arena::CreateMaybeMessage<::fcp::client::HistoricalContext>(Arena*);
85 template<> ::fcp::client::LocalComputation* Arena::CreateMaybeMessage<::fcp::client::LocalComputation>(Arena*);
86 template<> ::fcp::client::LocalComputation_InputResourceMapEntry_DoNotUse* Arena::CreateMaybeMessage<::fcp::client::LocalComputation_InputResourceMapEntry_DoNotUse>(Arena*);
87 template<> ::fcp::client::QueryTimeComputationProperties* Arena::CreateMaybeMessage<::fcp::client::QueryTimeComputationProperties>(Arena*);
88 template<> ::fcp::client::SecureAggregation* Arena::CreateMaybeMessage<::fcp::client::SecureAggregation>(Arena*);
89 template<> ::fcp::client::SelectorContext* Arena::CreateMaybeMessage<::fcp::client::SelectorContext>(Arena*);
90 template<> ::fcp::client::SimpleAggregation* Arena::CreateMaybeMessage<::fcp::client::SimpleAggregation>(Arena*);
91 PROTOBUF_NAMESPACE_CLOSE
92 namespace fcp {
93 namespace client {
94
95 enum QueryTimeComputationProperties_ExampleIteratorOutputFormat : int {
96 QueryTimeComputationProperties_ExampleIteratorOutputFormat_EXAMPLE_ITERATOR_OUTPUT_FORMAT_UNSPECIFIED = 0,
97 QueryTimeComputationProperties_ExampleIteratorOutputFormat_EXAMPLE_QUERY_RESULT = 1,
98 QueryTimeComputationProperties_ExampleIteratorOutputFormat_QueryTimeComputationProperties_ExampleIteratorOutputFormat_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::min(),
99 QueryTimeComputationProperties_ExampleIteratorOutputFormat_QueryTimeComputationProperties_ExampleIteratorOutputFormat_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::max()
100 };
101 bool QueryTimeComputationProperties_ExampleIteratorOutputFormat_IsValid(int value);
102 constexpr QueryTimeComputationProperties_ExampleIteratorOutputFormat QueryTimeComputationProperties_ExampleIteratorOutputFormat_ExampleIteratorOutputFormat_MIN = QueryTimeComputationProperties_ExampleIteratorOutputFormat_EXAMPLE_ITERATOR_OUTPUT_FORMAT_UNSPECIFIED;
103 constexpr QueryTimeComputationProperties_ExampleIteratorOutputFormat QueryTimeComputationProperties_ExampleIteratorOutputFormat_ExampleIteratorOutputFormat_MAX = QueryTimeComputationProperties_ExampleIteratorOutputFormat_EXAMPLE_QUERY_RESULT;
104 constexpr int QueryTimeComputationProperties_ExampleIteratorOutputFormat_ExampleIteratorOutputFormat_ARRAYSIZE = QueryTimeComputationProperties_ExampleIteratorOutputFormat_ExampleIteratorOutputFormat_MAX + 1;
105
106 const std::string& QueryTimeComputationProperties_ExampleIteratorOutputFormat_Name(QueryTimeComputationProperties_ExampleIteratorOutputFormat value);
107 template<typename T>
QueryTimeComputationProperties_ExampleIteratorOutputFormat_Name(T enum_t_value)108 inline const std::string& QueryTimeComputationProperties_ExampleIteratorOutputFormat_Name(T enum_t_value) {
109 static_assert(::std::is_same<T, QueryTimeComputationProperties_ExampleIteratorOutputFormat>::value ||
110 ::std::is_integral<T>::value,
111 "Incorrect type passed to function QueryTimeComputationProperties_ExampleIteratorOutputFormat_Name.");
112 return QueryTimeComputationProperties_ExampleIteratorOutputFormat_Name(static_cast<QueryTimeComputationProperties_ExampleIteratorOutputFormat>(enum_t_value));
113 }
114 bool QueryTimeComputationProperties_ExampleIteratorOutputFormat_Parse(
115 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, QueryTimeComputationProperties_ExampleIteratorOutputFormat* value);
116 // ===================================================================
117
118 class SelectorContext final :
119 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:fcp.client.SelectorContext) */ {
120 public:
SelectorContext()121 inline SelectorContext() : SelectorContext(nullptr) {}
122 ~SelectorContext() override;
123 explicit PROTOBUF_CONSTEXPR SelectorContext(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
124
125 SelectorContext(const SelectorContext& from);
SelectorContext(SelectorContext && from)126 SelectorContext(SelectorContext&& from) noexcept
127 : SelectorContext() {
128 *this = ::std::move(from);
129 }
130
131 inline SelectorContext& operator=(const SelectorContext& from) {
132 if (this == &from) return *this;
133 CopyFrom(from);
134 return *this;
135 }
136 inline SelectorContext& operator=(SelectorContext&& from) noexcept {
137 if (this == &from) return *this;
138 if (GetOwningArena() == from.GetOwningArena()
139 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
140 && GetOwningArena() != nullptr
141 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
142 ) {
143 InternalSwap(&from);
144 } else {
145 CopyFrom(from);
146 }
147 return *this;
148 }
149
default_instance()150 static const SelectorContext& default_instance() {
151 return *internal_default_instance();
152 }
internal_default_instance()153 static inline const SelectorContext* internal_default_instance() {
154 return reinterpret_cast<const SelectorContext*>(
155 &_SelectorContext_default_instance_);
156 }
157 static constexpr int kIndexInFileMessages =
158 0;
159
swap(SelectorContext & a,SelectorContext & b)160 friend void swap(SelectorContext& a, SelectorContext& b) {
161 a.Swap(&b);
162 }
Swap(SelectorContext * other)163 inline void Swap(SelectorContext* other) {
164 if (other == this) return;
165 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
166 if (GetOwningArena() != nullptr &&
167 GetOwningArena() == other->GetOwningArena()) {
168 #else // PROTOBUF_FORCE_COPY_IN_SWAP
169 if (GetOwningArena() == other->GetOwningArena()) {
170 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
171 InternalSwap(other);
172 } else {
173 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
174 }
175 }
176 void UnsafeArenaSwap(SelectorContext* other) {
177 if (other == this) return;
178 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
179 InternalSwap(other);
180 }
181
182 // implements Message ----------------------------------------------
183
184 SelectorContext* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
185 return CreateMaybeMessage<SelectorContext>(arena);
186 }
187 SelectorContext* New() const {
188 return New(nullptr);
189 }
190 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
191 void CopyFrom(const SelectorContext& from);
192 void MergeFrom(const SelectorContext& from);
193 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
194 bool IsInitialized() const final;
195
196 size_t ByteSizeLong() const final;
197 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
198 ::uint8_t* _InternalSerialize(
199 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
200 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
201
202 private:
203 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
204 void SharedDtor();
205 void SetCachedSize(int size) const;
206 void InternalSwap(SelectorContext* other);
207
208 private:
209 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
210 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
211 return "fcp.client.SelectorContext";
212 }
213 protected:
214 explicit SelectorContext(::PROTOBUF_NAMESPACE_ID::Arena* arena,
215 bool is_message_owned = false);
216 public:
217
218 std::string GetTypeName() const final;
219
220 // nested types ----------------------------------------------------
221
222 // accessors -------------------------------------------------------
223
224 enum : int {
225 kComputationPropertiesFieldNumber = 1,
226 };
227 // .fcp.client.QueryTimeComputationProperties computation_properties = 1;
228 bool has_computation_properties() const;
229 private:
230 bool _internal_has_computation_properties() const;
231 public:
232 void clear_computation_properties();
233 const ::fcp::client::QueryTimeComputationProperties& computation_properties() const;
234 PROTOBUF_NODISCARD ::fcp::client::QueryTimeComputationProperties* release_computation_properties();
235 ::fcp::client::QueryTimeComputationProperties* mutable_computation_properties();
236 void set_allocated_computation_properties(::fcp::client::QueryTimeComputationProperties* computation_properties);
237 private:
238 const ::fcp::client::QueryTimeComputationProperties& _internal_computation_properties() const;
239 ::fcp::client::QueryTimeComputationProperties* _internal_mutable_computation_properties();
240 public:
241 void unsafe_arena_set_allocated_computation_properties(
242 ::fcp::client::QueryTimeComputationProperties* computation_properties);
243 ::fcp::client::QueryTimeComputationProperties* unsafe_arena_release_computation_properties();
244
245 // @@protoc_insertion_point(class_scope:fcp.client.SelectorContext)
246 private:
247 class _Internal;
248
249 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
250 typedef void InternalArenaConstructable_;
251 typedef void DestructorSkippable_;
252 struct Impl_ {
253 ::fcp::client::QueryTimeComputationProperties* computation_properties_;
254 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
255 };
256 union { Impl_ _impl_; };
257 friend struct ::TableStruct_fcp_2fclient_2fselector_5fcontext_2eproto;
258 };
259 // -------------------------------------------------------------------
260
261 class QueryTimeComputationProperties final :
262 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:fcp.client.QueryTimeComputationProperties) */ {
263 public:
QueryTimeComputationProperties()264 inline QueryTimeComputationProperties() : QueryTimeComputationProperties(nullptr) {}
265 ~QueryTimeComputationProperties() override;
266 explicit PROTOBUF_CONSTEXPR QueryTimeComputationProperties(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
267
268 QueryTimeComputationProperties(const QueryTimeComputationProperties& from);
QueryTimeComputationProperties(QueryTimeComputationProperties && from)269 QueryTimeComputationProperties(QueryTimeComputationProperties&& from) noexcept
270 : QueryTimeComputationProperties() {
271 *this = ::std::move(from);
272 }
273
274 inline QueryTimeComputationProperties& operator=(const QueryTimeComputationProperties& from) {
275 if (this == &from) return *this;
276 CopyFrom(from);
277 return *this;
278 }
279 inline QueryTimeComputationProperties& operator=(QueryTimeComputationProperties&& from) noexcept {
280 if (this == &from) return *this;
281 if (GetOwningArena() == from.GetOwningArena()
282 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
283 && GetOwningArena() != nullptr
284 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
285 ) {
286 InternalSwap(&from);
287 } else {
288 CopyFrom(from);
289 }
290 return *this;
291 }
292
default_instance()293 static const QueryTimeComputationProperties& default_instance() {
294 return *internal_default_instance();
295 }
296 enum ComputationTypeCase {
297 kLocalCompute = 2,
298 kEligibilityEval = 3,
299 kFederated = 4,
300 COMPUTATION_TYPE_NOT_SET = 0,
301 };
302
internal_default_instance()303 static inline const QueryTimeComputationProperties* internal_default_instance() {
304 return reinterpret_cast<const QueryTimeComputationProperties*>(
305 &_QueryTimeComputationProperties_default_instance_);
306 }
307 static constexpr int kIndexInFileMessages =
308 1;
309
swap(QueryTimeComputationProperties & a,QueryTimeComputationProperties & b)310 friend void swap(QueryTimeComputationProperties& a, QueryTimeComputationProperties& b) {
311 a.Swap(&b);
312 }
Swap(QueryTimeComputationProperties * other)313 inline void Swap(QueryTimeComputationProperties* other) {
314 if (other == this) return;
315 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
316 if (GetOwningArena() != nullptr &&
317 GetOwningArena() == other->GetOwningArena()) {
318 #else // PROTOBUF_FORCE_COPY_IN_SWAP
319 if (GetOwningArena() == other->GetOwningArena()) {
320 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
321 InternalSwap(other);
322 } else {
323 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
324 }
325 }
326 void UnsafeArenaSwap(QueryTimeComputationProperties* other) {
327 if (other == this) return;
328 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
329 InternalSwap(other);
330 }
331
332 // implements Message ----------------------------------------------
333
334 QueryTimeComputationProperties* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
335 return CreateMaybeMessage<QueryTimeComputationProperties>(arena);
336 }
337 QueryTimeComputationProperties* New() const {
338 return New(nullptr);
339 }
340 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
341 void CopyFrom(const QueryTimeComputationProperties& from);
342 void MergeFrom(const QueryTimeComputationProperties& from);
343 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
344 bool IsInitialized() const final;
345
346 size_t ByteSizeLong() const final;
347 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
348 ::uint8_t* _InternalSerialize(
349 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
350 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
351
352 private:
353 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
354 void SharedDtor();
355 void SetCachedSize(int size) const;
356 void InternalSwap(QueryTimeComputationProperties* other);
357
358 private:
359 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
360 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
361 return "fcp.client.QueryTimeComputationProperties";
362 }
363 protected:
364 explicit QueryTimeComputationProperties(::PROTOBUF_NAMESPACE_ID::Arena* arena,
365 bool is_message_owned = false);
366 public:
367
368 std::string GetTypeName() const final;
369
370 // nested types ----------------------------------------------------
371
372 typedef QueryTimeComputationProperties_ExampleIteratorOutputFormat ExampleIteratorOutputFormat;
373 static constexpr ExampleIteratorOutputFormat EXAMPLE_ITERATOR_OUTPUT_FORMAT_UNSPECIFIED =
374 QueryTimeComputationProperties_ExampleIteratorOutputFormat_EXAMPLE_ITERATOR_OUTPUT_FORMAT_UNSPECIFIED;
375 static constexpr ExampleIteratorOutputFormat EXAMPLE_QUERY_RESULT =
376 QueryTimeComputationProperties_ExampleIteratorOutputFormat_EXAMPLE_QUERY_RESULT;
377 static inline bool ExampleIteratorOutputFormat_IsValid(int value) {
378 return QueryTimeComputationProperties_ExampleIteratorOutputFormat_IsValid(value);
379 }
380 static constexpr ExampleIteratorOutputFormat ExampleIteratorOutputFormat_MIN =
381 QueryTimeComputationProperties_ExampleIteratorOutputFormat_ExampleIteratorOutputFormat_MIN;
382 static constexpr ExampleIteratorOutputFormat ExampleIteratorOutputFormat_MAX =
383 QueryTimeComputationProperties_ExampleIteratorOutputFormat_ExampleIteratorOutputFormat_MAX;
384 static constexpr int ExampleIteratorOutputFormat_ARRAYSIZE =
385 QueryTimeComputationProperties_ExampleIteratorOutputFormat_ExampleIteratorOutputFormat_ARRAYSIZE;
386 template<typename T>
387 static inline const std::string& ExampleIteratorOutputFormat_Name(T enum_t_value) {
388 static_assert(::std::is_same<T, ExampleIteratorOutputFormat>::value ||
389 ::std::is_integral<T>::value,
390 "Incorrect type passed to function ExampleIteratorOutputFormat_Name.");
391 return QueryTimeComputationProperties_ExampleIteratorOutputFormat_Name(enum_t_value);
392 }
393 static inline bool ExampleIteratorOutputFormat_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
394 ExampleIteratorOutputFormat* value) {
395 return QueryTimeComputationProperties_ExampleIteratorOutputFormat_Parse(name, value);
396 }
397
398 // accessors -------------------------------------------------------
399
400 enum : int {
401 kSessionNameFieldNumber = 1,
402 kContextDataFieldNumber = 6,
403 kRunIdFieldNumber = 5,
404 kExampleIteratorOutputFormatFieldNumber = 7,
405 kLocalComputeFieldNumber = 2,
406 kEligibilityEvalFieldNumber = 3,
407 kFederatedFieldNumber = 4,
408 };
409 // string session_name = 1;
410 void clear_session_name();
411 const std::string& session_name() const;
412 template <typename ArgT0 = const std::string&, typename... ArgT>
413 void set_session_name(ArgT0&& arg0, ArgT... args);
414 std::string* mutable_session_name();
415 PROTOBUF_NODISCARD std::string* release_session_name();
416 void set_allocated_session_name(std::string* session_name);
417 private:
418 const std::string& _internal_session_name() const;
419 inline PROTOBUF_ALWAYS_INLINE void _internal_set_session_name(const std::string& value);
420 std::string* _internal_mutable_session_name();
421 public:
422
423 // bytes context_data = 6;
424 void clear_context_data();
425 const std::string& context_data() const;
426 template <typename ArgT0 = const std::string&, typename... ArgT>
427 void set_context_data(ArgT0&& arg0, ArgT... args);
428 std::string* mutable_context_data();
429 PROTOBUF_NODISCARD std::string* release_context_data();
430 void set_allocated_context_data(std::string* context_data);
431 private:
432 const std::string& _internal_context_data() const;
433 inline PROTOBUF_ALWAYS_INLINE void _internal_set_context_data(const std::string& value);
434 std::string* _internal_mutable_context_data();
435 public:
436
437 // int64 run_id = 5;
438 void clear_run_id();
439 ::int64_t run_id() const;
440 void set_run_id(::int64_t value);
441 private:
442 ::int64_t _internal_run_id() const;
443 void _internal_set_run_id(::int64_t value);
444 public:
445
446 // .fcp.client.QueryTimeComputationProperties.ExampleIteratorOutputFormat example_iterator_output_format = 7;
447 void clear_example_iterator_output_format();
448 ::fcp::client::QueryTimeComputationProperties_ExampleIteratorOutputFormat example_iterator_output_format() const;
449 void set_example_iterator_output_format(::fcp::client::QueryTimeComputationProperties_ExampleIteratorOutputFormat value);
450 private:
451 ::fcp::client::QueryTimeComputationProperties_ExampleIteratorOutputFormat _internal_example_iterator_output_format() const;
452 void _internal_set_example_iterator_output_format(::fcp::client::QueryTimeComputationProperties_ExampleIteratorOutputFormat value);
453 public:
454
455 // .fcp.client.LocalComputation local_compute = 2;
456 bool has_local_compute() const;
457 private:
458 bool _internal_has_local_compute() const;
459 public:
460 void clear_local_compute();
461 const ::fcp::client::LocalComputation& local_compute() const;
462 PROTOBUF_NODISCARD ::fcp::client::LocalComputation* release_local_compute();
463 ::fcp::client::LocalComputation* mutable_local_compute();
464 void set_allocated_local_compute(::fcp::client::LocalComputation* local_compute);
465 private:
466 const ::fcp::client::LocalComputation& _internal_local_compute() const;
467 ::fcp::client::LocalComputation* _internal_mutable_local_compute();
468 public:
469 void unsafe_arena_set_allocated_local_compute(
470 ::fcp::client::LocalComputation* local_compute);
471 ::fcp::client::LocalComputation* unsafe_arena_release_local_compute();
472
473 // .fcp.client.EligibilityEvalComputation eligibility_eval = 3;
474 bool has_eligibility_eval() const;
475 private:
476 bool _internal_has_eligibility_eval() const;
477 public:
478 void clear_eligibility_eval();
479 const ::fcp::client::EligibilityEvalComputation& eligibility_eval() const;
480 PROTOBUF_NODISCARD ::fcp::client::EligibilityEvalComputation* release_eligibility_eval();
481 ::fcp::client::EligibilityEvalComputation* mutable_eligibility_eval();
482 void set_allocated_eligibility_eval(::fcp::client::EligibilityEvalComputation* eligibility_eval);
483 private:
484 const ::fcp::client::EligibilityEvalComputation& _internal_eligibility_eval() const;
485 ::fcp::client::EligibilityEvalComputation* _internal_mutable_eligibility_eval();
486 public:
487 void unsafe_arena_set_allocated_eligibility_eval(
488 ::fcp::client::EligibilityEvalComputation* eligibility_eval);
489 ::fcp::client::EligibilityEvalComputation* unsafe_arena_release_eligibility_eval();
490
491 // .fcp.client.FederatedComputation federated = 4;
492 bool has_federated() const;
493 private:
494 bool _internal_has_federated() const;
495 public:
496 void clear_federated();
497 const ::fcp::client::FederatedComputation& federated() const;
498 PROTOBUF_NODISCARD ::fcp::client::FederatedComputation* release_federated();
499 ::fcp::client::FederatedComputation* mutable_federated();
500 void set_allocated_federated(::fcp::client::FederatedComputation* federated);
501 private:
502 const ::fcp::client::FederatedComputation& _internal_federated() const;
503 ::fcp::client::FederatedComputation* _internal_mutable_federated();
504 public:
505 void unsafe_arena_set_allocated_federated(
506 ::fcp::client::FederatedComputation* federated);
507 ::fcp::client::FederatedComputation* unsafe_arena_release_federated();
508
509 void clear_computation_type();
510 ComputationTypeCase computation_type_case() const;
511 // @@protoc_insertion_point(class_scope:fcp.client.QueryTimeComputationProperties)
512 private:
513 class _Internal;
514 void set_has_local_compute();
515 void set_has_eligibility_eval();
516 void set_has_federated();
517
518 inline bool has_computation_type() const;
519 inline void clear_has_computation_type();
520
521 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
522 typedef void InternalArenaConstructable_;
523 typedef void DestructorSkippable_;
524 struct Impl_ {
525 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr session_name_;
526 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr context_data_;
527 ::int64_t run_id_;
528 int example_iterator_output_format_;
529 union ComputationTypeUnion {
530 constexpr ComputationTypeUnion() : _constinit_{} {}
531 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
532 ::fcp::client::LocalComputation* local_compute_;
533 ::fcp::client::EligibilityEvalComputation* eligibility_eval_;
534 ::fcp::client::FederatedComputation* federated_;
535 } computation_type_;
536 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
537 ::uint32_t _oneof_case_[1];
538
539 };
540 union { Impl_ _impl_; };
541 friend struct ::TableStruct_fcp_2fclient_2fselector_5fcontext_2eproto;
542 };
543 // -------------------------------------------------------------------
544
545 class LocalComputation_InputResourceMapEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<LocalComputation_InputResourceMapEntry_DoNotUse,
546 std::string, std::string,
547 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
548 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> {
549 public:
550 typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<LocalComputation_InputResourceMapEntry_DoNotUse,
551 std::string, std::string,
552 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
553 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> SuperType;
554 LocalComputation_InputResourceMapEntry_DoNotUse();
555 explicit PROTOBUF_CONSTEXPR LocalComputation_InputResourceMapEntry_DoNotUse(
556 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
557 explicit LocalComputation_InputResourceMapEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
558 void MergeFrom(const LocalComputation_InputResourceMapEntry_DoNotUse& other);
internal_default_instance()559 static const LocalComputation_InputResourceMapEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const LocalComputation_InputResourceMapEntry_DoNotUse*>(&_LocalComputation_InputResourceMapEntry_DoNotUse_default_instance_); }
ValidateKey(std::string * s)560 static bool ValidateKey(std::string* s) {
561 return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "fcp.client.LocalComputation.InputResourceMapEntry.key");
562 }
ValidateValue(std::string * s)563 static bool ValidateValue(std::string* s) {
564 return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "fcp.client.LocalComputation.InputResourceMapEntry.value");
565 }
566 friend struct ::TableStruct_fcp_2fclient_2fselector_5fcontext_2eproto;
567 };
568
569 // -------------------------------------------------------------------
570
571 class LocalComputation final :
572 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:fcp.client.LocalComputation) */ {
573 public:
LocalComputation()574 inline LocalComputation() : LocalComputation(nullptr) {}
575 ~LocalComputation() override;
576 explicit PROTOBUF_CONSTEXPR LocalComputation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
577
578 LocalComputation(const LocalComputation& from);
LocalComputation(LocalComputation && from)579 LocalComputation(LocalComputation&& from) noexcept
580 : LocalComputation() {
581 *this = ::std::move(from);
582 }
583
584 inline LocalComputation& operator=(const LocalComputation& from) {
585 if (this == &from) return *this;
586 CopyFrom(from);
587 return *this;
588 }
589 inline LocalComputation& operator=(LocalComputation&& from) noexcept {
590 if (this == &from) return *this;
591 if (GetOwningArena() == from.GetOwningArena()
592 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
593 && GetOwningArena() != nullptr
594 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
595 ) {
596 InternalSwap(&from);
597 } else {
598 CopyFrom(from);
599 }
600 return *this;
601 }
602
default_instance()603 static const LocalComputation& default_instance() {
604 return *internal_default_instance();
605 }
internal_default_instance()606 static inline const LocalComputation* internal_default_instance() {
607 return reinterpret_cast<const LocalComputation*>(
608 &_LocalComputation_default_instance_);
609 }
610 static constexpr int kIndexInFileMessages =
611 3;
612
swap(LocalComputation & a,LocalComputation & b)613 friend void swap(LocalComputation& a, LocalComputation& b) {
614 a.Swap(&b);
615 }
Swap(LocalComputation * other)616 inline void Swap(LocalComputation* other) {
617 if (other == this) return;
618 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
619 if (GetOwningArena() != nullptr &&
620 GetOwningArena() == other->GetOwningArena()) {
621 #else // PROTOBUF_FORCE_COPY_IN_SWAP
622 if (GetOwningArena() == other->GetOwningArena()) {
623 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
624 InternalSwap(other);
625 } else {
626 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
627 }
628 }
629 void UnsafeArenaSwap(LocalComputation* other) {
630 if (other == this) return;
631 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
632 InternalSwap(other);
633 }
634
635 // implements Message ----------------------------------------------
636
637 LocalComputation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
638 return CreateMaybeMessage<LocalComputation>(arena);
639 }
640 LocalComputation* New() const {
641 return New(nullptr);
642 }
643 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
644 void CopyFrom(const LocalComputation& from);
645 void MergeFrom(const LocalComputation& from);
646 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
647 bool IsInitialized() const final;
648
649 size_t ByteSizeLong() const final;
650 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
651 ::uint8_t* _InternalSerialize(
652 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
653 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
654
655 private:
656 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
657 void SharedDtor();
658 void SetCachedSize(int size) const;
659 void InternalSwap(LocalComputation* other);
660
661 private:
662 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
663 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
664 return "fcp.client.LocalComputation";
665 }
666 protected:
667 explicit LocalComputation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
668 bool is_message_owned = false);
669 public:
670
671 std::string GetTypeName() const final;
672
673 // nested types ----------------------------------------------------
674
675
676 // accessors -------------------------------------------------------
677
678 enum : int {
679 kInputResourceMapFieldNumber = 3,
680 kInputDirFieldNumber = 1,
681 kOutputDirFieldNumber = 2,
682 };
683 // map<string, string> input_resource_map = 3;
684 int input_resource_map_size() const;
685 private:
686 int _internal_input_resource_map_size() const;
687 public:
688 void clear_input_resource_map();
689 private:
690 const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
691 _internal_input_resource_map() const;
692 ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
693 _internal_mutable_input_resource_map();
694 public:
695 const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
696 input_resource_map() const;
697 ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
698 mutable_input_resource_map();
699
700 // string input_dir = 1;
701 void clear_input_dir();
702 const std::string& input_dir() const;
703 template <typename ArgT0 = const std::string&, typename... ArgT>
704 void set_input_dir(ArgT0&& arg0, ArgT... args);
705 std::string* mutable_input_dir();
706 PROTOBUF_NODISCARD std::string* release_input_dir();
707 void set_allocated_input_dir(std::string* input_dir);
708 private:
709 const std::string& _internal_input_dir() const;
710 inline PROTOBUF_ALWAYS_INLINE void _internal_set_input_dir(const std::string& value);
711 std::string* _internal_mutable_input_dir();
712 public:
713
714 // string output_dir = 2;
715 void clear_output_dir();
716 const std::string& output_dir() const;
717 template <typename ArgT0 = const std::string&, typename... ArgT>
718 void set_output_dir(ArgT0&& arg0, ArgT... args);
719 std::string* mutable_output_dir();
720 PROTOBUF_NODISCARD std::string* release_output_dir();
721 void set_allocated_output_dir(std::string* output_dir);
722 private:
723 const std::string& _internal_output_dir() const;
724 inline PROTOBUF_ALWAYS_INLINE void _internal_set_output_dir(const std::string& value);
725 std::string* _internal_mutable_output_dir();
726 public:
727
728 // @@protoc_insertion_point(class_scope:fcp.client.LocalComputation)
729 private:
730 class _Internal;
731
732 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
733 typedef void InternalArenaConstructable_;
734 typedef void DestructorSkippable_;
735 struct Impl_ {
736 ::PROTOBUF_NAMESPACE_ID::internal::MapFieldLite<
737 LocalComputation_InputResourceMapEntry_DoNotUse,
738 std::string, std::string,
739 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
740 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> input_resource_map_;
741 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr input_dir_;
742 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr output_dir_;
743 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
744 };
745 union { Impl_ _impl_; };
746 friend struct ::TableStruct_fcp_2fclient_2fselector_5fcontext_2eproto;
747 };
748 // -------------------------------------------------------------------
749
750 class EligibilityEvalComputation final :
751 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:fcp.client.EligibilityEvalComputation) */ {
752 public:
EligibilityEvalComputation()753 inline EligibilityEvalComputation() : EligibilityEvalComputation(nullptr) {}
754 ~EligibilityEvalComputation() override;
755 explicit PROTOBUF_CONSTEXPR EligibilityEvalComputation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
756
757 EligibilityEvalComputation(const EligibilityEvalComputation& from);
EligibilityEvalComputation(EligibilityEvalComputation && from)758 EligibilityEvalComputation(EligibilityEvalComputation&& from) noexcept
759 : EligibilityEvalComputation() {
760 *this = ::std::move(from);
761 }
762
763 inline EligibilityEvalComputation& operator=(const EligibilityEvalComputation& from) {
764 if (this == &from) return *this;
765 CopyFrom(from);
766 return *this;
767 }
768 inline EligibilityEvalComputation& operator=(EligibilityEvalComputation&& from) noexcept {
769 if (this == &from) return *this;
770 if (GetOwningArena() == from.GetOwningArena()
771 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
772 && GetOwningArena() != nullptr
773 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
774 ) {
775 InternalSwap(&from);
776 } else {
777 CopyFrom(from);
778 }
779 return *this;
780 }
781
default_instance()782 static const EligibilityEvalComputation& default_instance() {
783 return *internal_default_instance();
784 }
internal_default_instance()785 static inline const EligibilityEvalComputation* internal_default_instance() {
786 return reinterpret_cast<const EligibilityEvalComputation*>(
787 &_EligibilityEvalComputation_default_instance_);
788 }
789 static constexpr int kIndexInFileMessages =
790 4;
791
swap(EligibilityEvalComputation & a,EligibilityEvalComputation & b)792 friend void swap(EligibilityEvalComputation& a, EligibilityEvalComputation& b) {
793 a.Swap(&b);
794 }
Swap(EligibilityEvalComputation * other)795 inline void Swap(EligibilityEvalComputation* other) {
796 if (other == this) return;
797 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
798 if (GetOwningArena() != nullptr &&
799 GetOwningArena() == other->GetOwningArena()) {
800 #else // PROTOBUF_FORCE_COPY_IN_SWAP
801 if (GetOwningArena() == other->GetOwningArena()) {
802 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
803 InternalSwap(other);
804 } else {
805 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
806 }
807 }
808 void UnsafeArenaSwap(EligibilityEvalComputation* other) {
809 if (other == this) return;
810 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
811 InternalSwap(other);
812 }
813
814 // implements Message ----------------------------------------------
815
816 EligibilityEvalComputation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
817 return CreateMaybeMessage<EligibilityEvalComputation>(arena);
818 }
819 EligibilityEvalComputation* New() const {
820 return New(nullptr);
821 }
822 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
823 void CopyFrom(const EligibilityEvalComputation& from);
824 void MergeFrom(const EligibilityEvalComputation& from);
825 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
826 bool IsInitialized() const final;
827
828 size_t ByteSizeLong() const final;
829 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
830 ::uint8_t* _InternalSerialize(
831 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
832 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
833
834 private:
835 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
836 void SharedDtor();
837 void SetCachedSize(int size) const;
838 void InternalSwap(EligibilityEvalComputation* other);
839
840 private:
841 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
842 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
843 return "fcp.client.EligibilityEvalComputation";
844 }
845 protected:
846 explicit EligibilityEvalComputation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
847 bool is_message_owned = false);
848 public:
849
850 std::string GetTypeName() const final;
851
852 // nested types ----------------------------------------------------
853
854 // accessors -------------------------------------------------------
855
856 enum : int {
857 kPopulationNameFieldNumber = 1,
858 };
859 // string population_name = 1;
860 void clear_population_name();
861 const std::string& population_name() const;
862 template <typename ArgT0 = const std::string&, typename... ArgT>
863 void set_population_name(ArgT0&& arg0, ArgT... args);
864 std::string* mutable_population_name();
865 PROTOBUF_NODISCARD std::string* release_population_name();
866 void set_allocated_population_name(std::string* population_name);
867 private:
868 const std::string& _internal_population_name() const;
869 inline PROTOBUF_ALWAYS_INLINE void _internal_set_population_name(const std::string& value);
870 std::string* _internal_mutable_population_name();
871 public:
872
873 // @@protoc_insertion_point(class_scope:fcp.client.EligibilityEvalComputation)
874 private:
875 class _Internal;
876
877 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
878 typedef void InternalArenaConstructable_;
879 typedef void DestructorSkippable_;
880 struct Impl_ {
881 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr population_name_;
882 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
883 };
884 union { Impl_ _impl_; };
885 friend struct ::TableStruct_fcp_2fclient_2fselector_5fcontext_2eproto;
886 };
887 // -------------------------------------------------------------------
888
889 class FederatedComputation final :
890 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:fcp.client.FederatedComputation) */ {
891 public:
FederatedComputation()892 inline FederatedComputation() : FederatedComputation(nullptr) {}
893 ~FederatedComputation() override;
894 explicit PROTOBUF_CONSTEXPR FederatedComputation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
895
896 FederatedComputation(const FederatedComputation& from);
FederatedComputation(FederatedComputation && from)897 FederatedComputation(FederatedComputation&& from) noexcept
898 : FederatedComputation() {
899 *this = ::std::move(from);
900 }
901
902 inline FederatedComputation& operator=(const FederatedComputation& from) {
903 if (this == &from) return *this;
904 CopyFrom(from);
905 return *this;
906 }
907 inline FederatedComputation& operator=(FederatedComputation&& from) noexcept {
908 if (this == &from) return *this;
909 if (GetOwningArena() == from.GetOwningArena()
910 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
911 && GetOwningArena() != nullptr
912 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
913 ) {
914 InternalSwap(&from);
915 } else {
916 CopyFrom(from);
917 }
918 return *this;
919 }
920
default_instance()921 static const FederatedComputation& default_instance() {
922 return *internal_default_instance();
923 }
924 enum AggregationTypeCase {
925 kSimpleAggregation = 3,
926 kSecureAggregation = 4,
927 AGGREGATION_TYPE_NOT_SET = 0,
928 };
929
internal_default_instance()930 static inline const FederatedComputation* internal_default_instance() {
931 return reinterpret_cast<const FederatedComputation*>(
932 &_FederatedComputation_default_instance_);
933 }
934 static constexpr int kIndexInFileMessages =
935 5;
936
swap(FederatedComputation & a,FederatedComputation & b)937 friend void swap(FederatedComputation& a, FederatedComputation& b) {
938 a.Swap(&b);
939 }
Swap(FederatedComputation * other)940 inline void Swap(FederatedComputation* other) {
941 if (other == this) return;
942 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
943 if (GetOwningArena() != nullptr &&
944 GetOwningArena() == other->GetOwningArena()) {
945 #else // PROTOBUF_FORCE_COPY_IN_SWAP
946 if (GetOwningArena() == other->GetOwningArena()) {
947 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
948 InternalSwap(other);
949 } else {
950 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
951 }
952 }
953 void UnsafeArenaSwap(FederatedComputation* other) {
954 if (other == this) return;
955 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
956 InternalSwap(other);
957 }
958
959 // implements Message ----------------------------------------------
960
961 FederatedComputation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
962 return CreateMaybeMessage<FederatedComputation>(arena);
963 }
964 FederatedComputation* New() const {
965 return New(nullptr);
966 }
967 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
968 void CopyFrom(const FederatedComputation& from);
969 void MergeFrom(const FederatedComputation& from);
970 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
971 bool IsInitialized() const final;
972
973 size_t ByteSizeLong() const final;
974 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
975 ::uint8_t* _InternalSerialize(
976 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
977 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
978
979 private:
980 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
981 void SharedDtor();
982 void SetCachedSize(int size) const;
983 void InternalSwap(FederatedComputation* other);
984
985 private:
986 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
987 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
988 return "fcp.client.FederatedComputation";
989 }
990 protected:
991 explicit FederatedComputation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
992 bool is_message_owned = false);
993 public:
994
995 std::string GetTypeName() const final;
996
997 // nested types ----------------------------------------------------
998
999 // accessors -------------------------------------------------------
1000
1001 enum : int {
1002 kPopulationNameFieldNumber = 1,
1003 kTaskNameFieldNumber = 2,
1004 kComputationIdFieldNumber = 5,
1005 kHistoricalContextFieldNumber = 6,
1006 kSimpleAggregationFieldNumber = 3,
1007 kSecureAggregationFieldNumber = 4,
1008 };
1009 // string population_name = 1;
1010 void clear_population_name();
1011 const std::string& population_name() const;
1012 template <typename ArgT0 = const std::string&, typename... ArgT>
1013 void set_population_name(ArgT0&& arg0, ArgT... args);
1014 std::string* mutable_population_name();
1015 PROTOBUF_NODISCARD std::string* release_population_name();
1016 void set_allocated_population_name(std::string* population_name);
1017 private:
1018 const std::string& _internal_population_name() const;
1019 inline PROTOBUF_ALWAYS_INLINE void _internal_set_population_name(const std::string& value);
1020 std::string* _internal_mutable_population_name();
1021 public:
1022
1023 // string task_name = 2;
1024 void clear_task_name();
1025 const std::string& task_name() const;
1026 template <typename ArgT0 = const std::string&, typename... ArgT>
1027 void set_task_name(ArgT0&& arg0, ArgT... args);
1028 std::string* mutable_task_name();
1029 PROTOBUF_NODISCARD std::string* release_task_name();
1030 void set_allocated_task_name(std::string* task_name);
1031 private:
1032 const std::string& _internal_task_name() const;
1033 inline PROTOBUF_ALWAYS_INLINE void _internal_set_task_name(const std::string& value);
1034 std::string* _internal_mutable_task_name();
1035 public:
1036
1037 // bytes computation_id = 5;
1038 void clear_computation_id();
1039 const std::string& computation_id() const;
1040 template <typename ArgT0 = const std::string&, typename... ArgT>
1041 void set_computation_id(ArgT0&& arg0, ArgT... args);
1042 std::string* mutable_computation_id();
1043 PROTOBUF_NODISCARD std::string* release_computation_id();
1044 void set_allocated_computation_id(std::string* computation_id);
1045 private:
1046 const std::string& _internal_computation_id() const;
1047 inline PROTOBUF_ALWAYS_INLINE void _internal_set_computation_id(const std::string& value);
1048 std::string* _internal_mutable_computation_id();
1049 public:
1050
1051 // .fcp.client.HistoricalContext historical_context = 6;
1052 bool has_historical_context() const;
1053 private:
1054 bool _internal_has_historical_context() const;
1055 public:
1056 void clear_historical_context();
1057 const ::fcp::client::HistoricalContext& historical_context() const;
1058 PROTOBUF_NODISCARD ::fcp::client::HistoricalContext* release_historical_context();
1059 ::fcp::client::HistoricalContext* mutable_historical_context();
1060 void set_allocated_historical_context(::fcp::client::HistoricalContext* historical_context);
1061 private:
1062 const ::fcp::client::HistoricalContext& _internal_historical_context() const;
1063 ::fcp::client::HistoricalContext* _internal_mutable_historical_context();
1064 public:
1065 void unsafe_arena_set_allocated_historical_context(
1066 ::fcp::client::HistoricalContext* historical_context);
1067 ::fcp::client::HistoricalContext* unsafe_arena_release_historical_context();
1068
1069 // .fcp.client.SimpleAggregation simple_aggregation = 3;
1070 bool has_simple_aggregation() const;
1071 private:
1072 bool _internal_has_simple_aggregation() const;
1073 public:
1074 void clear_simple_aggregation();
1075 const ::fcp::client::SimpleAggregation& simple_aggregation() const;
1076 PROTOBUF_NODISCARD ::fcp::client::SimpleAggregation* release_simple_aggregation();
1077 ::fcp::client::SimpleAggregation* mutable_simple_aggregation();
1078 void set_allocated_simple_aggregation(::fcp::client::SimpleAggregation* simple_aggregation);
1079 private:
1080 const ::fcp::client::SimpleAggregation& _internal_simple_aggregation() const;
1081 ::fcp::client::SimpleAggregation* _internal_mutable_simple_aggregation();
1082 public:
1083 void unsafe_arena_set_allocated_simple_aggregation(
1084 ::fcp::client::SimpleAggregation* simple_aggregation);
1085 ::fcp::client::SimpleAggregation* unsafe_arena_release_simple_aggregation();
1086
1087 // .fcp.client.SecureAggregation secure_aggregation = 4;
1088 bool has_secure_aggregation() const;
1089 private:
1090 bool _internal_has_secure_aggregation() const;
1091 public:
1092 void clear_secure_aggregation();
1093 const ::fcp::client::SecureAggregation& secure_aggregation() const;
1094 PROTOBUF_NODISCARD ::fcp::client::SecureAggregation* release_secure_aggregation();
1095 ::fcp::client::SecureAggregation* mutable_secure_aggregation();
1096 void set_allocated_secure_aggregation(::fcp::client::SecureAggregation* secure_aggregation);
1097 private:
1098 const ::fcp::client::SecureAggregation& _internal_secure_aggregation() const;
1099 ::fcp::client::SecureAggregation* _internal_mutable_secure_aggregation();
1100 public:
1101 void unsafe_arena_set_allocated_secure_aggregation(
1102 ::fcp::client::SecureAggregation* secure_aggregation);
1103 ::fcp::client::SecureAggregation* unsafe_arena_release_secure_aggregation();
1104
1105 void clear_aggregation_type();
1106 AggregationTypeCase aggregation_type_case() const;
1107 // @@protoc_insertion_point(class_scope:fcp.client.FederatedComputation)
1108 private:
1109 class _Internal;
1110 void set_has_simple_aggregation();
1111 void set_has_secure_aggregation();
1112
1113 inline bool has_aggregation_type() const;
1114 inline void clear_has_aggregation_type();
1115
1116 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1117 typedef void InternalArenaConstructable_;
1118 typedef void DestructorSkippable_;
1119 struct Impl_ {
1120 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr population_name_;
1121 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr task_name_;
1122 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr computation_id_;
1123 ::fcp::client::HistoricalContext* historical_context_;
1124 union AggregationTypeUnion {
1125 constexpr AggregationTypeUnion() : _constinit_{} {}
1126 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
1127 ::fcp::client::SimpleAggregation* simple_aggregation_;
1128 ::fcp::client::SecureAggregation* secure_aggregation_;
1129 } aggregation_type_;
1130 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1131 ::uint32_t _oneof_case_[1];
1132
1133 };
1134 union { Impl_ _impl_; };
1135 friend struct ::TableStruct_fcp_2fclient_2fselector_5fcontext_2eproto;
1136 };
1137 // -------------------------------------------------------------------
1138
1139 class SimpleAggregation final :
1140 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:fcp.client.SimpleAggregation) */ {
1141 public:
SimpleAggregation()1142 inline SimpleAggregation() : SimpleAggregation(nullptr) {}
1143 ~SimpleAggregation() override;
1144 explicit PROTOBUF_CONSTEXPR SimpleAggregation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1145
1146 SimpleAggregation(const SimpleAggregation& from);
SimpleAggregation(SimpleAggregation && from)1147 SimpleAggregation(SimpleAggregation&& from) noexcept
1148 : SimpleAggregation() {
1149 *this = ::std::move(from);
1150 }
1151
1152 inline SimpleAggregation& operator=(const SimpleAggregation& from) {
1153 if (this == &from) return *this;
1154 CopyFrom(from);
1155 return *this;
1156 }
1157 inline SimpleAggregation& operator=(SimpleAggregation&& from) noexcept {
1158 if (this == &from) return *this;
1159 if (GetOwningArena() == from.GetOwningArena()
1160 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1161 && GetOwningArena() != nullptr
1162 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1163 ) {
1164 InternalSwap(&from);
1165 } else {
1166 CopyFrom(from);
1167 }
1168 return *this;
1169 }
1170
default_instance()1171 static const SimpleAggregation& default_instance() {
1172 return *internal_default_instance();
1173 }
internal_default_instance()1174 static inline const SimpleAggregation* internal_default_instance() {
1175 return reinterpret_cast<const SimpleAggregation*>(
1176 &_SimpleAggregation_default_instance_);
1177 }
1178 static constexpr int kIndexInFileMessages =
1179 6;
1180
swap(SimpleAggregation & a,SimpleAggregation & b)1181 friend void swap(SimpleAggregation& a, SimpleAggregation& b) {
1182 a.Swap(&b);
1183 }
Swap(SimpleAggregation * other)1184 inline void Swap(SimpleAggregation* other) {
1185 if (other == this) return;
1186 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1187 if (GetOwningArena() != nullptr &&
1188 GetOwningArena() == other->GetOwningArena()) {
1189 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1190 if (GetOwningArena() == other->GetOwningArena()) {
1191 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1192 InternalSwap(other);
1193 } else {
1194 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1195 }
1196 }
1197 void UnsafeArenaSwap(SimpleAggregation* other) {
1198 if (other == this) return;
1199 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1200 InternalSwap(other);
1201 }
1202
1203 // implements Message ----------------------------------------------
1204
1205 SimpleAggregation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1206 return CreateMaybeMessage<SimpleAggregation>(arena);
1207 }
1208 SimpleAggregation* New() const {
1209 return New(nullptr);
1210 }
1211 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1212 void CopyFrom(const SimpleAggregation& from);
1213 void MergeFrom(const SimpleAggregation& from);
1214 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1215 bool IsInitialized() const final;
1216
1217 size_t ByteSizeLong() const final;
1218 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1219 ::uint8_t* _InternalSerialize(
1220 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1221 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1222
1223 private:
1224 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1225 void SharedDtor();
1226 void SetCachedSize(int size) const;
1227 void InternalSwap(SimpleAggregation* other);
1228
1229 private:
1230 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1231 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1232 return "fcp.client.SimpleAggregation";
1233 }
1234 protected:
1235 explicit SimpleAggregation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1236 bool is_message_owned = false);
1237 public:
1238
1239 std::string GetTypeName() const final;
1240
1241 // nested types ----------------------------------------------------
1242
1243 // accessors -------------------------------------------------------
1244
1245 // @@protoc_insertion_point(class_scope:fcp.client.SimpleAggregation)
1246 private:
1247 class _Internal;
1248
1249 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1250 typedef void InternalArenaConstructable_;
1251 typedef void DestructorSkippable_;
1252 struct Impl_ {
1253 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1254 };
1255 union { Impl_ _impl_; };
1256 friend struct ::TableStruct_fcp_2fclient_2fselector_5fcontext_2eproto;
1257 };
1258 // -------------------------------------------------------------------
1259
1260 class SecureAggregation final :
1261 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:fcp.client.SecureAggregation) */ {
1262 public:
SecureAggregation()1263 inline SecureAggregation() : SecureAggregation(nullptr) {}
1264 ~SecureAggregation() override;
1265 explicit PROTOBUF_CONSTEXPR SecureAggregation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1266
1267 SecureAggregation(const SecureAggregation& from);
SecureAggregation(SecureAggregation && from)1268 SecureAggregation(SecureAggregation&& from) noexcept
1269 : SecureAggregation() {
1270 *this = ::std::move(from);
1271 }
1272
1273 inline SecureAggregation& operator=(const SecureAggregation& from) {
1274 if (this == &from) return *this;
1275 CopyFrom(from);
1276 return *this;
1277 }
1278 inline SecureAggregation& operator=(SecureAggregation&& from) noexcept {
1279 if (this == &from) return *this;
1280 if (GetOwningArena() == from.GetOwningArena()
1281 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1282 && GetOwningArena() != nullptr
1283 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1284 ) {
1285 InternalSwap(&from);
1286 } else {
1287 CopyFrom(from);
1288 }
1289 return *this;
1290 }
1291
default_instance()1292 static const SecureAggregation& default_instance() {
1293 return *internal_default_instance();
1294 }
internal_default_instance()1295 static inline const SecureAggregation* internal_default_instance() {
1296 return reinterpret_cast<const SecureAggregation*>(
1297 &_SecureAggregation_default_instance_);
1298 }
1299 static constexpr int kIndexInFileMessages =
1300 7;
1301
swap(SecureAggregation & a,SecureAggregation & b)1302 friend void swap(SecureAggregation& a, SecureAggregation& b) {
1303 a.Swap(&b);
1304 }
Swap(SecureAggregation * other)1305 inline void Swap(SecureAggregation* other) {
1306 if (other == this) return;
1307 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1308 if (GetOwningArena() != nullptr &&
1309 GetOwningArena() == other->GetOwningArena()) {
1310 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1311 if (GetOwningArena() == other->GetOwningArena()) {
1312 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1313 InternalSwap(other);
1314 } else {
1315 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1316 }
1317 }
1318 void UnsafeArenaSwap(SecureAggregation* other) {
1319 if (other == this) return;
1320 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1321 InternalSwap(other);
1322 }
1323
1324 // implements Message ----------------------------------------------
1325
1326 SecureAggregation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1327 return CreateMaybeMessage<SecureAggregation>(arena);
1328 }
1329 SecureAggregation* New() const {
1330 return New(nullptr);
1331 }
1332 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1333 void CopyFrom(const SecureAggregation& from);
1334 void MergeFrom(const SecureAggregation& from);
1335 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1336 bool IsInitialized() const final;
1337
1338 size_t ByteSizeLong() const final;
1339 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1340 ::uint8_t* _InternalSerialize(
1341 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1342 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1343
1344 private:
1345 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1346 void SharedDtor();
1347 void SetCachedSize(int size) const;
1348 void InternalSwap(SecureAggregation* other);
1349
1350 private:
1351 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1352 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1353 return "fcp.client.SecureAggregation";
1354 }
1355 protected:
1356 explicit SecureAggregation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1357 bool is_message_owned = false);
1358 public:
1359
1360 std::string GetTypeName() const final;
1361
1362 // nested types ----------------------------------------------------
1363
1364 // accessors -------------------------------------------------------
1365
1366 enum : int {
1367 kMinimumClientsInServerVisibleAggregateFieldNumber = 1,
1368 };
1369 // int32 minimum_clients_in_server_visible_aggregate = 1;
1370 void clear_minimum_clients_in_server_visible_aggregate();
1371 ::int32_t minimum_clients_in_server_visible_aggregate() const;
1372 void set_minimum_clients_in_server_visible_aggregate(::int32_t value);
1373 private:
1374 ::int32_t _internal_minimum_clients_in_server_visible_aggregate() const;
1375 void _internal_set_minimum_clients_in_server_visible_aggregate(::int32_t value);
1376 public:
1377
1378 // @@protoc_insertion_point(class_scope:fcp.client.SecureAggregation)
1379 private:
1380 class _Internal;
1381
1382 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1383 typedef void InternalArenaConstructable_;
1384 typedef void DestructorSkippable_;
1385 struct Impl_ {
1386 ::int32_t minimum_clients_in_server_visible_aggregate_;
1387 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1388 };
1389 union { Impl_ _impl_; };
1390 friend struct ::TableStruct_fcp_2fclient_2fselector_5fcontext_2eproto;
1391 };
1392 // -------------------------------------------------------------------
1393
1394 class HistoricalContext final :
1395 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:fcp.client.HistoricalContext) */ {
1396 public:
HistoricalContext()1397 inline HistoricalContext() : HistoricalContext(nullptr) {}
1398 ~HistoricalContext() override;
1399 explicit PROTOBUF_CONSTEXPR HistoricalContext(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1400
1401 HistoricalContext(const HistoricalContext& from);
HistoricalContext(HistoricalContext && from)1402 HistoricalContext(HistoricalContext&& from) noexcept
1403 : HistoricalContext() {
1404 *this = ::std::move(from);
1405 }
1406
1407 inline HistoricalContext& operator=(const HistoricalContext& from) {
1408 if (this == &from) return *this;
1409 CopyFrom(from);
1410 return *this;
1411 }
1412 inline HistoricalContext& operator=(HistoricalContext&& from) noexcept {
1413 if (this == &from) return *this;
1414 if (GetOwningArena() == from.GetOwningArena()
1415 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1416 && GetOwningArena() != nullptr
1417 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1418 ) {
1419 InternalSwap(&from);
1420 } else {
1421 CopyFrom(from);
1422 }
1423 return *this;
1424 }
1425
default_instance()1426 static const HistoricalContext& default_instance() {
1427 return *internal_default_instance();
1428 }
internal_default_instance()1429 static inline const HistoricalContext* internal_default_instance() {
1430 return reinterpret_cast<const HistoricalContext*>(
1431 &_HistoricalContext_default_instance_);
1432 }
1433 static constexpr int kIndexInFileMessages =
1434 8;
1435
swap(HistoricalContext & a,HistoricalContext & b)1436 friend void swap(HistoricalContext& a, HistoricalContext& b) {
1437 a.Swap(&b);
1438 }
Swap(HistoricalContext * other)1439 inline void Swap(HistoricalContext* other) {
1440 if (other == this) return;
1441 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1442 if (GetOwningArena() != nullptr &&
1443 GetOwningArena() == other->GetOwningArena()) {
1444 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1445 if (GetOwningArena() == other->GetOwningArena()) {
1446 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1447 InternalSwap(other);
1448 } else {
1449 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1450 }
1451 }
1452 void UnsafeArenaSwap(HistoricalContext* other) {
1453 if (other == this) return;
1454 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1455 InternalSwap(other);
1456 }
1457
1458 // implements Message ----------------------------------------------
1459
1460 HistoricalContext* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1461 return CreateMaybeMessage<HistoricalContext>(arena);
1462 }
1463 HistoricalContext* New() const {
1464 return New(nullptr);
1465 }
1466 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1467 void CopyFrom(const HistoricalContext& from);
1468 void MergeFrom(const HistoricalContext& from);
1469 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1470 bool IsInitialized() const final;
1471
1472 size_t ByteSizeLong() const final;
1473 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1474 ::uint8_t* _InternalSerialize(
1475 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1476 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1477
1478 private:
1479 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1480 void SharedDtor();
1481 void SetCachedSize(int size) const;
1482 void InternalSwap(HistoricalContext* other);
1483
1484 private:
1485 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1486 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1487 return "fcp.client.HistoricalContext";
1488 }
1489 protected:
1490 explicit HistoricalContext(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1491 bool is_message_owned = false);
1492 public:
1493
1494 std::string GetTypeName() const final;
1495
1496 // nested types ----------------------------------------------------
1497
1498 // accessors -------------------------------------------------------
1499
1500 enum : int {
1501 kLastSuccessfulContributionTimeFieldNumber = 1,
1502 };
1503 // .google.protobuf.Timestamp last_successful_contribution_time = 1;
1504 bool has_last_successful_contribution_time() const;
1505 private:
1506 bool _internal_has_last_successful_contribution_time() const;
1507 public:
1508 void clear_last_successful_contribution_time();
1509 const ::PROTOBUF_NAMESPACE_ID::Timestamp& last_successful_contribution_time() const;
1510 PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Timestamp* release_last_successful_contribution_time();
1511 ::PROTOBUF_NAMESPACE_ID::Timestamp* mutable_last_successful_contribution_time();
1512 void set_allocated_last_successful_contribution_time(::PROTOBUF_NAMESPACE_ID::Timestamp* last_successful_contribution_time);
1513 private:
1514 const ::PROTOBUF_NAMESPACE_ID::Timestamp& _internal_last_successful_contribution_time() const;
1515 ::PROTOBUF_NAMESPACE_ID::Timestamp* _internal_mutable_last_successful_contribution_time();
1516 public:
1517 void unsafe_arena_set_allocated_last_successful_contribution_time(
1518 ::PROTOBUF_NAMESPACE_ID::Timestamp* last_successful_contribution_time);
1519 ::PROTOBUF_NAMESPACE_ID::Timestamp* unsafe_arena_release_last_successful_contribution_time();
1520
1521 // @@protoc_insertion_point(class_scope:fcp.client.HistoricalContext)
1522 private:
1523 class _Internal;
1524
1525 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1526 typedef void InternalArenaConstructable_;
1527 typedef void DestructorSkippable_;
1528 struct Impl_ {
1529 ::PROTOBUF_NAMESPACE_ID::Timestamp* last_successful_contribution_time_;
1530 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1531 };
1532 union { Impl_ _impl_; };
1533 friend struct ::TableStruct_fcp_2fclient_2fselector_5fcontext_2eproto;
1534 };
1535 // ===================================================================
1536
1537
1538 // ===================================================================
1539
1540 #ifdef __GNUC__
1541 #pragma GCC diagnostic push
1542 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1543 #endif // __GNUC__
1544 // SelectorContext
1545
1546 // .fcp.client.QueryTimeComputationProperties computation_properties = 1;
_internal_has_computation_properties()1547 inline bool SelectorContext::_internal_has_computation_properties() const {
1548 return this != internal_default_instance() && _impl_.computation_properties_ != nullptr;
1549 }
has_computation_properties()1550 inline bool SelectorContext::has_computation_properties() const {
1551 return _internal_has_computation_properties();
1552 }
clear_computation_properties()1553 inline void SelectorContext::clear_computation_properties() {
1554 if (GetArenaForAllocation() == nullptr && _impl_.computation_properties_ != nullptr) {
1555 delete _impl_.computation_properties_;
1556 }
1557 _impl_.computation_properties_ = nullptr;
1558 }
_internal_computation_properties()1559 inline const ::fcp::client::QueryTimeComputationProperties& SelectorContext::_internal_computation_properties() const {
1560 const ::fcp::client::QueryTimeComputationProperties* p = _impl_.computation_properties_;
1561 return p != nullptr ? *p : reinterpret_cast<const ::fcp::client::QueryTimeComputationProperties&>(
1562 ::fcp::client::_QueryTimeComputationProperties_default_instance_);
1563 }
computation_properties()1564 inline const ::fcp::client::QueryTimeComputationProperties& SelectorContext::computation_properties() const {
1565 // @@protoc_insertion_point(field_get:fcp.client.SelectorContext.computation_properties)
1566 return _internal_computation_properties();
1567 }
unsafe_arena_set_allocated_computation_properties(::fcp::client::QueryTimeComputationProperties * computation_properties)1568 inline void SelectorContext::unsafe_arena_set_allocated_computation_properties(
1569 ::fcp::client::QueryTimeComputationProperties* computation_properties) {
1570 if (GetArenaForAllocation() == nullptr) {
1571 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.computation_properties_);
1572 }
1573 _impl_.computation_properties_ = computation_properties;
1574 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:fcp.client.SelectorContext.computation_properties)
1575 }
release_computation_properties()1576 inline ::fcp::client::QueryTimeComputationProperties* SelectorContext::release_computation_properties() {
1577
1578 ::fcp::client::QueryTimeComputationProperties* temp = _impl_.computation_properties_;
1579 _impl_.computation_properties_ = nullptr;
1580 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
1581 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
1582 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1583 if (GetArenaForAllocation() == nullptr) { delete old; }
1584 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
1585 if (GetArenaForAllocation() != nullptr) {
1586 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1587 }
1588 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
1589 return temp;
1590 }
unsafe_arena_release_computation_properties()1591 inline ::fcp::client::QueryTimeComputationProperties* SelectorContext::unsafe_arena_release_computation_properties() {
1592 // @@protoc_insertion_point(field_release:fcp.client.SelectorContext.computation_properties)
1593
1594 ::fcp::client::QueryTimeComputationProperties* temp = _impl_.computation_properties_;
1595 _impl_.computation_properties_ = nullptr;
1596 return temp;
1597 }
_internal_mutable_computation_properties()1598 inline ::fcp::client::QueryTimeComputationProperties* SelectorContext::_internal_mutable_computation_properties() {
1599
1600 if (_impl_.computation_properties_ == nullptr) {
1601 auto* p = CreateMaybeMessage<::fcp::client::QueryTimeComputationProperties>(GetArenaForAllocation());
1602 _impl_.computation_properties_ = p;
1603 }
1604 return _impl_.computation_properties_;
1605 }
mutable_computation_properties()1606 inline ::fcp::client::QueryTimeComputationProperties* SelectorContext::mutable_computation_properties() {
1607 ::fcp::client::QueryTimeComputationProperties* _msg = _internal_mutable_computation_properties();
1608 // @@protoc_insertion_point(field_mutable:fcp.client.SelectorContext.computation_properties)
1609 return _msg;
1610 }
set_allocated_computation_properties(::fcp::client::QueryTimeComputationProperties * computation_properties)1611 inline void SelectorContext::set_allocated_computation_properties(::fcp::client::QueryTimeComputationProperties* computation_properties) {
1612 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
1613 if (message_arena == nullptr) {
1614 delete _impl_.computation_properties_;
1615 }
1616 if (computation_properties) {
1617 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1618 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(computation_properties);
1619 if (message_arena != submessage_arena) {
1620 computation_properties = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1621 message_arena, computation_properties, submessage_arena);
1622 }
1623
1624 } else {
1625
1626 }
1627 _impl_.computation_properties_ = computation_properties;
1628 // @@protoc_insertion_point(field_set_allocated:fcp.client.SelectorContext.computation_properties)
1629 }
1630
1631 // -------------------------------------------------------------------
1632
1633 // QueryTimeComputationProperties
1634
1635 // string session_name = 1;
clear_session_name()1636 inline void QueryTimeComputationProperties::clear_session_name() {
1637 _impl_.session_name_.ClearToEmpty();
1638 }
session_name()1639 inline const std::string& QueryTimeComputationProperties::session_name() const {
1640 // @@protoc_insertion_point(field_get:fcp.client.QueryTimeComputationProperties.session_name)
1641 return _internal_session_name();
1642 }
1643 template <typename ArgT0, typename... ArgT>
1644 inline PROTOBUF_ALWAYS_INLINE
set_session_name(ArgT0 && arg0,ArgT...args)1645 void QueryTimeComputationProperties::set_session_name(ArgT0&& arg0, ArgT... args) {
1646
1647 _impl_.session_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1648 // @@protoc_insertion_point(field_set:fcp.client.QueryTimeComputationProperties.session_name)
1649 }
mutable_session_name()1650 inline std::string* QueryTimeComputationProperties::mutable_session_name() {
1651 std::string* _s = _internal_mutable_session_name();
1652 // @@protoc_insertion_point(field_mutable:fcp.client.QueryTimeComputationProperties.session_name)
1653 return _s;
1654 }
_internal_session_name()1655 inline const std::string& QueryTimeComputationProperties::_internal_session_name() const {
1656 return _impl_.session_name_.Get();
1657 }
_internal_set_session_name(const std::string & value)1658 inline void QueryTimeComputationProperties::_internal_set_session_name(const std::string& value) {
1659
1660 _impl_.session_name_.Set(value, GetArenaForAllocation());
1661 }
_internal_mutable_session_name()1662 inline std::string* QueryTimeComputationProperties::_internal_mutable_session_name() {
1663
1664 return _impl_.session_name_.Mutable(GetArenaForAllocation());
1665 }
release_session_name()1666 inline std::string* QueryTimeComputationProperties::release_session_name() {
1667 // @@protoc_insertion_point(field_release:fcp.client.QueryTimeComputationProperties.session_name)
1668 return _impl_.session_name_.Release();
1669 }
set_allocated_session_name(std::string * session_name)1670 inline void QueryTimeComputationProperties::set_allocated_session_name(std::string* session_name) {
1671 _impl_.session_name_.SetAllocated(session_name, GetArenaForAllocation());
1672 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1673 if (_impl_.session_name_.IsDefault()) {
1674 _impl_.session_name_.Set("", GetArenaForAllocation());
1675 }
1676 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1677 // @@protoc_insertion_point(field_set_allocated:fcp.client.QueryTimeComputationProperties.session_name)
1678 }
1679
1680 // .fcp.client.LocalComputation local_compute = 2;
_internal_has_local_compute()1681 inline bool QueryTimeComputationProperties::_internal_has_local_compute() const {
1682 return computation_type_case() == kLocalCompute;
1683 }
has_local_compute()1684 inline bool QueryTimeComputationProperties::has_local_compute() const {
1685 return _internal_has_local_compute();
1686 }
set_has_local_compute()1687 inline void QueryTimeComputationProperties::set_has_local_compute() {
1688 _impl_._oneof_case_[0] = kLocalCompute;
1689 }
clear_local_compute()1690 inline void QueryTimeComputationProperties::clear_local_compute() {
1691 if (_internal_has_local_compute()) {
1692 if (GetArenaForAllocation() == nullptr) {
1693 delete _impl_.computation_type_.local_compute_;
1694 }
1695 clear_has_computation_type();
1696 }
1697 }
release_local_compute()1698 inline ::fcp::client::LocalComputation* QueryTimeComputationProperties::release_local_compute() {
1699 // @@protoc_insertion_point(field_release:fcp.client.QueryTimeComputationProperties.local_compute)
1700 if (_internal_has_local_compute()) {
1701 clear_has_computation_type();
1702 ::fcp::client::LocalComputation* temp = _impl_.computation_type_.local_compute_;
1703 if (GetArenaForAllocation() != nullptr) {
1704 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1705 }
1706 _impl_.computation_type_.local_compute_ = nullptr;
1707 return temp;
1708 } else {
1709 return nullptr;
1710 }
1711 }
_internal_local_compute()1712 inline const ::fcp::client::LocalComputation& QueryTimeComputationProperties::_internal_local_compute() const {
1713 return _internal_has_local_compute()
1714 ? *_impl_.computation_type_.local_compute_
1715 : reinterpret_cast< ::fcp::client::LocalComputation&>(::fcp::client::_LocalComputation_default_instance_);
1716 }
local_compute()1717 inline const ::fcp::client::LocalComputation& QueryTimeComputationProperties::local_compute() const {
1718 // @@protoc_insertion_point(field_get:fcp.client.QueryTimeComputationProperties.local_compute)
1719 return _internal_local_compute();
1720 }
unsafe_arena_release_local_compute()1721 inline ::fcp::client::LocalComputation* QueryTimeComputationProperties::unsafe_arena_release_local_compute() {
1722 // @@protoc_insertion_point(field_unsafe_arena_release:fcp.client.QueryTimeComputationProperties.local_compute)
1723 if (_internal_has_local_compute()) {
1724 clear_has_computation_type();
1725 ::fcp::client::LocalComputation* temp = _impl_.computation_type_.local_compute_;
1726 _impl_.computation_type_.local_compute_ = nullptr;
1727 return temp;
1728 } else {
1729 return nullptr;
1730 }
1731 }
unsafe_arena_set_allocated_local_compute(::fcp::client::LocalComputation * local_compute)1732 inline void QueryTimeComputationProperties::unsafe_arena_set_allocated_local_compute(::fcp::client::LocalComputation* local_compute) {
1733 clear_computation_type();
1734 if (local_compute) {
1735 set_has_local_compute();
1736 _impl_.computation_type_.local_compute_ = local_compute;
1737 }
1738 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:fcp.client.QueryTimeComputationProperties.local_compute)
1739 }
_internal_mutable_local_compute()1740 inline ::fcp::client::LocalComputation* QueryTimeComputationProperties::_internal_mutable_local_compute() {
1741 if (!_internal_has_local_compute()) {
1742 clear_computation_type();
1743 set_has_local_compute();
1744 _impl_.computation_type_.local_compute_ = CreateMaybeMessage< ::fcp::client::LocalComputation >(GetArenaForAllocation());
1745 }
1746 return _impl_.computation_type_.local_compute_;
1747 }
mutable_local_compute()1748 inline ::fcp::client::LocalComputation* QueryTimeComputationProperties::mutable_local_compute() {
1749 ::fcp::client::LocalComputation* _msg = _internal_mutable_local_compute();
1750 // @@protoc_insertion_point(field_mutable:fcp.client.QueryTimeComputationProperties.local_compute)
1751 return _msg;
1752 }
1753
1754 // .fcp.client.EligibilityEvalComputation eligibility_eval = 3;
_internal_has_eligibility_eval()1755 inline bool QueryTimeComputationProperties::_internal_has_eligibility_eval() const {
1756 return computation_type_case() == kEligibilityEval;
1757 }
has_eligibility_eval()1758 inline bool QueryTimeComputationProperties::has_eligibility_eval() const {
1759 return _internal_has_eligibility_eval();
1760 }
set_has_eligibility_eval()1761 inline void QueryTimeComputationProperties::set_has_eligibility_eval() {
1762 _impl_._oneof_case_[0] = kEligibilityEval;
1763 }
clear_eligibility_eval()1764 inline void QueryTimeComputationProperties::clear_eligibility_eval() {
1765 if (_internal_has_eligibility_eval()) {
1766 if (GetArenaForAllocation() == nullptr) {
1767 delete _impl_.computation_type_.eligibility_eval_;
1768 }
1769 clear_has_computation_type();
1770 }
1771 }
release_eligibility_eval()1772 inline ::fcp::client::EligibilityEvalComputation* QueryTimeComputationProperties::release_eligibility_eval() {
1773 // @@protoc_insertion_point(field_release:fcp.client.QueryTimeComputationProperties.eligibility_eval)
1774 if (_internal_has_eligibility_eval()) {
1775 clear_has_computation_type();
1776 ::fcp::client::EligibilityEvalComputation* temp = _impl_.computation_type_.eligibility_eval_;
1777 if (GetArenaForAllocation() != nullptr) {
1778 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1779 }
1780 _impl_.computation_type_.eligibility_eval_ = nullptr;
1781 return temp;
1782 } else {
1783 return nullptr;
1784 }
1785 }
_internal_eligibility_eval()1786 inline const ::fcp::client::EligibilityEvalComputation& QueryTimeComputationProperties::_internal_eligibility_eval() const {
1787 return _internal_has_eligibility_eval()
1788 ? *_impl_.computation_type_.eligibility_eval_
1789 : reinterpret_cast< ::fcp::client::EligibilityEvalComputation&>(::fcp::client::_EligibilityEvalComputation_default_instance_);
1790 }
eligibility_eval()1791 inline const ::fcp::client::EligibilityEvalComputation& QueryTimeComputationProperties::eligibility_eval() const {
1792 // @@protoc_insertion_point(field_get:fcp.client.QueryTimeComputationProperties.eligibility_eval)
1793 return _internal_eligibility_eval();
1794 }
unsafe_arena_release_eligibility_eval()1795 inline ::fcp::client::EligibilityEvalComputation* QueryTimeComputationProperties::unsafe_arena_release_eligibility_eval() {
1796 // @@protoc_insertion_point(field_unsafe_arena_release:fcp.client.QueryTimeComputationProperties.eligibility_eval)
1797 if (_internal_has_eligibility_eval()) {
1798 clear_has_computation_type();
1799 ::fcp::client::EligibilityEvalComputation* temp = _impl_.computation_type_.eligibility_eval_;
1800 _impl_.computation_type_.eligibility_eval_ = nullptr;
1801 return temp;
1802 } else {
1803 return nullptr;
1804 }
1805 }
unsafe_arena_set_allocated_eligibility_eval(::fcp::client::EligibilityEvalComputation * eligibility_eval)1806 inline void QueryTimeComputationProperties::unsafe_arena_set_allocated_eligibility_eval(::fcp::client::EligibilityEvalComputation* eligibility_eval) {
1807 clear_computation_type();
1808 if (eligibility_eval) {
1809 set_has_eligibility_eval();
1810 _impl_.computation_type_.eligibility_eval_ = eligibility_eval;
1811 }
1812 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:fcp.client.QueryTimeComputationProperties.eligibility_eval)
1813 }
_internal_mutable_eligibility_eval()1814 inline ::fcp::client::EligibilityEvalComputation* QueryTimeComputationProperties::_internal_mutable_eligibility_eval() {
1815 if (!_internal_has_eligibility_eval()) {
1816 clear_computation_type();
1817 set_has_eligibility_eval();
1818 _impl_.computation_type_.eligibility_eval_ = CreateMaybeMessage< ::fcp::client::EligibilityEvalComputation >(GetArenaForAllocation());
1819 }
1820 return _impl_.computation_type_.eligibility_eval_;
1821 }
mutable_eligibility_eval()1822 inline ::fcp::client::EligibilityEvalComputation* QueryTimeComputationProperties::mutable_eligibility_eval() {
1823 ::fcp::client::EligibilityEvalComputation* _msg = _internal_mutable_eligibility_eval();
1824 // @@protoc_insertion_point(field_mutable:fcp.client.QueryTimeComputationProperties.eligibility_eval)
1825 return _msg;
1826 }
1827
1828 // .fcp.client.FederatedComputation federated = 4;
_internal_has_federated()1829 inline bool QueryTimeComputationProperties::_internal_has_federated() const {
1830 return computation_type_case() == kFederated;
1831 }
has_federated()1832 inline bool QueryTimeComputationProperties::has_federated() const {
1833 return _internal_has_federated();
1834 }
set_has_federated()1835 inline void QueryTimeComputationProperties::set_has_federated() {
1836 _impl_._oneof_case_[0] = kFederated;
1837 }
clear_federated()1838 inline void QueryTimeComputationProperties::clear_federated() {
1839 if (_internal_has_federated()) {
1840 if (GetArenaForAllocation() == nullptr) {
1841 delete _impl_.computation_type_.federated_;
1842 }
1843 clear_has_computation_type();
1844 }
1845 }
release_federated()1846 inline ::fcp::client::FederatedComputation* QueryTimeComputationProperties::release_federated() {
1847 // @@protoc_insertion_point(field_release:fcp.client.QueryTimeComputationProperties.federated)
1848 if (_internal_has_federated()) {
1849 clear_has_computation_type();
1850 ::fcp::client::FederatedComputation* temp = _impl_.computation_type_.federated_;
1851 if (GetArenaForAllocation() != nullptr) {
1852 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1853 }
1854 _impl_.computation_type_.federated_ = nullptr;
1855 return temp;
1856 } else {
1857 return nullptr;
1858 }
1859 }
_internal_federated()1860 inline const ::fcp::client::FederatedComputation& QueryTimeComputationProperties::_internal_federated() const {
1861 return _internal_has_federated()
1862 ? *_impl_.computation_type_.federated_
1863 : reinterpret_cast< ::fcp::client::FederatedComputation&>(::fcp::client::_FederatedComputation_default_instance_);
1864 }
federated()1865 inline const ::fcp::client::FederatedComputation& QueryTimeComputationProperties::federated() const {
1866 // @@protoc_insertion_point(field_get:fcp.client.QueryTimeComputationProperties.federated)
1867 return _internal_federated();
1868 }
unsafe_arena_release_federated()1869 inline ::fcp::client::FederatedComputation* QueryTimeComputationProperties::unsafe_arena_release_federated() {
1870 // @@protoc_insertion_point(field_unsafe_arena_release:fcp.client.QueryTimeComputationProperties.federated)
1871 if (_internal_has_federated()) {
1872 clear_has_computation_type();
1873 ::fcp::client::FederatedComputation* temp = _impl_.computation_type_.federated_;
1874 _impl_.computation_type_.federated_ = nullptr;
1875 return temp;
1876 } else {
1877 return nullptr;
1878 }
1879 }
unsafe_arena_set_allocated_federated(::fcp::client::FederatedComputation * federated)1880 inline void QueryTimeComputationProperties::unsafe_arena_set_allocated_federated(::fcp::client::FederatedComputation* federated) {
1881 clear_computation_type();
1882 if (federated) {
1883 set_has_federated();
1884 _impl_.computation_type_.federated_ = federated;
1885 }
1886 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:fcp.client.QueryTimeComputationProperties.federated)
1887 }
_internal_mutable_federated()1888 inline ::fcp::client::FederatedComputation* QueryTimeComputationProperties::_internal_mutable_federated() {
1889 if (!_internal_has_federated()) {
1890 clear_computation_type();
1891 set_has_federated();
1892 _impl_.computation_type_.federated_ = CreateMaybeMessage< ::fcp::client::FederatedComputation >(GetArenaForAllocation());
1893 }
1894 return _impl_.computation_type_.federated_;
1895 }
mutable_federated()1896 inline ::fcp::client::FederatedComputation* QueryTimeComputationProperties::mutable_federated() {
1897 ::fcp::client::FederatedComputation* _msg = _internal_mutable_federated();
1898 // @@protoc_insertion_point(field_mutable:fcp.client.QueryTimeComputationProperties.federated)
1899 return _msg;
1900 }
1901
1902 // int64 run_id = 5;
clear_run_id()1903 inline void QueryTimeComputationProperties::clear_run_id() {
1904 _impl_.run_id_ = ::int64_t{0};
1905 }
_internal_run_id()1906 inline ::int64_t QueryTimeComputationProperties::_internal_run_id() const {
1907 return _impl_.run_id_;
1908 }
run_id()1909 inline ::int64_t QueryTimeComputationProperties::run_id() const {
1910 // @@protoc_insertion_point(field_get:fcp.client.QueryTimeComputationProperties.run_id)
1911 return _internal_run_id();
1912 }
_internal_set_run_id(::int64_t value)1913 inline void QueryTimeComputationProperties::_internal_set_run_id(::int64_t value) {
1914
1915 _impl_.run_id_ = value;
1916 }
set_run_id(::int64_t value)1917 inline void QueryTimeComputationProperties::set_run_id(::int64_t value) {
1918 _internal_set_run_id(value);
1919 // @@protoc_insertion_point(field_set:fcp.client.QueryTimeComputationProperties.run_id)
1920 }
1921
1922 // bytes context_data = 6;
clear_context_data()1923 inline void QueryTimeComputationProperties::clear_context_data() {
1924 _impl_.context_data_.ClearToEmpty();
1925 }
context_data()1926 inline const std::string& QueryTimeComputationProperties::context_data() const {
1927 // @@protoc_insertion_point(field_get:fcp.client.QueryTimeComputationProperties.context_data)
1928 return _internal_context_data();
1929 }
1930 template <typename ArgT0, typename... ArgT>
1931 inline PROTOBUF_ALWAYS_INLINE
set_context_data(ArgT0 && arg0,ArgT...args)1932 void QueryTimeComputationProperties::set_context_data(ArgT0&& arg0, ArgT... args) {
1933
1934 _impl_.context_data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1935 // @@protoc_insertion_point(field_set:fcp.client.QueryTimeComputationProperties.context_data)
1936 }
mutable_context_data()1937 inline std::string* QueryTimeComputationProperties::mutable_context_data() {
1938 std::string* _s = _internal_mutable_context_data();
1939 // @@protoc_insertion_point(field_mutable:fcp.client.QueryTimeComputationProperties.context_data)
1940 return _s;
1941 }
_internal_context_data()1942 inline const std::string& QueryTimeComputationProperties::_internal_context_data() const {
1943 return _impl_.context_data_.Get();
1944 }
_internal_set_context_data(const std::string & value)1945 inline void QueryTimeComputationProperties::_internal_set_context_data(const std::string& value) {
1946
1947 _impl_.context_data_.Set(value, GetArenaForAllocation());
1948 }
_internal_mutable_context_data()1949 inline std::string* QueryTimeComputationProperties::_internal_mutable_context_data() {
1950
1951 return _impl_.context_data_.Mutable(GetArenaForAllocation());
1952 }
release_context_data()1953 inline std::string* QueryTimeComputationProperties::release_context_data() {
1954 // @@protoc_insertion_point(field_release:fcp.client.QueryTimeComputationProperties.context_data)
1955 return _impl_.context_data_.Release();
1956 }
set_allocated_context_data(std::string * context_data)1957 inline void QueryTimeComputationProperties::set_allocated_context_data(std::string* context_data) {
1958 _impl_.context_data_.SetAllocated(context_data, GetArenaForAllocation());
1959 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1960 if (_impl_.context_data_.IsDefault()) {
1961 _impl_.context_data_.Set("", GetArenaForAllocation());
1962 }
1963 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1964 // @@protoc_insertion_point(field_set_allocated:fcp.client.QueryTimeComputationProperties.context_data)
1965 }
1966
1967 // .fcp.client.QueryTimeComputationProperties.ExampleIteratorOutputFormat example_iterator_output_format = 7;
clear_example_iterator_output_format()1968 inline void QueryTimeComputationProperties::clear_example_iterator_output_format() {
1969 _impl_.example_iterator_output_format_ = 0;
1970 }
_internal_example_iterator_output_format()1971 inline ::fcp::client::QueryTimeComputationProperties_ExampleIteratorOutputFormat QueryTimeComputationProperties::_internal_example_iterator_output_format() const {
1972 return static_cast< ::fcp::client::QueryTimeComputationProperties_ExampleIteratorOutputFormat >(_impl_.example_iterator_output_format_);
1973 }
example_iterator_output_format()1974 inline ::fcp::client::QueryTimeComputationProperties_ExampleIteratorOutputFormat QueryTimeComputationProperties::example_iterator_output_format() const {
1975 // @@protoc_insertion_point(field_get:fcp.client.QueryTimeComputationProperties.example_iterator_output_format)
1976 return _internal_example_iterator_output_format();
1977 }
_internal_set_example_iterator_output_format(::fcp::client::QueryTimeComputationProperties_ExampleIteratorOutputFormat value)1978 inline void QueryTimeComputationProperties::_internal_set_example_iterator_output_format(::fcp::client::QueryTimeComputationProperties_ExampleIteratorOutputFormat value) {
1979
1980 _impl_.example_iterator_output_format_ = value;
1981 }
set_example_iterator_output_format(::fcp::client::QueryTimeComputationProperties_ExampleIteratorOutputFormat value)1982 inline void QueryTimeComputationProperties::set_example_iterator_output_format(::fcp::client::QueryTimeComputationProperties_ExampleIteratorOutputFormat value) {
1983 _internal_set_example_iterator_output_format(value);
1984 // @@protoc_insertion_point(field_set:fcp.client.QueryTimeComputationProperties.example_iterator_output_format)
1985 }
1986
has_computation_type()1987 inline bool QueryTimeComputationProperties::has_computation_type() const {
1988 return computation_type_case() != COMPUTATION_TYPE_NOT_SET;
1989 }
clear_has_computation_type()1990 inline void QueryTimeComputationProperties::clear_has_computation_type() {
1991 _impl_._oneof_case_[0] = COMPUTATION_TYPE_NOT_SET;
1992 }
computation_type_case()1993 inline QueryTimeComputationProperties::ComputationTypeCase QueryTimeComputationProperties::computation_type_case() const {
1994 return QueryTimeComputationProperties::ComputationTypeCase(_impl_._oneof_case_[0]);
1995 }
1996 // -------------------------------------------------------------------
1997
1998 // -------------------------------------------------------------------
1999
2000 // LocalComputation
2001
2002 // string input_dir = 1;
clear_input_dir()2003 inline void LocalComputation::clear_input_dir() {
2004 _impl_.input_dir_.ClearToEmpty();
2005 }
input_dir()2006 inline const std::string& LocalComputation::input_dir() const {
2007 // @@protoc_insertion_point(field_get:fcp.client.LocalComputation.input_dir)
2008 return _internal_input_dir();
2009 }
2010 template <typename ArgT0, typename... ArgT>
2011 inline PROTOBUF_ALWAYS_INLINE
set_input_dir(ArgT0 && arg0,ArgT...args)2012 void LocalComputation::set_input_dir(ArgT0&& arg0, ArgT... args) {
2013
2014 _impl_.input_dir_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2015 // @@protoc_insertion_point(field_set:fcp.client.LocalComputation.input_dir)
2016 }
mutable_input_dir()2017 inline std::string* LocalComputation::mutable_input_dir() {
2018 std::string* _s = _internal_mutable_input_dir();
2019 // @@protoc_insertion_point(field_mutable:fcp.client.LocalComputation.input_dir)
2020 return _s;
2021 }
_internal_input_dir()2022 inline const std::string& LocalComputation::_internal_input_dir() const {
2023 return _impl_.input_dir_.Get();
2024 }
_internal_set_input_dir(const std::string & value)2025 inline void LocalComputation::_internal_set_input_dir(const std::string& value) {
2026
2027 _impl_.input_dir_.Set(value, GetArenaForAllocation());
2028 }
_internal_mutable_input_dir()2029 inline std::string* LocalComputation::_internal_mutable_input_dir() {
2030
2031 return _impl_.input_dir_.Mutable(GetArenaForAllocation());
2032 }
release_input_dir()2033 inline std::string* LocalComputation::release_input_dir() {
2034 // @@protoc_insertion_point(field_release:fcp.client.LocalComputation.input_dir)
2035 return _impl_.input_dir_.Release();
2036 }
set_allocated_input_dir(std::string * input_dir)2037 inline void LocalComputation::set_allocated_input_dir(std::string* input_dir) {
2038 _impl_.input_dir_.SetAllocated(input_dir, GetArenaForAllocation());
2039 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2040 if (_impl_.input_dir_.IsDefault()) {
2041 _impl_.input_dir_.Set("", GetArenaForAllocation());
2042 }
2043 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2044 // @@protoc_insertion_point(field_set_allocated:fcp.client.LocalComputation.input_dir)
2045 }
2046
2047 // string output_dir = 2;
clear_output_dir()2048 inline void LocalComputation::clear_output_dir() {
2049 _impl_.output_dir_.ClearToEmpty();
2050 }
output_dir()2051 inline const std::string& LocalComputation::output_dir() const {
2052 // @@protoc_insertion_point(field_get:fcp.client.LocalComputation.output_dir)
2053 return _internal_output_dir();
2054 }
2055 template <typename ArgT0, typename... ArgT>
2056 inline PROTOBUF_ALWAYS_INLINE
set_output_dir(ArgT0 && arg0,ArgT...args)2057 void LocalComputation::set_output_dir(ArgT0&& arg0, ArgT... args) {
2058
2059 _impl_.output_dir_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2060 // @@protoc_insertion_point(field_set:fcp.client.LocalComputation.output_dir)
2061 }
mutable_output_dir()2062 inline std::string* LocalComputation::mutable_output_dir() {
2063 std::string* _s = _internal_mutable_output_dir();
2064 // @@protoc_insertion_point(field_mutable:fcp.client.LocalComputation.output_dir)
2065 return _s;
2066 }
_internal_output_dir()2067 inline const std::string& LocalComputation::_internal_output_dir() const {
2068 return _impl_.output_dir_.Get();
2069 }
_internal_set_output_dir(const std::string & value)2070 inline void LocalComputation::_internal_set_output_dir(const std::string& value) {
2071
2072 _impl_.output_dir_.Set(value, GetArenaForAllocation());
2073 }
_internal_mutable_output_dir()2074 inline std::string* LocalComputation::_internal_mutable_output_dir() {
2075
2076 return _impl_.output_dir_.Mutable(GetArenaForAllocation());
2077 }
release_output_dir()2078 inline std::string* LocalComputation::release_output_dir() {
2079 // @@protoc_insertion_point(field_release:fcp.client.LocalComputation.output_dir)
2080 return _impl_.output_dir_.Release();
2081 }
set_allocated_output_dir(std::string * output_dir)2082 inline void LocalComputation::set_allocated_output_dir(std::string* output_dir) {
2083 _impl_.output_dir_.SetAllocated(output_dir, GetArenaForAllocation());
2084 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2085 if (_impl_.output_dir_.IsDefault()) {
2086 _impl_.output_dir_.Set("", GetArenaForAllocation());
2087 }
2088 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2089 // @@protoc_insertion_point(field_set_allocated:fcp.client.LocalComputation.output_dir)
2090 }
2091
2092 // map<string, string> input_resource_map = 3;
_internal_input_resource_map_size()2093 inline int LocalComputation::_internal_input_resource_map_size() const {
2094 return _impl_.input_resource_map_.size();
2095 }
input_resource_map_size()2096 inline int LocalComputation::input_resource_map_size() const {
2097 return _internal_input_resource_map_size();
2098 }
clear_input_resource_map()2099 inline void LocalComputation::clear_input_resource_map() {
2100 _impl_.input_resource_map_.Clear();
2101 }
2102 inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
_internal_input_resource_map()2103 LocalComputation::_internal_input_resource_map() const {
2104 return _impl_.input_resource_map_.GetMap();
2105 }
2106 inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
input_resource_map()2107 LocalComputation::input_resource_map() const {
2108 // @@protoc_insertion_point(field_map:fcp.client.LocalComputation.input_resource_map)
2109 return _internal_input_resource_map();
2110 }
2111 inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
_internal_mutable_input_resource_map()2112 LocalComputation::_internal_mutable_input_resource_map() {
2113 return _impl_.input_resource_map_.MutableMap();
2114 }
2115 inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
mutable_input_resource_map()2116 LocalComputation::mutable_input_resource_map() {
2117 // @@protoc_insertion_point(field_mutable_map:fcp.client.LocalComputation.input_resource_map)
2118 return _internal_mutable_input_resource_map();
2119 }
2120
2121 // -------------------------------------------------------------------
2122
2123 // EligibilityEvalComputation
2124
2125 // string population_name = 1;
clear_population_name()2126 inline void EligibilityEvalComputation::clear_population_name() {
2127 _impl_.population_name_.ClearToEmpty();
2128 }
population_name()2129 inline const std::string& EligibilityEvalComputation::population_name() const {
2130 // @@protoc_insertion_point(field_get:fcp.client.EligibilityEvalComputation.population_name)
2131 return _internal_population_name();
2132 }
2133 template <typename ArgT0, typename... ArgT>
2134 inline PROTOBUF_ALWAYS_INLINE
set_population_name(ArgT0 && arg0,ArgT...args)2135 void EligibilityEvalComputation::set_population_name(ArgT0&& arg0, ArgT... args) {
2136
2137 _impl_.population_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2138 // @@protoc_insertion_point(field_set:fcp.client.EligibilityEvalComputation.population_name)
2139 }
mutable_population_name()2140 inline std::string* EligibilityEvalComputation::mutable_population_name() {
2141 std::string* _s = _internal_mutable_population_name();
2142 // @@protoc_insertion_point(field_mutable:fcp.client.EligibilityEvalComputation.population_name)
2143 return _s;
2144 }
_internal_population_name()2145 inline const std::string& EligibilityEvalComputation::_internal_population_name() const {
2146 return _impl_.population_name_.Get();
2147 }
_internal_set_population_name(const std::string & value)2148 inline void EligibilityEvalComputation::_internal_set_population_name(const std::string& value) {
2149
2150 _impl_.population_name_.Set(value, GetArenaForAllocation());
2151 }
_internal_mutable_population_name()2152 inline std::string* EligibilityEvalComputation::_internal_mutable_population_name() {
2153
2154 return _impl_.population_name_.Mutable(GetArenaForAllocation());
2155 }
release_population_name()2156 inline std::string* EligibilityEvalComputation::release_population_name() {
2157 // @@protoc_insertion_point(field_release:fcp.client.EligibilityEvalComputation.population_name)
2158 return _impl_.population_name_.Release();
2159 }
set_allocated_population_name(std::string * population_name)2160 inline void EligibilityEvalComputation::set_allocated_population_name(std::string* population_name) {
2161 _impl_.population_name_.SetAllocated(population_name, GetArenaForAllocation());
2162 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2163 if (_impl_.population_name_.IsDefault()) {
2164 _impl_.population_name_.Set("", GetArenaForAllocation());
2165 }
2166 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2167 // @@protoc_insertion_point(field_set_allocated:fcp.client.EligibilityEvalComputation.population_name)
2168 }
2169
2170 // -------------------------------------------------------------------
2171
2172 // FederatedComputation
2173
2174 // string population_name = 1;
clear_population_name()2175 inline void FederatedComputation::clear_population_name() {
2176 _impl_.population_name_.ClearToEmpty();
2177 }
population_name()2178 inline const std::string& FederatedComputation::population_name() const {
2179 // @@protoc_insertion_point(field_get:fcp.client.FederatedComputation.population_name)
2180 return _internal_population_name();
2181 }
2182 template <typename ArgT0, typename... ArgT>
2183 inline PROTOBUF_ALWAYS_INLINE
set_population_name(ArgT0 && arg0,ArgT...args)2184 void FederatedComputation::set_population_name(ArgT0&& arg0, ArgT... args) {
2185
2186 _impl_.population_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2187 // @@protoc_insertion_point(field_set:fcp.client.FederatedComputation.population_name)
2188 }
mutable_population_name()2189 inline std::string* FederatedComputation::mutable_population_name() {
2190 std::string* _s = _internal_mutable_population_name();
2191 // @@protoc_insertion_point(field_mutable:fcp.client.FederatedComputation.population_name)
2192 return _s;
2193 }
_internal_population_name()2194 inline const std::string& FederatedComputation::_internal_population_name() const {
2195 return _impl_.population_name_.Get();
2196 }
_internal_set_population_name(const std::string & value)2197 inline void FederatedComputation::_internal_set_population_name(const std::string& value) {
2198
2199 _impl_.population_name_.Set(value, GetArenaForAllocation());
2200 }
_internal_mutable_population_name()2201 inline std::string* FederatedComputation::_internal_mutable_population_name() {
2202
2203 return _impl_.population_name_.Mutable(GetArenaForAllocation());
2204 }
release_population_name()2205 inline std::string* FederatedComputation::release_population_name() {
2206 // @@protoc_insertion_point(field_release:fcp.client.FederatedComputation.population_name)
2207 return _impl_.population_name_.Release();
2208 }
set_allocated_population_name(std::string * population_name)2209 inline void FederatedComputation::set_allocated_population_name(std::string* population_name) {
2210 _impl_.population_name_.SetAllocated(population_name, GetArenaForAllocation());
2211 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2212 if (_impl_.population_name_.IsDefault()) {
2213 _impl_.population_name_.Set("", GetArenaForAllocation());
2214 }
2215 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2216 // @@protoc_insertion_point(field_set_allocated:fcp.client.FederatedComputation.population_name)
2217 }
2218
2219 // string task_name = 2;
clear_task_name()2220 inline void FederatedComputation::clear_task_name() {
2221 _impl_.task_name_.ClearToEmpty();
2222 }
task_name()2223 inline const std::string& FederatedComputation::task_name() const {
2224 // @@protoc_insertion_point(field_get:fcp.client.FederatedComputation.task_name)
2225 return _internal_task_name();
2226 }
2227 template <typename ArgT0, typename... ArgT>
2228 inline PROTOBUF_ALWAYS_INLINE
set_task_name(ArgT0 && arg0,ArgT...args)2229 void FederatedComputation::set_task_name(ArgT0&& arg0, ArgT... args) {
2230
2231 _impl_.task_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2232 // @@protoc_insertion_point(field_set:fcp.client.FederatedComputation.task_name)
2233 }
mutable_task_name()2234 inline std::string* FederatedComputation::mutable_task_name() {
2235 std::string* _s = _internal_mutable_task_name();
2236 // @@protoc_insertion_point(field_mutable:fcp.client.FederatedComputation.task_name)
2237 return _s;
2238 }
_internal_task_name()2239 inline const std::string& FederatedComputation::_internal_task_name() const {
2240 return _impl_.task_name_.Get();
2241 }
_internal_set_task_name(const std::string & value)2242 inline void FederatedComputation::_internal_set_task_name(const std::string& value) {
2243
2244 _impl_.task_name_.Set(value, GetArenaForAllocation());
2245 }
_internal_mutable_task_name()2246 inline std::string* FederatedComputation::_internal_mutable_task_name() {
2247
2248 return _impl_.task_name_.Mutable(GetArenaForAllocation());
2249 }
release_task_name()2250 inline std::string* FederatedComputation::release_task_name() {
2251 // @@protoc_insertion_point(field_release:fcp.client.FederatedComputation.task_name)
2252 return _impl_.task_name_.Release();
2253 }
set_allocated_task_name(std::string * task_name)2254 inline void FederatedComputation::set_allocated_task_name(std::string* task_name) {
2255 _impl_.task_name_.SetAllocated(task_name, GetArenaForAllocation());
2256 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2257 if (_impl_.task_name_.IsDefault()) {
2258 _impl_.task_name_.Set("", GetArenaForAllocation());
2259 }
2260 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2261 // @@protoc_insertion_point(field_set_allocated:fcp.client.FederatedComputation.task_name)
2262 }
2263
2264 // bytes computation_id = 5;
clear_computation_id()2265 inline void FederatedComputation::clear_computation_id() {
2266 _impl_.computation_id_.ClearToEmpty();
2267 }
computation_id()2268 inline const std::string& FederatedComputation::computation_id() const {
2269 // @@protoc_insertion_point(field_get:fcp.client.FederatedComputation.computation_id)
2270 return _internal_computation_id();
2271 }
2272 template <typename ArgT0, typename... ArgT>
2273 inline PROTOBUF_ALWAYS_INLINE
set_computation_id(ArgT0 && arg0,ArgT...args)2274 void FederatedComputation::set_computation_id(ArgT0&& arg0, ArgT... args) {
2275
2276 _impl_.computation_id_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2277 // @@protoc_insertion_point(field_set:fcp.client.FederatedComputation.computation_id)
2278 }
mutable_computation_id()2279 inline std::string* FederatedComputation::mutable_computation_id() {
2280 std::string* _s = _internal_mutable_computation_id();
2281 // @@protoc_insertion_point(field_mutable:fcp.client.FederatedComputation.computation_id)
2282 return _s;
2283 }
_internal_computation_id()2284 inline const std::string& FederatedComputation::_internal_computation_id() const {
2285 return _impl_.computation_id_.Get();
2286 }
_internal_set_computation_id(const std::string & value)2287 inline void FederatedComputation::_internal_set_computation_id(const std::string& value) {
2288
2289 _impl_.computation_id_.Set(value, GetArenaForAllocation());
2290 }
_internal_mutable_computation_id()2291 inline std::string* FederatedComputation::_internal_mutable_computation_id() {
2292
2293 return _impl_.computation_id_.Mutable(GetArenaForAllocation());
2294 }
release_computation_id()2295 inline std::string* FederatedComputation::release_computation_id() {
2296 // @@protoc_insertion_point(field_release:fcp.client.FederatedComputation.computation_id)
2297 return _impl_.computation_id_.Release();
2298 }
set_allocated_computation_id(std::string * computation_id)2299 inline void FederatedComputation::set_allocated_computation_id(std::string* computation_id) {
2300 _impl_.computation_id_.SetAllocated(computation_id, GetArenaForAllocation());
2301 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2302 if (_impl_.computation_id_.IsDefault()) {
2303 _impl_.computation_id_.Set("", GetArenaForAllocation());
2304 }
2305 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2306 // @@protoc_insertion_point(field_set_allocated:fcp.client.FederatedComputation.computation_id)
2307 }
2308
2309 // .fcp.client.HistoricalContext historical_context = 6;
_internal_has_historical_context()2310 inline bool FederatedComputation::_internal_has_historical_context() const {
2311 return this != internal_default_instance() && _impl_.historical_context_ != nullptr;
2312 }
has_historical_context()2313 inline bool FederatedComputation::has_historical_context() const {
2314 return _internal_has_historical_context();
2315 }
clear_historical_context()2316 inline void FederatedComputation::clear_historical_context() {
2317 if (GetArenaForAllocation() == nullptr && _impl_.historical_context_ != nullptr) {
2318 delete _impl_.historical_context_;
2319 }
2320 _impl_.historical_context_ = nullptr;
2321 }
_internal_historical_context()2322 inline const ::fcp::client::HistoricalContext& FederatedComputation::_internal_historical_context() const {
2323 const ::fcp::client::HistoricalContext* p = _impl_.historical_context_;
2324 return p != nullptr ? *p : reinterpret_cast<const ::fcp::client::HistoricalContext&>(
2325 ::fcp::client::_HistoricalContext_default_instance_);
2326 }
historical_context()2327 inline const ::fcp::client::HistoricalContext& FederatedComputation::historical_context() const {
2328 // @@protoc_insertion_point(field_get:fcp.client.FederatedComputation.historical_context)
2329 return _internal_historical_context();
2330 }
unsafe_arena_set_allocated_historical_context(::fcp::client::HistoricalContext * historical_context)2331 inline void FederatedComputation::unsafe_arena_set_allocated_historical_context(
2332 ::fcp::client::HistoricalContext* historical_context) {
2333 if (GetArenaForAllocation() == nullptr) {
2334 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.historical_context_);
2335 }
2336 _impl_.historical_context_ = historical_context;
2337 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:fcp.client.FederatedComputation.historical_context)
2338 }
release_historical_context()2339 inline ::fcp::client::HistoricalContext* FederatedComputation::release_historical_context() {
2340
2341 ::fcp::client::HistoricalContext* temp = _impl_.historical_context_;
2342 _impl_.historical_context_ = nullptr;
2343 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
2344 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
2345 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2346 if (GetArenaForAllocation() == nullptr) { delete old; }
2347 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
2348 if (GetArenaForAllocation() != nullptr) {
2349 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2350 }
2351 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
2352 return temp;
2353 }
unsafe_arena_release_historical_context()2354 inline ::fcp::client::HistoricalContext* FederatedComputation::unsafe_arena_release_historical_context() {
2355 // @@protoc_insertion_point(field_release:fcp.client.FederatedComputation.historical_context)
2356
2357 ::fcp::client::HistoricalContext* temp = _impl_.historical_context_;
2358 _impl_.historical_context_ = nullptr;
2359 return temp;
2360 }
_internal_mutable_historical_context()2361 inline ::fcp::client::HistoricalContext* FederatedComputation::_internal_mutable_historical_context() {
2362
2363 if (_impl_.historical_context_ == nullptr) {
2364 auto* p = CreateMaybeMessage<::fcp::client::HistoricalContext>(GetArenaForAllocation());
2365 _impl_.historical_context_ = p;
2366 }
2367 return _impl_.historical_context_;
2368 }
mutable_historical_context()2369 inline ::fcp::client::HistoricalContext* FederatedComputation::mutable_historical_context() {
2370 ::fcp::client::HistoricalContext* _msg = _internal_mutable_historical_context();
2371 // @@protoc_insertion_point(field_mutable:fcp.client.FederatedComputation.historical_context)
2372 return _msg;
2373 }
set_allocated_historical_context(::fcp::client::HistoricalContext * historical_context)2374 inline void FederatedComputation::set_allocated_historical_context(::fcp::client::HistoricalContext* historical_context) {
2375 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
2376 if (message_arena == nullptr) {
2377 delete _impl_.historical_context_;
2378 }
2379 if (historical_context) {
2380 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
2381 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(historical_context);
2382 if (message_arena != submessage_arena) {
2383 historical_context = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2384 message_arena, historical_context, submessage_arena);
2385 }
2386
2387 } else {
2388
2389 }
2390 _impl_.historical_context_ = historical_context;
2391 // @@protoc_insertion_point(field_set_allocated:fcp.client.FederatedComputation.historical_context)
2392 }
2393
2394 // .fcp.client.SimpleAggregation simple_aggregation = 3;
_internal_has_simple_aggregation()2395 inline bool FederatedComputation::_internal_has_simple_aggregation() const {
2396 return aggregation_type_case() == kSimpleAggregation;
2397 }
has_simple_aggregation()2398 inline bool FederatedComputation::has_simple_aggregation() const {
2399 return _internal_has_simple_aggregation();
2400 }
set_has_simple_aggregation()2401 inline void FederatedComputation::set_has_simple_aggregation() {
2402 _impl_._oneof_case_[0] = kSimpleAggregation;
2403 }
clear_simple_aggregation()2404 inline void FederatedComputation::clear_simple_aggregation() {
2405 if (_internal_has_simple_aggregation()) {
2406 if (GetArenaForAllocation() == nullptr) {
2407 delete _impl_.aggregation_type_.simple_aggregation_;
2408 }
2409 clear_has_aggregation_type();
2410 }
2411 }
release_simple_aggregation()2412 inline ::fcp::client::SimpleAggregation* FederatedComputation::release_simple_aggregation() {
2413 // @@protoc_insertion_point(field_release:fcp.client.FederatedComputation.simple_aggregation)
2414 if (_internal_has_simple_aggregation()) {
2415 clear_has_aggregation_type();
2416 ::fcp::client::SimpleAggregation* temp = _impl_.aggregation_type_.simple_aggregation_;
2417 if (GetArenaForAllocation() != nullptr) {
2418 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2419 }
2420 _impl_.aggregation_type_.simple_aggregation_ = nullptr;
2421 return temp;
2422 } else {
2423 return nullptr;
2424 }
2425 }
_internal_simple_aggregation()2426 inline const ::fcp::client::SimpleAggregation& FederatedComputation::_internal_simple_aggregation() const {
2427 return _internal_has_simple_aggregation()
2428 ? *_impl_.aggregation_type_.simple_aggregation_
2429 : reinterpret_cast< ::fcp::client::SimpleAggregation&>(::fcp::client::_SimpleAggregation_default_instance_);
2430 }
simple_aggregation()2431 inline const ::fcp::client::SimpleAggregation& FederatedComputation::simple_aggregation() const {
2432 // @@protoc_insertion_point(field_get:fcp.client.FederatedComputation.simple_aggregation)
2433 return _internal_simple_aggregation();
2434 }
unsafe_arena_release_simple_aggregation()2435 inline ::fcp::client::SimpleAggregation* FederatedComputation::unsafe_arena_release_simple_aggregation() {
2436 // @@protoc_insertion_point(field_unsafe_arena_release:fcp.client.FederatedComputation.simple_aggregation)
2437 if (_internal_has_simple_aggregation()) {
2438 clear_has_aggregation_type();
2439 ::fcp::client::SimpleAggregation* temp = _impl_.aggregation_type_.simple_aggregation_;
2440 _impl_.aggregation_type_.simple_aggregation_ = nullptr;
2441 return temp;
2442 } else {
2443 return nullptr;
2444 }
2445 }
unsafe_arena_set_allocated_simple_aggregation(::fcp::client::SimpleAggregation * simple_aggregation)2446 inline void FederatedComputation::unsafe_arena_set_allocated_simple_aggregation(::fcp::client::SimpleAggregation* simple_aggregation) {
2447 clear_aggregation_type();
2448 if (simple_aggregation) {
2449 set_has_simple_aggregation();
2450 _impl_.aggregation_type_.simple_aggregation_ = simple_aggregation;
2451 }
2452 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:fcp.client.FederatedComputation.simple_aggregation)
2453 }
_internal_mutable_simple_aggregation()2454 inline ::fcp::client::SimpleAggregation* FederatedComputation::_internal_mutable_simple_aggregation() {
2455 if (!_internal_has_simple_aggregation()) {
2456 clear_aggregation_type();
2457 set_has_simple_aggregation();
2458 _impl_.aggregation_type_.simple_aggregation_ = CreateMaybeMessage< ::fcp::client::SimpleAggregation >(GetArenaForAllocation());
2459 }
2460 return _impl_.aggregation_type_.simple_aggregation_;
2461 }
mutable_simple_aggregation()2462 inline ::fcp::client::SimpleAggregation* FederatedComputation::mutable_simple_aggregation() {
2463 ::fcp::client::SimpleAggregation* _msg = _internal_mutable_simple_aggregation();
2464 // @@protoc_insertion_point(field_mutable:fcp.client.FederatedComputation.simple_aggregation)
2465 return _msg;
2466 }
2467
2468 // .fcp.client.SecureAggregation secure_aggregation = 4;
_internal_has_secure_aggregation()2469 inline bool FederatedComputation::_internal_has_secure_aggregation() const {
2470 return aggregation_type_case() == kSecureAggregation;
2471 }
has_secure_aggregation()2472 inline bool FederatedComputation::has_secure_aggregation() const {
2473 return _internal_has_secure_aggregation();
2474 }
set_has_secure_aggregation()2475 inline void FederatedComputation::set_has_secure_aggregation() {
2476 _impl_._oneof_case_[0] = kSecureAggregation;
2477 }
clear_secure_aggregation()2478 inline void FederatedComputation::clear_secure_aggregation() {
2479 if (_internal_has_secure_aggregation()) {
2480 if (GetArenaForAllocation() == nullptr) {
2481 delete _impl_.aggregation_type_.secure_aggregation_;
2482 }
2483 clear_has_aggregation_type();
2484 }
2485 }
release_secure_aggregation()2486 inline ::fcp::client::SecureAggregation* FederatedComputation::release_secure_aggregation() {
2487 // @@protoc_insertion_point(field_release:fcp.client.FederatedComputation.secure_aggregation)
2488 if (_internal_has_secure_aggregation()) {
2489 clear_has_aggregation_type();
2490 ::fcp::client::SecureAggregation* temp = _impl_.aggregation_type_.secure_aggregation_;
2491 if (GetArenaForAllocation() != nullptr) {
2492 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2493 }
2494 _impl_.aggregation_type_.secure_aggregation_ = nullptr;
2495 return temp;
2496 } else {
2497 return nullptr;
2498 }
2499 }
_internal_secure_aggregation()2500 inline const ::fcp::client::SecureAggregation& FederatedComputation::_internal_secure_aggregation() const {
2501 return _internal_has_secure_aggregation()
2502 ? *_impl_.aggregation_type_.secure_aggregation_
2503 : reinterpret_cast< ::fcp::client::SecureAggregation&>(::fcp::client::_SecureAggregation_default_instance_);
2504 }
secure_aggregation()2505 inline const ::fcp::client::SecureAggregation& FederatedComputation::secure_aggregation() const {
2506 // @@protoc_insertion_point(field_get:fcp.client.FederatedComputation.secure_aggregation)
2507 return _internal_secure_aggregation();
2508 }
unsafe_arena_release_secure_aggregation()2509 inline ::fcp::client::SecureAggregation* FederatedComputation::unsafe_arena_release_secure_aggregation() {
2510 // @@protoc_insertion_point(field_unsafe_arena_release:fcp.client.FederatedComputation.secure_aggregation)
2511 if (_internal_has_secure_aggregation()) {
2512 clear_has_aggregation_type();
2513 ::fcp::client::SecureAggregation* temp = _impl_.aggregation_type_.secure_aggregation_;
2514 _impl_.aggregation_type_.secure_aggregation_ = nullptr;
2515 return temp;
2516 } else {
2517 return nullptr;
2518 }
2519 }
unsafe_arena_set_allocated_secure_aggregation(::fcp::client::SecureAggregation * secure_aggregation)2520 inline void FederatedComputation::unsafe_arena_set_allocated_secure_aggregation(::fcp::client::SecureAggregation* secure_aggregation) {
2521 clear_aggregation_type();
2522 if (secure_aggregation) {
2523 set_has_secure_aggregation();
2524 _impl_.aggregation_type_.secure_aggregation_ = secure_aggregation;
2525 }
2526 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:fcp.client.FederatedComputation.secure_aggregation)
2527 }
_internal_mutable_secure_aggregation()2528 inline ::fcp::client::SecureAggregation* FederatedComputation::_internal_mutable_secure_aggregation() {
2529 if (!_internal_has_secure_aggregation()) {
2530 clear_aggregation_type();
2531 set_has_secure_aggregation();
2532 _impl_.aggregation_type_.secure_aggregation_ = CreateMaybeMessage< ::fcp::client::SecureAggregation >(GetArenaForAllocation());
2533 }
2534 return _impl_.aggregation_type_.secure_aggregation_;
2535 }
mutable_secure_aggregation()2536 inline ::fcp::client::SecureAggregation* FederatedComputation::mutable_secure_aggregation() {
2537 ::fcp::client::SecureAggregation* _msg = _internal_mutable_secure_aggregation();
2538 // @@protoc_insertion_point(field_mutable:fcp.client.FederatedComputation.secure_aggregation)
2539 return _msg;
2540 }
2541
has_aggregation_type()2542 inline bool FederatedComputation::has_aggregation_type() const {
2543 return aggregation_type_case() != AGGREGATION_TYPE_NOT_SET;
2544 }
clear_has_aggregation_type()2545 inline void FederatedComputation::clear_has_aggregation_type() {
2546 _impl_._oneof_case_[0] = AGGREGATION_TYPE_NOT_SET;
2547 }
aggregation_type_case()2548 inline FederatedComputation::AggregationTypeCase FederatedComputation::aggregation_type_case() const {
2549 return FederatedComputation::AggregationTypeCase(_impl_._oneof_case_[0]);
2550 }
2551 // -------------------------------------------------------------------
2552
2553 // SimpleAggregation
2554
2555 // -------------------------------------------------------------------
2556
2557 // SecureAggregation
2558
2559 // int32 minimum_clients_in_server_visible_aggregate = 1;
clear_minimum_clients_in_server_visible_aggregate()2560 inline void SecureAggregation::clear_minimum_clients_in_server_visible_aggregate() {
2561 _impl_.minimum_clients_in_server_visible_aggregate_ = 0;
2562 }
_internal_minimum_clients_in_server_visible_aggregate()2563 inline ::int32_t SecureAggregation::_internal_minimum_clients_in_server_visible_aggregate() const {
2564 return _impl_.minimum_clients_in_server_visible_aggregate_;
2565 }
minimum_clients_in_server_visible_aggregate()2566 inline ::int32_t SecureAggregation::minimum_clients_in_server_visible_aggregate() const {
2567 // @@protoc_insertion_point(field_get:fcp.client.SecureAggregation.minimum_clients_in_server_visible_aggregate)
2568 return _internal_minimum_clients_in_server_visible_aggregate();
2569 }
_internal_set_minimum_clients_in_server_visible_aggregate(::int32_t value)2570 inline void SecureAggregation::_internal_set_minimum_clients_in_server_visible_aggregate(::int32_t value) {
2571
2572 _impl_.minimum_clients_in_server_visible_aggregate_ = value;
2573 }
set_minimum_clients_in_server_visible_aggregate(::int32_t value)2574 inline void SecureAggregation::set_minimum_clients_in_server_visible_aggregate(::int32_t value) {
2575 _internal_set_minimum_clients_in_server_visible_aggregate(value);
2576 // @@protoc_insertion_point(field_set:fcp.client.SecureAggregation.minimum_clients_in_server_visible_aggregate)
2577 }
2578
2579 // -------------------------------------------------------------------
2580
2581 // HistoricalContext
2582
2583 // .google.protobuf.Timestamp last_successful_contribution_time = 1;
_internal_has_last_successful_contribution_time()2584 inline bool HistoricalContext::_internal_has_last_successful_contribution_time() const {
2585 return this != internal_default_instance() && _impl_.last_successful_contribution_time_ != nullptr;
2586 }
has_last_successful_contribution_time()2587 inline bool HistoricalContext::has_last_successful_contribution_time() const {
2588 return _internal_has_last_successful_contribution_time();
2589 }
_internal_last_successful_contribution_time()2590 inline const ::PROTOBUF_NAMESPACE_ID::Timestamp& HistoricalContext::_internal_last_successful_contribution_time() const {
2591 const ::PROTOBUF_NAMESPACE_ID::Timestamp* p = _impl_.last_successful_contribution_time_;
2592 return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Timestamp&>(
2593 ::PROTOBUF_NAMESPACE_ID::_Timestamp_default_instance_);
2594 }
last_successful_contribution_time()2595 inline const ::PROTOBUF_NAMESPACE_ID::Timestamp& HistoricalContext::last_successful_contribution_time() const {
2596 // @@protoc_insertion_point(field_get:fcp.client.HistoricalContext.last_successful_contribution_time)
2597 return _internal_last_successful_contribution_time();
2598 }
unsafe_arena_set_allocated_last_successful_contribution_time(::PROTOBUF_NAMESPACE_ID::Timestamp * last_successful_contribution_time)2599 inline void HistoricalContext::unsafe_arena_set_allocated_last_successful_contribution_time(
2600 ::PROTOBUF_NAMESPACE_ID::Timestamp* last_successful_contribution_time) {
2601 if (GetArenaForAllocation() == nullptr) {
2602 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.last_successful_contribution_time_);
2603 }
2604 _impl_.last_successful_contribution_time_ = last_successful_contribution_time;
2605 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:fcp.client.HistoricalContext.last_successful_contribution_time)
2606 }
release_last_successful_contribution_time()2607 inline ::PROTOBUF_NAMESPACE_ID::Timestamp* HistoricalContext::release_last_successful_contribution_time() {
2608
2609 ::PROTOBUF_NAMESPACE_ID::Timestamp* temp = _impl_.last_successful_contribution_time_;
2610 _impl_.last_successful_contribution_time_ = nullptr;
2611 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
2612 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
2613 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2614 if (GetArenaForAllocation() == nullptr) { delete old; }
2615 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
2616 if (GetArenaForAllocation() != nullptr) {
2617 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2618 }
2619 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
2620 return temp;
2621 }
unsafe_arena_release_last_successful_contribution_time()2622 inline ::PROTOBUF_NAMESPACE_ID::Timestamp* HistoricalContext::unsafe_arena_release_last_successful_contribution_time() {
2623 // @@protoc_insertion_point(field_release:fcp.client.HistoricalContext.last_successful_contribution_time)
2624
2625 ::PROTOBUF_NAMESPACE_ID::Timestamp* temp = _impl_.last_successful_contribution_time_;
2626 _impl_.last_successful_contribution_time_ = nullptr;
2627 return temp;
2628 }
_internal_mutable_last_successful_contribution_time()2629 inline ::PROTOBUF_NAMESPACE_ID::Timestamp* HistoricalContext::_internal_mutable_last_successful_contribution_time() {
2630
2631 if (_impl_.last_successful_contribution_time_ == nullptr) {
2632 auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Timestamp>(GetArenaForAllocation());
2633 _impl_.last_successful_contribution_time_ = p;
2634 }
2635 return _impl_.last_successful_contribution_time_;
2636 }
mutable_last_successful_contribution_time()2637 inline ::PROTOBUF_NAMESPACE_ID::Timestamp* HistoricalContext::mutable_last_successful_contribution_time() {
2638 ::PROTOBUF_NAMESPACE_ID::Timestamp* _msg = _internal_mutable_last_successful_contribution_time();
2639 // @@protoc_insertion_point(field_mutable:fcp.client.HistoricalContext.last_successful_contribution_time)
2640 return _msg;
2641 }
set_allocated_last_successful_contribution_time(::PROTOBUF_NAMESPACE_ID::Timestamp * last_successful_contribution_time)2642 inline void HistoricalContext::set_allocated_last_successful_contribution_time(::PROTOBUF_NAMESPACE_ID::Timestamp* last_successful_contribution_time) {
2643 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
2644 if (message_arena == nullptr) {
2645 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.last_successful_contribution_time_);
2646 }
2647 if (last_successful_contribution_time) {
2648 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
2649 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
2650 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(last_successful_contribution_time));
2651 if (message_arena != submessage_arena) {
2652 last_successful_contribution_time = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2653 message_arena, last_successful_contribution_time, submessage_arena);
2654 }
2655
2656 } else {
2657
2658 }
2659 _impl_.last_successful_contribution_time_ = last_successful_contribution_time;
2660 // @@protoc_insertion_point(field_set_allocated:fcp.client.HistoricalContext.last_successful_contribution_time)
2661 }
2662
2663 #ifdef __GNUC__
2664 #pragma GCC diagnostic pop
2665 #endif // __GNUC__
2666 // -------------------------------------------------------------------
2667
2668 // -------------------------------------------------------------------
2669
2670 // -------------------------------------------------------------------
2671
2672 // -------------------------------------------------------------------
2673
2674 // -------------------------------------------------------------------
2675
2676 // -------------------------------------------------------------------
2677
2678 // -------------------------------------------------------------------
2679
2680 // -------------------------------------------------------------------
2681
2682
2683 // @@protoc_insertion_point(namespace_scope)
2684
2685 } // namespace client
2686 } // namespace fcp
2687
2688 PROTOBUF_NAMESPACE_OPEN
2689
2690 template <> struct is_proto_enum< ::fcp::client::QueryTimeComputationProperties_ExampleIteratorOutputFormat> : ::std::true_type {};
2691
2692 PROTOBUF_NAMESPACE_CLOSE
2693
2694 // @@protoc_insertion_point(global_scope)
2695
2696 #include <google/protobuf/port_undef.inc>
2697 #endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_fcp_2fclient_2fselector_5fcontext_2eproto
2698